now") == "https://example.com/a")
+ }
+
+ @Test func usesTheFirstWebURL() {
+ #expect(extract("ftp://files.example.com then https://b.example.com and https://c.example.com") == "https://b.example.com")
+ }
+
+ @Test func textWithoutAWebLinkHasNoLink() {
+ #expect(extract("javascript:alert(1)") == nil)
+ #expect(extract("file:///etc/passwd") == nil)
+ #expect(extract("mailto:someone@example.com") == nil)
+ #expect(extract("ftp://files.example.com") == nil)
+ #expect(extract("httpx://example.com") == nil)
+ }
+
+ @Test func rejectsEmptyAndHostlessInput() {
+ #expect(extract("") == nil)
+ #expect(extract(" \n") == nil)
+ #expect(extract("no links here, just httpbin and https://") == nil)
+ }
+
+ @Test func acceptsUppercaseSchemes() {
+ #expect(extract("HTTPS://EXAMPLE.COM/") == "HTTPS://EXAMPLE.COM/")
+ }
+
+ @Test func acceptsLinksUpToTheLengthLimit() {
+ let base = "https://example.com/"
+ let longest = base + String(repeating: "a", count: LinkIntake.maxURLBytes - base.utf8.count)
+ #expect(extract(longest) == longest)
+ #expect(extract("Go to " + longest + ".") == longest) // Measured after trimming.
+ #expect(extract(longest + "a") == nil)
+ // Measured as encoded: each `{` becomes `%7B`.
+ #expect(extract(base + String(repeating: "{", count: 6000)) == nil)
+ }
+
+ @Test func skipsAnOverlongTokenWholeIncludingLinksNestedInIt() {
+ let overlong = "https://example.com/" + String(repeating: "a", count: LinkIntake.maxURLBytes)
+ #expect(extract(overlong + "https://nested.example.com/") == nil)
+ #expect(extract(overlong + " https://next.example.com/") == "https://next.example.com/")
+ }
+
+ @Test(arguments: [
+ String(repeating: "http", count: 256 * 1024),
+ String(repeating: "http ", count: 100_000),
+ String(repeating: "http" + String(repeating: ")", count: 16_000) + " ", count: 16),
+ String(repeating: "http](", count: 200_000),
+ ])
+ func hostileTextIsScannedInLinearTime(_ hostile: String) {
+ // Quadratic versions took 10 s to minutes on these; linear takes well under a second.
+ let start = ContinuousClock.now
+ #expect(extract(hostile) == nil)
+ #expect(ContinuousClock.now - start < .seconds(5))
+ }
+
+ @Test func onlyLinksStartingNearTheStartOfHugeTextCount() {
+ let filler = String(repeating: "x", count: LinkIntake.maxScannedCharacters)
+ #expect(extract(filler + " https://example.com/") == nil)
+ #expect(extract("https://example.com/ " + filler) == "https://example.com/")
+ }
+
+ @Test func aLinkThatStartsBeforeTheScanLimitIsReadWhole() {
+ let link = "https://example.com/very/long/path?token=abcdef"
+ let filler = String(repeating: "x", count: LinkIntake.maxScannedCharacters - 30)
+ #expect(extract(filler + " " + link) == link)
+ }
+
+ @Test func findsTheLinkBehindSelectedHyperlinkText() {
+ func extract(html: String) -> String? { LinkIntake.extractURL(fromHTML: html)?.absoluteString }
+ #expect(extract(html: #"Amflow's latest e-bikes"#)
+ == "https://www.theverge.com/transportation/909060/amflows-latest-e-bikes")
+ #expect(extract(html: #"Verify"#)
+ == "https://www.google.com/url?q=https://example.com/&sa=D")
+ #expect(extract(html: "x") == "https://example.com/a")
+ #expect(extract(html: #"mail web"#) == "https://example.org/")
+ #expect(extract(html: "see https://example.com/page.
") == "https://example.com/page")
+ #expect(extract(html: "no links
") == nil)
+ }
+
+ @Test func validatesURLObjects() throws {
+ let web = try #require(URL(string: "https://example.com/x"))
+ #expect(LinkIntake.validate(web) == web)
+ #expect(LinkIntake.validate(try #require(URL(string: "HTTP://example.com/"))) != nil)
+ #expect(LinkIntake.validate(URL(filePath: "/etc/passwd")) == nil)
+ #expect(LinkIntake.validate(try #require(URL(string: "ftp://files.example.com/"))) == nil)
+ #expect(LinkIntake.validate(try #require(URL(string: "mailto:a@example.com"))) == nil)
+ #expect(LinkIntake.validate(try #require(URL(string: "https:///no-host"))) == nil)
+ #expect(LinkIntake.validate(try #require(URL(string: "http://:80/"))) == nil)
+ let long = "https://example.com/" + String(repeating: "a", count: LinkIntake.maxURLBytes)
+ #expect(LinkIntake.validate(try #require(URL(string: long))) == nil)
+ }
+}
diff --git a/Tests/KnotchyCoreTests/NetworkRouteTests.swift b/Tests/KnotchyCoreTests/NetworkRouteTests.swift
new file mode 100644
index 0000000..09be1fb
--- /dev/null
+++ b/Tests/KnotchyCoreTests/NetworkRouteTests.swift
@@ -0,0 +1,145 @@
+import Foundation
+import Testing
+@testable import KnotchyCore
+
+@Suite struct NetworkRouteTests {
+ static let key = Data(repeating: 7, count: 32).base64EncodedString()
+ static let otherKey = Data(repeating: 9, count: 32).base64EncodedString()
+
+ static let mullvadStyle = """
+ [Interface]
+ # Device: Quick Fox
+ PrivateKey = \(key)
+ Address = 10.64.12.34/32,fc00:bbbb:bbbb:bb01::1:c21/128
+ DNS = 10.64.0.1
+
+ [Peer]
+ PublicKey = \(otherKey)
+ AllowedIPs = 0.0.0.0/0,::0/0
+ Endpoint = se-got-wg-001.relays.mullvad.net:51820
+ """
+
+ @Test func parsesAProviderConfig() throws {
+ let config = try WireGuardConfig.parse(Self.mullvadStyle)
+ #expect(config.privateKey == Self.key)
+ #expect(config.addresses == ["10.64.12.34/32"])
+ #expect(config.dns == ["10.64.0.1"])
+ #expect(config.peerPublicKey == Self.otherKey)
+ #expect(config.endpointHost == "se-got-wg-001.relays.mullvad.net")
+ #expect(config.endpointPort == 51820)
+ #expect(config.mtu == nil)
+ #expect(config.persistentKeepalive == nil)
+ }
+
+ @Test func keysAreCaseInsensitiveAndRepeatsJoin() throws {
+ let text = """
+ [interface]
+ privatekey=\(Self.key)
+ Address = 10.2.0.2
+ Address = 10.2.0.3/32
+ DNS = 10.2.0.1, 1.1.1.1, example.search.domain
+ MTU = 1380
+ [PEER]
+ publickey = \(Self.otherKey)
+ PresharedKey = \(Self.key)
+ endpoint = 203.0.113.9:443
+ PersistentKeepalive = 15
+ """
+ let config = try WireGuardConfig.parse(text)
+ #expect(config.addresses == ["10.2.0.2/32", "10.2.0.3/32"])
+ #expect(config.dns == ["10.2.0.1", "1.1.1.1"])
+ #expect(config.mtu == 1380)
+ #expect(config.presharedKey == Self.key)
+ #expect(config.persistentKeepalive == 15)
+ }
+
+ @Test func rejectsWhatTheVMCannotUse() {
+ func parse(_ text: String) -> WireGuardConfig.ParseError? {
+ do { _ = try WireGuardConfig.parse(text); return nil } catch { return error }
+ }
+ let peer = "[Peer]\nPublicKey = \(Self.otherKey)\nEndpoint = 1.2.3.4:51820\n"
+ #expect(parse("[Interface]\nAddress = 10.0.0.2/32\n" + peer) == .missing("PrivateKey"))
+ #expect(parse("[Interface]\nPrivateKey = nope\nAddress = 10.0.0.2/32\n" + peer) == .invalid("PrivateKey"))
+ #expect(parse("[Interface]\nPrivateKey = \(Self.key)\nAddress = fd00::2/128\n" + peer) == .missing("an IPv4 Address"))
+ #expect(parse("[Interface]\nPrivateKey = \(Self.key)\nAddress = 10.0.0.2/32\n") == .missing("[Peer]"))
+ #expect(parse("[Interface]\nPrivateKey = \(Self.key)\nAddress = 10.0.0.2/32\n" + peer + peer) == .multiplePeers)
+ let v6Endpoint = "[Peer]\nPublicKey = \(Self.otherKey)\nEndpoint = [2001:db8::1]:51820\n"
+ #expect(parse("[Interface]\nPrivateKey = \(Self.key)\nAddress = 10.0.0.2/32\n" + v6Endpoint) != nil)
+ let shellEndpoint = "[Peer]\nPublicKey = \(Self.otherKey)\nEndpoint = $(reboot):51820\n"
+ #expect(parse("[Interface]\nPrivateKey = \(Self.key)\nAddress = 10.0.0.2/32\n" + shellEndpoint) == .invalid("Endpoint"))
+ #expect(parse("[Interface]\nPrivateKey = \(Self.key)\nAddress = 10.0.0.2/32\nPostUp = rm -rf /\n" + peer) == nil)
+ }
+
+ @Test func setconfForcesAFullTunnelAndAKeepalive() throws {
+ let config = try WireGuardConfig.parse(Self.mullvadStyle)
+ let setconf = config.setconf(endpointAddress: "185.213.154.66")
+ #expect(setconf == """
+ [Interface]
+ PrivateKey = \(Self.key)
+
+ [Peer]
+ PublicKey = \(Self.otherKey)
+ Endpoint = 185.213.154.66:51820
+ AllowedIPs = 0.0.0.0/0
+ PersistentKeepalive = 25
+
+ """)
+ }
+
+ @Test func proxyURLsEncodeCredentialsAndUseTheAddress() {
+ let proxy = ProxySettings(kind: .socks5, host: "proxy.example", port: 1080, username: "me@home", password: "p:w/d@!")
+ #expect(proxy.url(address: "203.0.113.7") == "socks5://me%40home:p%3Aw%2Fd%40%21@203.0.113.7:1080")
+ #expect(ProxySettings(kind: .http, host: "h", port: 8080).url(address: "10.0.0.5") == "http://10.0.0.5:8080")
+ #expect(ProxySettings(kind: .http, host: "h", port: 8080, username: "u").url(address: "10.0.0.5") == "http://u@10.0.0.5:8080")
+ }
+
+ @Test func launchKeepsSecretsOutOfTheEnvironment() throws {
+ var asked: [String] = []
+ let resolve = { (host: String) -> String in asked.append(host); return "198.51.100.4" }
+ #expect(try NetworkRoute.direct.launch(resolve: resolve) == RouteLaunch(environment: ["KNOTCHY_ROUTE=direct"], secrets: []))
+
+ let proxy = NetworkRoute.proxy(ProxySettings(kind: .http, host: "proxy.corp", port: 3128, username: "u", password: "p"))
+ #expect(try proxy.launch(resolve: resolve) == RouteLaunch(
+ environment: ["KNOTCHY_ROUTE=proxy", "KNOTCHY_PROXY_ADDR=198.51.100.4:3128"],
+ secrets: ["KNOTCHY_PROXY_URL=http://u:p@198.51.100.4:3128"]
+ ))
+
+ let wireGuard = try NetworkRoute.wireGuard(WireGuardConfig.parse(Self.mullvadStyle)).launch(resolve: resolve)
+ #expect(asked == ["proxy.corp", "se-got-wg-001.relays.mullvad.net"])
+ #expect(wireGuard.environment == [
+ "KNOTCHY_ROUTE=wireguard", "KNOTCHY_WG_ENDPOINT=198.51.100.4:51820", "KNOTCHY_WG_ADDRESS=10.64.12.34/32",
+ "KNOTCHY_WG_DNS=10.64.0.1", "KNOTCHY_WG_MTU=1420",
+ ])
+ #expect(wireGuard.environment.allSatisfy { !$0.contains(Self.key) })
+ #expect(wireGuard.secrets.count == 1 && wireGuard.secrets[0].hasPrefix("KNOTCHY_WG_SETCONF="))
+ #expect((wireGuard.environment + wireGuard.secrets).allSatisfy { !$0.contains("\n") })
+
+ #expect(throws: VMBackendError.failed("no")) { try NetworkRoute.unusable(reason: "no").launch(resolve: resolve) }
+ }
+
+ @Test func routeLabels() throws {
+ #expect(NetworkRoute.direct.label == nil)
+ #expect(NetworkRoute.proxy(ProxySettings(kind: .socks5, host: "h", port: 1)).label == "SOCKS5 proxy")
+ var config = try WireGuardConfig.parse(Self.mullvadStyle)
+ #expect(NetworkRoute.wireGuard(config).label == "VPN")
+ config.name = "sg-sin-wg-001"
+ #expect(NetworkRoute.wireGuard(config).label == "sg-sin-wg-001")
+ }
+
+ @Test func proxiesOnTheMacOrItsNetworkAreRefused() throws {
+ for local in ["10.1.2.3", "127.0.0.1", "169.254.169.254", "172.20.0.1", "192.168.64.1", "100.100.1.1", "0.0.0.0"] {
+ #expect(ProxySettings.isLocal(local, hostNetworks: []), "\(local)")
+ }
+ #expect(ProxySettings.isLocal("203.0.113.9", hostNetworks: ["203.0.113.0/24"]))
+ #expect(!ProxySettings.isLocal("203.0.113.9", hostNetworks: ["198.51.100.0/24"]))
+ #expect(!ProxySettings.isLocal("8.8.8.8", hostNetworks: []))
+ #expect(!ProxySettings.isLocal("172.32.0.1", hostNetworks: []))
+
+ let proxy = NetworkRoute.proxy(ProxySettings(kind: .http, host: "proxy.lan", port: 3128))
+ #expect(throws: VMBackendError.self) { try proxy.launch(resolve: { _ in "192.168.1.10" }) }
+ #expect(try proxy.launch(resolve: { _ in "192.168.1.10" }, allowLocalProxy: true).environment.count == 2)
+ // A local WireGuard server is fine: only wireguard-go can reach it.
+ let wireGuard = NetworkRoute.wireGuard(try WireGuardConfig.parse(Self.mullvadStyle))
+ #expect(try wireGuard.launch(resolve: { _ in "192.168.1.1" }).environment.contains("KNOTCHY_WG_ENDPOINT=192.168.1.1:51820"))
+ }
+}
diff --git a/Tests/KnotchyCoreTests/NotchGeometryTests.swift b/Tests/KnotchyCoreTests/NotchGeometryTests.swift
new file mode 100644
index 0000000..63f279d
--- /dev/null
+++ b/Tests/KnotchyCoreTests/NotchGeometryTests.swift
@@ -0,0 +1,165 @@
+import CoreGraphics
+import Testing
+@testable import KnotchyCore
+
+struct NotchGeometryTests {
+ private let macBookPro = ScreenInfo(
+ frame: CGRect(x: 0, y: 0, width: 1512, height: 982),
+ visibleFrame: CGRect(x: 0, y: 80, width: 1512, height: 870),
+ safeAreaTop: 32,
+ auxLeft: CGRect(x: 0, y: 950, width: 662, height: 32),
+ auxRight: CGRect(x: 850, y: 950, width: 662, height: 32),
+ menuBarThickness: 24
+ )
+
+ private let external = ScreenInfo(
+ frame: CGRect(x: 1512, y: -200, width: 1920, height: 1080),
+ visibleFrame: CGRect(x: 1512, y: -200, width: 1920, height: 1055),
+ safeAreaTop: 0, auxLeft: .zero, auxRight: .zero, menuBarThickness: 24
+ )
+
+ @Test func peekUnderAPhysicalNotch() {
+ let layout = NotchGeometry.layout(for: macBookPro, mode: .peek)
+ #expect(layout.notch == CGRect(x: 662, y: 950, width: 188, height: 32))
+ #expect(layout.pill == CGRect(x: 590, y: 950, width: 332, height: 32))
+ #expect(layout.panel == CGRect(x: 430, y: 510, width: 652, height: 472))
+ #expect(layout.toolbar == CGRect(x: 436, y: 916, width: 640, height: 34))
+ #expect(layout.content == CGRect(x: 436, y: 516, width: 640, height: 400))
+ #expect(layout.contentScale == 0.625)
+ }
+
+ @Test func expandedUnderAPhysicalNotch() {
+ let layout = NotchGeometry.layout(for: macBookPro, mode: .expanded)
+ #expect(layout.panel == CGRect(x: 238, y: 270, width: 1036, height: 712))
+ #expect(layout.content == CGRect(x: 244, y: 276, width: 1024, height: 640))
+ #expect(layout.contentScale == 1)
+ }
+
+ @Test func theNotchHeightIsTheSafeArea() {
+ var screen = macBookPro
+ screen.safeAreaTop = 37
+ screen.auxLeft = CGRect(x: 0, y: 945, width: 662, height: 37)
+ screen.auxRight = CGRect(x: 850, y: 945, width: 662, height: 37)
+ let layout = NotchGeometry.layout(for: screen, mode: .peek)
+ #expect(layout.notch == CGRect(x: 662, y: 945, width: 188, height: 37))
+ #expect(layout.panel.height == CGFloat(37 + 34 + 400 + 6))
+ }
+
+ @Test func aNotchNeedsASafeAreaAndBothMenuBarAreas() {
+ let virtualNotch = CGRect(x: 656, y: 950, width: 200, height: 32)
+ var noRightArea = macBookPro
+ noRightArea.auxRight = .zero
+ #expect(!noRightArea.hasNotch)
+ #expect(NotchGeometry.layout(for: noRightArea, mode: .peek).notch == virtualNotch)
+
+ var noSafeArea = macBookPro
+ noSafeArea.safeAreaTop = 0
+ #expect(!noSafeArea.hasNotch)
+ #expect(NotchGeometry.layout(for: noSafeArea, mode: .peek).notch == virtualNotch)
+ }
+
+ @Test func asymmetricEarsAndNotchWidthClamping() {
+ var screen = macBookPro
+ screen.auxLeft = CGRect(x: 0, y: 950, width: 600, height: 32)
+ screen.auxRight = CGRect(x: 850, y: 950, width: 662, height: 32)
+ #expect(NotchGeometry.layout(for: screen, mode: .peek).notch == CGRect(x: 600, y: 950, width: 250, height: 32))
+
+ screen.auxLeft = CGRect(x: 0, y: 950, width: 500, height: 32)
+ screen.auxRight = CGRect(x: 1000, y: 950, width: 512, height: 32)
+ #expect(NotchGeometry.layout(for: screen, mode: .peek).notch.width == 300)
+
+ screen.auxLeft = CGRect(x: 0, y: 950, width: 700, height: 32)
+ screen.auxRight = CGRect(x: 760, y: 950, width: 752, height: 32)
+ #expect(NotchGeometry.layout(for: screen, mode: .peek).notch == CGRect(x: 670, y: 950, width: 120, height: 32))
+ }
+
+ @Test func virtualNotchOnAScreenWithoutOne() {
+ let layout = NotchGeometry.layout(for: external, mode: .peek)
+ #expect(layout.notch == CGRect(x: 2372, y: 855, width: 200, height: 25))
+ #expect(layout.panel == CGRect(x: 2146, y: 415, width: 652, height: 465))
+ #expect(layout.content == CGRect(x: 2152, y: 421, width: 640, height: 400))
+ }
+
+ @Test func aScreenLeftOfTheMainOne() {
+ var screen = external
+ screen.frame.origin = CGPoint(x: -1920, y: 0)
+ screen.visibleFrame.origin = CGPoint(x: -1920, y: 0)
+ let layout = NotchGeometry.layout(for: screen, mode: .peek)
+ #expect(layout.notch == CGRect(x: -1060, y: 1055, width: 200, height: 25))
+ #expect(layout.panel == CGRect(x: -1286, y: 615, width: 652, height: 465))
+ }
+
+ @Test func autoHiddenMenuBarKeepsAVisibleNotch() {
+ var screen = external
+ screen.visibleFrame = screen.frame
+ screen.menuBarThickness = 0
+ #expect(NotchGeometry.layout(for: screen, mode: .peek).notch.height == 24)
+
+ screen.menuBarThickness = 30
+ #expect(NotchGeometry.layout(for: screen, mode: .peek).notch.height == 30)
+ }
+
+ @Test func expandedScalesDownOnAShortScreenKeeping16by10() {
+ let short = ScreenInfo(
+ frame: CGRect(x: 0, y: 0, width: 1280, height: 720),
+ visibleFrame: CGRect(x: 0, y: 60, width: 1280, height: 636),
+ safeAreaTop: 0, auxLeft: .zero, auxRight: .zero, menuBarThickness: 24
+ )
+ let layout = NotchGeometry.layout(for: short, mode: .expanded)
+ // Usable height: 720 - 60 (Dock) - 24 (notch) - 34 - 6 - 8 = 588, rounded down to 585.
+ #expect(layout.content.size == CGSize(width: 936, height: 585))
+ #expect(layout.content.width / layout.content.height == 1.6)
+ #expect(layout.panel.minY >= short.visibleFrame.minY)
+ #expect(layout.contentScale == CGFloat(936) / 1024)
+ #expect(NotchGeometry.layout(for: short, mode: .peek).content.size == CGSize(width: 640, height: 400))
+ }
+
+ @Test func expandedScalesDownOnANarrowScreen() {
+ let portrait = ScreenInfo(
+ frame: CGRect(x: 0, y: 0, width: 900, height: 1600),
+ visibleFrame: CGRect(x: 0, y: 0, width: 900, height: 1575),
+ safeAreaTop: 0, auxLeft: .zero, auxRight: .zero, menuBarThickness: 25
+ )
+ let layout = NotchGeometry.layout(for: portrait, mode: .expanded)
+ // Usable width: 900 - 16 - 12 = 872, which is exactly 16:10 at 545 high.
+ #expect(layout.panel == CGRect(x: 8, y: 990, width: 884, height: 610))
+ #expect(layout.content == CGRect(x: 14, y: 996, width: 872, height: 545))
+ }
+
+ @Test func aVirtualNotchIsOnWholePoints() {
+ var odd = external
+ odd.frame.size.width = 1365
+ odd.visibleFrame.size.width = 1365
+ let layout = NotchGeometry.layout(for: odd, mode: .peek)
+ #expect(layout.notch.minX == layout.notch.minX.rounded())
+ #expect(layout.panel.minX == layout.panel.minX.rounded())
+ }
+
+ @Test func mapsSurfacePointsToRenderPixels() {
+ let render = PixelSize(width: 1024, height: 640)
+ let peek = CGSize(width: 640, height: 400)
+ func point(_ p: CGPoint, _ surface: CGSize) -> [UInt16]? {
+ NotchGeometry.videoPoint(p, surfaceSize: surface, renderSize: render).map { [$0.x, $0.y] }
+ }
+ #expect(point(CGPoint(x: 320, y: 200), peek) == [512, 320])
+ #expect(point(.zero, peek) == [0, 0])
+ #expect(point(CGPoint(x: 0.5, y: 0.5), peek) == [0, 0])
+ #expect(point(CGPoint(x: 640, y: 400), peek) == [1023, 639])
+ #expect(point(CGPoint(x: -5, y: 900), peek) == [0, 639])
+ // Letterboxing: a wider surface gets 30 pt bars at the sides, a taller one 50 pt above and below.
+ #expect(point(CGPoint(x: 30, y: 0), CGSize(width: 700, height: 400)) == [0, 0])
+ #expect(point(CGPoint(x: 0, y: 450), CGSize(width: 640, height: 500)) == [0, 639])
+ #expect(point(CGPoint(x: 0, y: 50), CGSize(width: 640, height: 500)) == [0, 0])
+ }
+
+ @Test func nothingToMapOntoGivesNoPoint() {
+ let render = PixelSize(width: 1024, height: 640)
+ let peek = CGSize(width: 640, height: 400)
+ #expect(NotchGeometry.videoPoint(.zero, surfaceSize: .zero, renderSize: render) == nil)
+ #expect(NotchGeometry.videoPoint(CGPoint(x: CGFloat.nan, y: 5), surfaceSize: peek, renderSize: render) == nil)
+ #expect(NotchGeometry.videoPoint(.zero, surfaceSize: CGSize(width: CGFloat.infinity, height: CGFloat.infinity), renderSize: render) == nil)
+ #expect(NotchGeometry.videoPoint(.zero, surfaceSize: CGSize(width: CGFloat.leastNonzeroMagnitude, height: 1), renderSize: render) == nil)
+ #expect(NotchGeometry.videoPoint(.zero, surfaceSize: peek, renderSize: PixelSize(width: 70_000, height: 640)) == nil)
+ #expect(NotchGeometry.videoPoint(.zero, surfaceSize: peek, renderSize: PixelSize(width: 0, height: 640)) == nil)
+ }
+}
diff --git a/Tests/KnotchyCoreTests/RuntimeInstallerTests.swift b/Tests/KnotchyCoreTests/RuntimeInstallerTests.swift
new file mode 100644
index 0000000..c89c120
--- /dev/null
+++ b/Tests/KnotchyCoreTests/RuntimeInstallerTests.swift
@@ -0,0 +1,83 @@
+import CryptoKit
+import Foundation
+import Testing
+@testable import KnotchyCore
+
+// Serialized: each download clears leftover download folders, which other tests would still be using.
+@Suite(.serialized)
+struct RuntimeInstallerTests {
+ private func release(for data: Data, url: URL) -> ContainerRuntime.Release {
+ let hash = SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
+ return ContainerRuntime.Release(version: "1.4.1", url: url, sha256: hash, size: Int64(data.count))
+ }
+
+ private func source(_ data: Data) throws -> URL {
+ let file = FileManager.default.temporaryDirectory.appendingPathComponent("source-\(UUID().uuidString).pkg")
+ try data.write(to: file)
+ return file
+ }
+
+ private static func downloadDirectories() -> Set {
+ let names = (try? FileManager.default.contentsOfDirectory(atPath: NSTemporaryDirectory())) ?? []
+ return Set(names.filter { $0.hasPrefix("knotchy-runtime-") })
+ }
+
+ @Test func aMatchingDownloadIsKeptUntilDiscarded() async throws {
+ let data = Data("package".utf8)
+ let url = try source(data)
+ defer { try? FileManager.default.removeItem(at: url) }
+ let installer = SystemRuntimeInstaller()
+ let package = try await installer.download(release(for: data, url: url)) { _ in }
+ #expect(try Data(contentsOf: package.file) == data)
+ #expect(package.file.lastPathComponent == url.lastPathComponent)
+ installer.discard(package)
+ #expect(!FileManager.default.fileExists(atPath: package.directory.path))
+ }
+
+ @Test func aMismatchedDownloadIsDeleted() async throws {
+ let url = try source(Data("tampered".utf8))
+ defer { try? FileManager.default.removeItem(at: url) }
+ let expected = release(for: Data("package".utf8), url: url)
+ await #expect(throws: DownloadError.mismatch) {
+ _ = try await SystemRuntimeInstaller().download(expected) { _ in }
+ }
+ #expect(Self.downloadDirectories().isEmpty)
+ }
+
+ @Test func aNewDownloadClearsLeftovers() async throws {
+ let leftover = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent("knotchy-runtime-LEFTOVER")
+ try FileManager.default.createDirectory(at: leftover, withIntermediateDirectories: true)
+ let data = Data("package".utf8)
+ let url = try source(data)
+ defer { try? FileManager.default.removeItem(at: url) }
+ let installer = SystemRuntimeInstaller()
+ let package = try await installer.download(release(for: data, url: url)) { _ in }
+ #expect(!FileManager.default.fileExists(atPath: leftover.path))
+ installer.discard(package)
+ }
+
+ @Test func aFailedDownloadSaysSo() async {
+ let missing = URL(fileURLWithPath: "/nonexistent/container.pkg")
+ await #expect(throws: DownloadError.self) {
+ _ = try await SystemRuntimeInstaller().download(release(for: Data(), url: missing)) { _ in }
+ }
+ }
+
+ // Only this path of the real `openInInstaller` may run in tests: any other would open Installer.
+ @MainActor
+ @Test func aChangedPackageIsNotOpened() async throws {
+ let data = Data("package".utf8)
+ let url = try source(data)
+ defer { try? FileManager.default.removeItem(at: url) }
+ let installer = SystemRuntimeInstaller()
+ let expected = release(for: data, url: url)
+ let package = try await installer.download(expected) { _ in }
+ try Data("pAckage".utf8).write(to: package.file) // Same size, so the hash has to catch it.
+ guard case .changed = await installer.openInInstaller(package, release: expected) else {
+ Issue.record("Expected the changed package not to be opened")
+ installer.discard(package)
+ return
+ }
+ #expect(!FileManager.default.fileExists(atPath: package.directory.path))
+ }
+}
diff --git a/Tests/KnotchyCoreTests/SessionLifecycleTests.swift b/Tests/KnotchyCoreTests/SessionLifecycleTests.swift
new file mode 100644
index 0000000..95eba2b
--- /dev/null
+++ b/Tests/KnotchyCoreTests/SessionLifecycleTests.swift
@@ -0,0 +1,372 @@
+import Foundation
+import Testing
+@testable import KnotchyCore
+
+@MainActor
+@Suite(.timeLimit(.minutes(1)))
+struct SessionLifecycleTests {
+ private let first = "knotchy-00000001"
+ private let second = "knotchy-00000002"
+
+ @Test func launchSweepsOrphansFirst() async {
+ let h = Harness()
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls == [.sweep(keeping: [])])
+ #expect(h.state == .idle)
+ }
+
+ @Test func aLinkBootsConnectsAndLoadsThenPeeks() async {
+ let h = Harness()
+ h.backend.hold(.start)
+ h.connector.hold()
+ h.controller.open(Harness.url)
+ #expect(h.state == .starting(.booting, folded: false))
+ #expect(h.controller.openedURL == Harness.url)
+ #expect(h.controller.liveIDs.snapshot == [first])
+
+ await waitUntil("start runs") { h.backend.parkedCount(.start) == 1 }
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight, .start(first)])
+ #expect(h.backend.startArguments == [.init(id: first, url: Harness.url,
+ renderSize: PixelSize(width: 1024, height: 640),
+ blockCIDRs: ["192.168.1.0/24"])])
+
+ h.backend.release(.start)
+ await waitUntil("connecting") { h.state == .starting(.connecting, folded: false) }
+ await waitUntil("connect runs") { h.connector.parkedCount == 1 }
+ #expect(h.connector.socketPaths == ["/fake/\(first).sock"])
+
+ h.connector.release()
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ let stream = h.connector.connections[0]
+ #expect(h.controller.connection === stream)
+
+ stream.emit(.hello(version: 1, size: SessionController.renderSize))
+ stream.emit(.contentReady)
+ await waitUntil("live") { h.state == .live(.peek) }
+ }
+
+ @Test func thePageURLFollowsTheVMButNeverReplacesTheOpenedLink() async {
+ let h = Harness()
+ let stream = await h.goLive()
+ #expect(h.controller.pageURL == nil)
+ let next = URL(string: "https://example.org/next")!
+ stream.emit(.pageURL(next))
+ await waitUntil("the page URL shows") { h.controller.pageURL == next }
+ #expect(h.controller.openedURL == Harness.url)
+
+ h.controller.open(URL(string: "https://example.net/")!)
+ #expect(h.controller.pageURL == nil)
+ }
+
+ @Test func destroyIsConfirmedBeforeDestroyedShowsThenGoesIdle() async {
+ let h = Harness()
+ let stream = await h.goLive()
+ h.backend.hold(.destroy)
+ h.controller.destroy()
+ #expect(h.state == .destroying)
+ #expect(stream.isClosed)
+ #expect(h.controller.connection == nil)
+
+ await waitUntil("destroy runs") { h.backend.parkedCount(.destroy) == 1 }
+ #expect(h.state == .destroying)
+ #expect(h.controller.liveIDs.snapshot == [first])
+
+ h.backend.release(.destroy)
+ await waitUntil("destroyed") { h.state == .destroyed }
+ #expect(h.controller.liveIDs.snapshot.isEmpty)
+ h.advance(by: .milliseconds(1499))
+ #expect(h.state == .destroyed)
+ h.advance(by: .milliseconds(1))
+ #expect(h.state == .idle)
+ #expect(h.controller.openedURL == nil)
+ }
+
+ @Test(arguments: [LiveMode.peek, .expanded, .collapsed])
+ func destroyWorksFromEveryLiveMode(_ mode: LiveMode) async {
+ let h = Harness()
+ await h.goLive()
+ h.enter(mode)
+ #expect(h.state == .live(mode))
+ h.controller.destroy()
+ #expect(h.state == .destroying)
+ #expect(h.controller.countdown == nil)
+ await waitUntil("destroyed") { h.state == .destroyed }
+ }
+
+ @Test func destroyDuringPreflightNeverCallsTheBackendsDestroy() async {
+ let h = Harness()
+ h.backend.hold(.preflight)
+ h.controller.open(Harness.url)
+ await waitUntil("preflight runs") { h.backend.parkedCount(.preflight) == 1 }
+ h.controller.destroy()
+ h.backend.release(.preflight)
+ await waitUntil("destroyed") { h.state == .destroyed }
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight])
+ #expect(h.controller.liveIDs.snapshot.isEmpty)
+ }
+
+ @Test func destroyWhileConnectingClosesTheLateStream() async {
+ let h = Harness()
+ h.connector.hold()
+ h.controller.open(Harness.url)
+ await waitUntil("connect runs") { h.connector.parkedCount == 1 }
+ h.controller.destroy()
+ await waitUntil("destroyed") { h.state == .destroyed }
+ h.connector.release()
+ await waitUntil("the late stream is closed") { h.connector.connections.first?.isClosed == true }
+ #expect(h.state == .destroyed)
+ #expect(h.controller.connection == nil)
+ h.advance(by: .milliseconds(1500))
+ #expect(h.state == .idle)
+ }
+
+ @Test func aConnectThatFailsAfterDestroyIsIgnored() async {
+ let h = Harness()
+ h.connector.hold()
+ h.connector.failNextConnect(with: .timedOut)
+ h.backend.hold(.destroy)
+ h.controller.open(Harness.url)
+ await waitUntil("connect runs") { h.connector.parkedCount == 1 }
+ h.controller.destroy()
+ await waitUntil("destroy runs") { h.backend.parkedCount(.destroy) == 1 }
+ h.connector.release()
+ await h.controller.waitForSessionTasks()
+ #expect(h.state == .destroying) // Not the failed connect's error card.
+ h.backend.release(.destroy)
+ await waitUntil("destroyed") { h.state == .destroyed }
+ }
+
+ @Test func destroyWhileBootingDestroysTheVMOnceStartReturns() async {
+ let h = Harness()
+ h.backend.hold(.start)
+ h.controller.open(Harness.url)
+ await waitUntil("start runs") { h.backend.parkedCount(.start) == 1 }
+ h.controller.destroy()
+ #expect(h.state == .destroying)
+ h.backend.release(.start)
+ await waitUntil("destroyed") { h.state == .destroyed }
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight, .start(first), .destroy(first)])
+ #expect(h.connector.socketPaths.isEmpty)
+ }
+
+ @Test func aStuckDestroyShowsTheAmberPillAndCanBeRetried() async {
+ let h = Harness()
+ await h.goLive()
+ h.backend.failDestroys(with: VMBackendError.destroyStuck(id: first))
+ h.controller.destroy()
+ await waitUntil("stuck") { h.state == .failed(.destroyStuck) }
+ #expect(h.controller.liveIDs.snapshot == [first])
+
+ h.backend.failDestroys(with: nil)
+ h.controller.retry()
+ #expect(h.state == .destroying)
+ await waitUntil("destroyed") { h.state == .destroyed }
+ #expect(h.backend.calls.filter { $0 == .destroy(first) }.count == 2)
+ #expect(h.controller.liveIDs.snapshot.isEmpty)
+ }
+
+ @Test func aRetryNeverRetriesItself() async {
+ let h = Harness()
+ await h.goLive()
+ h.backend.failDestroys(with: VMBackendError.destroyStuck(id: first))
+ h.controller.destroy()
+ await waitUntil("stuck") { h.state == .failed(.destroyStuck) }
+
+ h.controller.retry() // Fails again: its own job must not also force-destroy the VM.
+ await h.controller.waitForBackendIdle()
+ #expect(h.state == .failed(.destroyStuck))
+
+ h.backend.failDestroys(with: nil)
+ h.controller.retry()
+ await waitUntil("destroyed") { h.state == .destroyed }
+ await h.controller.waitForBackendIdle()
+ #expect(!h.backend.calls.contains(.forceDestroy(first)))
+ }
+
+ @Test func theStuckPillGoesIdleAfter30sAndTheVMStaysListed() async {
+ let h = Harness()
+ await h.goLive()
+ h.backend.failDestroys(with: VMBackendError.destroyStuck(id: first))
+ h.controller.destroy()
+ await waitUntil("stuck") { h.state == .failed(.destroyStuck) }
+ h.advance(by: .seconds(29))
+ #expect(h.state == .failed(.destroyStuck))
+ h.advance(by: .seconds(1))
+ #expect(h.state == .idle)
+ #expect(h.controller.liveIDs.snapshot == [first])
+ }
+
+ @Test func eachLaterJobRetriesAStuckVMOnce() async {
+ let h = Harness()
+ await h.goLive()
+ h.backend.failDestroys(with: VMBackendError.destroyStuck(id: first))
+ h.controller.destroy()
+ await waitUntil("stuck") { h.state == .failed(.destroyStuck) }
+ await h.controller.waitForBackendIdle()
+ #expect(!h.backend.calls.contains(.forceDestroy(first)))
+
+ h.backend.failDestroys(with: nil)
+ h.backend.failForceDestroys(with: VMBackendError.destroyStuck(id: first))
+ await h.goLive(Harness.otherURL)
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls.filter { $0 == .forceDestroy(first) }.count == 1)
+ #expect(h.controller.liveIDs.snapshot == [first, second])
+
+ h.backend.failForceDestroys(with: nil)
+ h.controller.destroy() // Destroying `second` is a later job: `first` gets another retry.
+ await waitUntil("destroyed") { h.state == .destroyed }
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls.filter { $0 == .forceDestroy(first) }.count == 2)
+ #expect(h.controller.liveIDs.snapshot.isEmpty)
+ }
+
+ @Test func stuckVMsTakeTurnsForRetries() async {
+ let h = Harness()
+ h.backend.failDestroys(with: VMBackendError.destroyStuck(id: "any"))
+ h.backend.failForceDestroys(with: VMBackendError.destroyStuck(id: "any"))
+ await h.goLive()
+ h.controller.destroy()
+ await waitUntil("the first VM is stuck") { h.state == .failed(.destroyStuck) }
+ await h.goLive(Harness.otherURL)
+ h.controller.destroy()
+ await waitUntil("the second VM is stuck") { h.state == .failed(.destroyStuck) }
+ await h.goLive()
+ await h.controller.waitForBackendIdle()
+ let retries = h.backend.calls.filter { if case .forceDestroy = $0 { true } else { false } }
+ #expect(retries == [.forceDestroy(first), .forceDestroy(first), .forceDestroy(second)])
+ }
+
+ @Test func aStartFailureShowsTheErrorCardAndQueuesDestroy() async {
+ let h = Harness()
+ h.backend.failStarts(with: VMBackendError.failed("container run timed out"))
+ h.controller.open(Harness.url)
+ await waitUntil("failed") { h.state == .failed(.start("container run timed out")) }
+ await waitUntil("the VM is destroyed") { h.backend.calls.contains(.destroy(first)) }
+ await waitUntil("gone") { h.controller.liveIDs.snapshot.isEmpty }
+
+ h.backend.failStarts(with: nil)
+ h.controller.retry()
+ #expect(h.state == .starting(.booting, folded: false))
+ #expect(h.controller.openedURL == Harness.url)
+ await waitUntil("the retry starts") { h.backend.calls.contains(.start(second)) }
+ }
+
+ @Test func dismissingTheErrorCardGoesIdle() async {
+ let h = Harness()
+ h.backend.failStarts(with: VMBackendError.failed("boom"))
+ h.controller.open(Harness.url)
+ await waitUntil("failed") { h.state == .failed(.start("boom")) }
+ h.controller.dismiss()
+ #expect(h.state == .idle)
+ #expect(h.controller.openedURL == nil)
+ }
+
+ @Test func aConnectFailureFailsTheStart() async {
+ let h = Harness()
+ h.connector.failNextConnect(with: .timedOut)
+ h.controller.open(Harness.url)
+ await waitUntil("failed") { h.state == .failed(.start("The VM didn't answer in time.")) }
+ await waitUntil("the VM is destroyed") { h.backend.calls.contains(.destroy(first)) }
+ }
+
+ @Test func aVersionMismatchAsksForARebuildAndDestroysTheVM() async {
+ let h = Harness()
+ h.connector.failNextConnect(with: .versionMismatch(found: 0, need: 1))
+ h.backend.hold(.destroy)
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") {
+ h.state == .setupRequired(.imageOutdated(found: 0, need: 1), error: nil)
+ }
+ await waitUntil("destroy runs") { h.backend.parkedCount(.destroy) == 1 }
+ #expect(h.controller.liveIDs.snapshot == [first]) // Kept until the destroy is confirmed.
+ h.backend.release(.destroy)
+ await waitUntil("gone") { h.controller.liveIDs.snapshot.isEmpty }
+ }
+
+ @Test func theStreamEndingWhileStartingFailsTheStart() async {
+ let h = Harness()
+ let stream = await h.openAndConnect()
+ stream.emit(.ended(.noFirstFrame))
+ await waitUntil("failed") { h.state == .failed(.start("The VM didn't send a first frame in time.")) }
+ await waitUntil("the VM is destroyed") { h.backend.calls.contains(.destroy(first)) }
+ }
+
+ @Test func theStreamEndingWhileLiveShowsSessionEndedFor3s() async {
+ let h = Harness()
+ let stream = await h.goLive()
+ stream.emit(.ended(.closed))
+ await waitUntil("ended") { h.state == .failed(.ended(.closed)) }
+ await waitUntil("the VM is destroyed") { h.backend.calls.contains(.destroy(first)) }
+ h.advance(by: .milliseconds(2999))
+ #expect(h.state == .failed(.ended(.closed)))
+ h.advance(by: .milliseconds(1))
+ #expect(h.state == .idle)
+ }
+
+ @Test(arguments: [LiveMode.peek, .expanded, .collapsed])
+ func theStreamEndingInEveryLiveModeShowsSessionEnded(_ mode: LiveMode) async {
+ let h = Harness()
+ let stream = await h.goLive()
+ h.enter(mode)
+ stream.emit(.ended(.decodeErrors))
+ await waitUntil("ended") { h.state == .failed(.ended(.decodeErrors)) }
+ #expect(h.controller.countdown == nil)
+ #expect(h.controller.connection == nil)
+ }
+
+ @Test func aStreamThatFinishesWithoutEndedStillEnds() async {
+ let h = Harness()
+ let stream = await h.goLive()
+ stream.finishEvents()
+ await waitUntil("ended") { h.state == .failed(.ended(.closed)) }
+ await waitUntil("the VM is destroyed") { h.backend.calls.contains(.destroy(first)) }
+ }
+
+ @Test func theAppQuitsItselfAfter60sIdle() {
+ let h = Harness()
+ h.advance(by: .seconds(59))
+ #expect(h.recorder.quitRequests == 0)
+ h.advance(by: .seconds(1))
+ #expect(h.recorder.quitRequests == 1)
+ }
+
+ @Test func theIdleQuitTimerRestartsWheneverIdleStarts() async {
+ let h = Harness()
+ h.advance(by: .seconds(30))
+ await h.goLive()
+ h.advance(by: .seconds(60))
+ #expect(h.recorder.quitRequests == 0)
+
+ h.controller.destroy()
+ await waitUntil("destroyed") { h.state == .destroyed }
+ h.advance(by: .milliseconds(1500))
+ #expect(h.state == .idle)
+ h.advance(by: .seconds(59))
+ #expect(h.recorder.quitRequests == 0)
+ h.advance(by: .seconds(1))
+ #expect(h.recorder.quitRequests == 1)
+ }
+
+ @Test func noLinkOpensOnceTheChainIsClosedForQuitting() async {
+ let h = Harness()
+ h.controller.closeBackendChain()
+ h.controller.open(Harness.url)
+ #expect(h.state == .idle)
+ }
+
+ @Test func theQuitSnapshotIncludesAStartInFlight() async {
+ let h = Harness()
+ h.backend.hold(.start)
+ h.controller.open(Harness.url)
+ await waitUntil("start runs") { h.backend.parkedCount(.start) == 1 }
+ h.controller.closeBackendChain()
+ #expect(h.controller.liveIDs.snapshot == [first])
+
+ // Nothing may destroy the VM behind the quit path's back.
+ h.backend.release(.start)
+ await h.controller.waitForBackendIdle()
+ #expect(!h.backend.calls.contains(.destroy(first)))
+ #expect(h.controller.liveIDs.snapshot == [first])
+ }
+}
diff --git a/Tests/KnotchyCoreTests/SessionNewLinkTests.swift b/Tests/KnotchyCoreTests/SessionNewLinkTests.swift
new file mode 100644
index 0000000..39b955e
--- /dev/null
+++ b/Tests/KnotchyCoreTests/SessionNewLinkTests.swift
@@ -0,0 +1,204 @@
+import Foundation
+import Testing
+@testable import KnotchyCore
+
+@MainActor
+@Suite(.timeLimit(.minutes(1)))
+struct SessionNewLinkTests {
+ private let first = "knotchy-00000001"
+ private let second = "knotchy-00000002"
+
+ @Test func fromLiveTheOldVMIsDestroyedAndTheNewOneStartsAtOnce() async {
+ let h = Harness()
+ let old = await h.goLive()
+ h.controller.open(Harness.otherURL)
+ #expect(h.state == .starting(.booting, folded: false))
+ #expect(h.controller.openedURL == Harness.otherURL)
+ #expect(old.isClosed)
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight, .start(first), .destroy(first), .preflight, .start(second)])
+ }
+
+ @Test func aStartThatHasNotBegunNeverRuns() async {
+ let h = Harness()
+ h.controller.open(Harness.url)
+ h.controller.open(Harness.otherURL)
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight, .start(second)])
+ #expect(h.controller.liveIDs.snapshot == [second])
+ }
+
+ @Test func aSupersededStartIsDestroyedRightAfterItReturns() async {
+ let h = Harness()
+ h.backend.hold(.start)
+ h.controller.open(Harness.url)
+ await waitUntil("start runs") { h.backend.parkedCount(.start) == 1 }
+ h.controller.open(Harness.otherURL)
+ #expect(h.controller.liveIDs.snapshot == [first, second])
+
+ h.backend.release(.start)
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight, .start(first), .destroy(first), .preflight, .start(second)])
+ await waitUntil("the new session connects") { h.connector.socketPaths == ["/fake/\(second).sock"] }
+ #expect(h.controller.liveIDs.snapshot == [second])
+ }
+
+ @Test func aConnectThatReturnsAfterANewLinkIsClosed() async {
+ let h = Harness()
+ h.connector.hold()
+ h.controller.open(Harness.url)
+ await waitUntil("connect runs") { h.connector.parkedCount == 1 }
+ h.backend.hold(.start)
+ h.controller.open(Harness.otherURL)
+ await waitUntil("the new start runs") { h.backend.parkedCount(.start) == 1 }
+
+ h.connector.release()
+ await waitUntil("the late stream is closed") { h.connector.connections.first?.isClosed == true }
+ #expect(h.state == .starting(.booting, folded: false))
+ #expect(h.controller.connection == nil)
+
+ h.backend.release(.start)
+ await waitUntil("the new session connects") { h.state == .starting(.loading, folded: false) }
+ #expect((h.controller.connection as? FakeStreamConnection)?.socketPath == "/fake/\(second).sock")
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight, .start(first), .destroy(first), .preflight, .start(second)])
+ }
+
+ @Test func aSupersededStartThatFailsLeavesTheNewSessionAlone() async {
+ let h = Harness()
+ h.backend.hold(.start)
+ h.backend.hold(.destroy)
+ h.controller.open(Harness.url)
+ await waitUntil("start runs") { h.backend.parkedCount(.start) == 1 }
+ h.controller.open(Harness.otherURL)
+ h.backend.failStarts(with: VMBackendError.failed("boom"))
+ h.backend.release(.start)
+ await waitUntil("the old VM's destroy runs") { h.backend.parkedCount(.destroy) == 1 }
+ #expect(h.state == .starting(.booting, folded: false)) // Not the old start's error card.
+ h.backend.failStarts(with: nil)
+ h.backend.release(.destroy)
+ await waitUntil("the new session connects") { h.state == .starting(.loading, folded: false) }
+ }
+
+ @Test func anOldSessionsStuckDestroyDoesNotDriveTheCurrentPill() async {
+ let h = Harness()
+ await h.goLive()
+ h.backend.hold(.destroy)
+ h.backend.failDestroys(with: VMBackendError.destroyStuck(id: first))
+ h.controller.destroy()
+ await waitUntil("destroy runs") { h.backend.parkedCount(.destroy) == 1 }
+ h.controller.open(Harness.otherURL)
+ h.controller.destroy() // The new session never started a VM, so this one succeeds.
+ h.backend.release(.destroy)
+ await h.controller.waitForBackendIdle()
+ #expect(h.state == .destroyed)
+ }
+
+ @Test func liveIDsCoverASupersededSessionUntilItsDestroyIsConfirmed() async {
+ let h = Harness()
+ await h.goLive()
+ h.backend.hold(.destroy)
+ h.controller.open(Harness.otherURL)
+ await waitUntil("destroy runs") { h.backend.parkedCount(.destroy) == 1 }
+ #expect(h.controller.liveIDs.snapshot == [first, second])
+ h.backend.release(.destroy)
+ await h.controller.waitForBackendIdle()
+ #expect(h.controller.liveIDs.snapshot == [second])
+ }
+
+ @Test func fromDestroyingTheNewSessionStartsAfterTheDestroy() async {
+ let h = Harness()
+ await h.goLive()
+ h.backend.hold(.destroy)
+ h.controller.destroy()
+ await waitUntil("destroy runs") { h.backend.parkedCount(.destroy) == 1 }
+ h.controller.open(Harness.otherURL)
+ #expect(h.state == .starting(.booting, folded: false))
+
+ h.backend.release(.destroy)
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls.suffix(3) == [.destroy(first), .preflight, .start(second)])
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ }
+
+ @Test func fromTheCollapsedPillTheNewLinkOpensThePanel() async {
+ let h = Harness()
+ await h.goLive()
+ h.controller.clickedOutside()
+ h.controller.open(Harness.otherURL)
+ #expect(h.state == .starting(.booting, folded: false))
+ #expect(h.controller.countdown == nil)
+ }
+
+ @Test func fromDestroyedTheCheckmarkIsCutShort() async {
+ let h = Harness()
+ await h.goLive()
+ h.controller.destroy()
+ await waitUntil("destroyed") { h.state == .destroyed }
+ h.controller.open(Harness.otherURL)
+ #expect(h.state == .starting(.booting, folded: false))
+ h.advance(by: .seconds(2))
+ #expect(h.state != .idle)
+ }
+
+ @Test func fromSessionEndedThePillIsCutShort() async {
+ let h = Harness()
+ let stream = await h.goLive()
+ stream.emit(.ended(.closed))
+ await waitUntil("ended") { h.state == .failed(.ended(.closed)) }
+ h.controller.open(Harness.otherURL)
+ #expect(h.state == .starting(.booting, folded: false))
+ h.advance(by: .seconds(3))
+ #expect(h.state != .idle)
+ }
+
+ @Test func fromTheErrorCardTheNewLinkStarts() async {
+ let h = Harness()
+ h.backend.failStarts(with: VMBackendError.failed("boom"))
+ h.controller.open(Harness.url)
+ await waitUntil("failed") { h.state == .failed(.start("boom")) }
+ h.backend.failStarts(with: nil)
+ h.controller.open(Harness.otherURL)
+ #expect(h.state == .starting(.booting, folded: false))
+ await waitUntil("the new start runs") { h.backend.calls.contains(.start(second)) }
+ }
+
+ @Test func fromAStuckDestroyTheStuckVMStaysOnPendingCleanup() async {
+ let h = Harness()
+ await h.goLive()
+ h.backend.failDestroys(with: VMBackendError.destroyStuck(id: first))
+ h.backend.failForceDestroys(with: VMBackendError.destroyStuck(id: first))
+ h.controller.destroy()
+ await waitUntil("stuck") { h.state == .failed(.destroyStuck) }
+ h.controller.open(Harness.otherURL)
+ #expect(h.state == .starting(.booting, folded: false))
+ await h.controller.waitForBackendIdle()
+ #expect(h.controller.liveIDs.snapshot == [first, second])
+ }
+
+ @Test func fromSetupRequiredPreflightRunsAgain() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.imageMissing))
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") { h.state == .setupRequired(.imageMissing, error: nil) }
+ h.controller.open(Harness.otherURL)
+ #expect(h.state == .starting(.booting, folded: false))
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight, .preflight, .start(second)])
+ }
+
+ @Test func backendCallsNeverOverlap() async {
+ let h = Harness()
+ h.backend.hold(.start)
+ h.controller.open(Harness.url)
+ await waitUntil("start runs") { h.backend.parkedCount(.start) == 1 }
+ h.controller.open(Harness.otherURL)
+ h.controller.open(Harness.url)
+ h.controller.destroy()
+ h.controller.open(Harness.otherURL)
+ h.backend.release(.start)
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.maxConcurrentCalls == 1)
+ #expect(h.controller.liveIDs.snapshot == ["knotchy-00000004"])
+ }
+}
diff --git a/Tests/KnotchyCoreTests/SessionPanelTests.swift b/Tests/KnotchyCoreTests/SessionPanelTests.swift
new file mode 100644
index 0000000..ac58cc4
--- /dev/null
+++ b/Tests/KnotchyCoreTests/SessionPanelTests.swift
@@ -0,0 +1,340 @@
+import Foundation
+import Testing
+@testable import KnotchyCore
+
+@MainActor
+@Suite(.timeLimit(.minutes(1)))
+struct SessionPanelTests {
+ @Test func aFreshPanelStaysOpenUntilEnteredOrFor30s() async {
+ let h = Harness()
+ await h.goLive()
+ h.advance(by: .milliseconds(29_999))
+ #expect(h.state == .live(.peek))
+ h.advance(by: .milliseconds(1))
+ #expect(h.state == .live(.collapsed))
+ }
+
+ @Test func theFirstClickOutsideFoldsAnUnengagedPanel() async {
+ let h = Harness()
+ await h.goLive()
+ h.controller.clickedOutside()
+ #expect(h.state == .live(.collapsed))
+ }
+
+ @Test func anEnteredPeekFolds400msAfterThePointerLeaves() async {
+ let h = Harness()
+ await h.goLive()
+ h.controller.pointerEntered()
+ h.advance(by: .seconds(60))
+ #expect(h.state == .live(.peek)) // Entered: the 30 s fold no longer applies.
+
+ h.controller.pointerExited()
+ h.advance(by: .milliseconds(399))
+ #expect(h.state == .live(.peek))
+ h.advance(by: .milliseconds(1))
+ #expect(h.state == .live(.collapsed))
+ }
+
+ @Test func comingBackWithinTheGraceKeepsItOpen() async {
+ let h = Harness()
+ await h.goLive()
+ h.controller.pointerEntered()
+ h.controller.pointerExited()
+ h.advance(by: .milliseconds(200))
+ h.controller.pointerEntered()
+ h.advance(by: .seconds(1))
+ #expect(h.state == .live(.peek))
+ }
+
+ @Test func afterAClickInsideOnlyAClickOutsideFolds() async {
+ let h = Harness()
+ await h.goLive()
+ h.controller.pointerEntered()
+ h.controller.panelClicked()
+ h.controller.pointerExited()
+ h.advance(by: .seconds(60))
+ #expect(h.state == .live(.peek))
+ h.controller.clickedOutside()
+ #expect(h.state == .live(.collapsed))
+ }
+
+ @Test func expandedFoldsOnlyOnAClickOutside() async {
+ let h = Harness()
+ await h.goLive()
+ h.controller.pointerEntered()
+ h.controller.expand()
+ #expect(h.state == .live(.expanded))
+ h.controller.pointerExited()
+ h.advance(by: .seconds(60))
+ #expect(h.state == .live(.expanded))
+
+ h.controller.shrink()
+ #expect(h.state == .live(.peek))
+ h.controller.pointerEntered()
+ h.controller.pointerExited()
+ h.advance(by: .seconds(1))
+ #expect(h.state == .live(.peek)) // Still key after Expanded: pointer-away doesn't fold.
+
+ h.controller.expand()
+ h.controller.clickedOutside()
+ #expect(h.state == .live(.collapsed))
+ }
+
+ @Test func expandAndShrinkOnlyApplyToTheirModes() async {
+ let h = Harness()
+ h.controller.expand()
+ #expect(h.state == .idle)
+ await h.goLive()
+ h.controller.shrink()
+ #expect(h.state == .live(.peek))
+ h.controller.clickedOutside()
+ h.controller.expand()
+ #expect(h.state == .live(.collapsed))
+ }
+
+ @Test func hoveringThePillReopensPeek() async {
+ let h = Harness()
+ await h.goLive()
+ h.controller.clickedOutside()
+ h.controller.pointerEntered()
+ #expect(h.state == .live(.peek))
+ h.controller.pointerExited()
+ h.advance(by: .milliseconds(400))
+ #expect(h.state == .live(.collapsed))
+ }
+
+ @Test func theIdleCountdownRunsOnlyWhileCollapsedAndResetsOnReopen() async {
+ let h = Harness()
+ await h.goLive()
+ #expect(h.controller.countdown == nil)
+ h.controller.clickedOutside()
+ #expect(h.controller.countdown == .seconds(300))
+
+ h.advance(by: .seconds(240))
+ #expect(h.controller.countdown == .seconds(60))
+ h.controller.pointerEntered()
+ #expect(h.controller.countdown == nil)
+ h.advance(by: .seconds(120))
+ #expect(h.state == .live(.peek))
+
+ h.controller.clickedOutside()
+ #expect(h.controller.countdown == .seconds(300))
+ h.advance(by: .seconds(300) - .milliseconds(1))
+ #expect(h.state == .live(.collapsed))
+ h.advance(by: .milliseconds(1))
+ #expect(h.state == .destroying)
+ await waitUntil("destroyed") { h.state == .destroyed }
+ }
+
+ @Test func decodingPausesWhileCollapsed() async {
+ let h = Harness()
+ let stream = await h.goLive()
+ h.controller.clickedOutside()
+ #expect(stream.decodeChanges == [false])
+ h.controller.pointerEntered()
+ #expect(stream.decodeChanges == [false, true])
+ }
+
+ @Test func foldingWhileStartingShowsThePillAndStaysFoldedWhenReady() async {
+ let h = Harness()
+ h.connector.hold()
+ h.controller.open(Harness.url)
+ h.controller.clickedOutside()
+ #expect(h.state == .starting(.booting, folded: true))
+
+ await waitUntil("connecting") { h.state == .starting(.connecting, folded: true) }
+ h.connector.release()
+ await waitUntil("loading") { h.state == .starting(.loading, folded: true) }
+
+ let stream = h.connector.connections[0]
+ stream.emit(.contentReady)
+ await waitUntil("collapsed") { h.state == .live(.collapsed) }
+ #expect(h.controller.countdown == .seconds(300))
+ #expect(stream.decodeChanges == [false])
+ }
+
+ @Test func hoveringTheStartingPillUnfoldsIt() async {
+ let h = Harness()
+ h.backend.hold(.start)
+ h.controller.open(Harness.url)
+ h.controller.clickedOutside()
+ h.controller.pointerEntered()
+ #expect(h.state == .starting(.booting, folded: false))
+ h.controller.pointerExited()
+ h.advance(by: .milliseconds(400))
+ #expect(h.state == .starting(.booting, folded: true))
+ h.backend.release(.start)
+ }
+
+ @Test func aGraceFoldStartedWhileStartingCarriesIntoPeek() async {
+ let h = Harness()
+ let stream = await h.openAndConnect()
+ h.controller.pointerEntered()
+ h.controller.pointerExited()
+ h.advance(by: .milliseconds(200))
+ stream.emit(.contentReady)
+ await waitUntil("live") { h.state == .live(.peek) }
+ h.advance(by: .milliseconds(200))
+ #expect(h.state == .live(.collapsed))
+ }
+
+ @Test func retryKeepsThePanelEnteredWhenThePointerIsOnIt() async {
+ let h = Harness()
+ h.backend.failStarts(with: VMBackendError.failed("boom"))
+ h.controller.open(Harness.url)
+ await waitUntil("failed") { h.state == .failed(.start("boom")) }
+ h.backend.failStarts(with: nil)
+ h.controller.pointerEntered()
+ h.controller.retry()
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ h.connector.connections[0].emit(.contentReady)
+ await waitUntil("live") { h.state == .live(.peek) }
+
+ h.advance(by: .seconds(30))
+ #expect(h.state == .live(.peek))
+ h.controller.pointerExited()
+ h.advance(by: .milliseconds(400))
+ #expect(h.state == .live(.collapsed))
+ }
+
+ @Test func pointerInputDoesNothingWithoutAnOpenPanel() async {
+ let h = Harness()
+ h.controller.clickedOutside()
+ h.controller.pointerEntered()
+ h.controller.pointerExited()
+ h.controller.panelClicked()
+ #expect(h.state == .idle)
+ }
+}
+
+@MainActor
+@Suite(.timeLimit(.minutes(1)))
+struct SessionProgressTests {
+ @Test func showsTheLatestProgressWhileStarting() async {
+ let h = Harness()
+ let stream = await h.openAndConnect()
+ stream.emit(.progress(10))
+ await waitUntil("10 %") { h.controller.progress == 10 }
+ stream.emit(.progress(60))
+ await waitUntil("60 %") { h.controller.progress == 60 }
+ h.advance(by: .seconds(10))
+ #expect(h.controller.progress == 60) // No hiding before content is ready.
+ }
+
+ @Test func hidesAtProgress100() async {
+ let h = Harness()
+ let stream = await h.openAndConnect()
+ stream.emit(.progress(30))
+ await waitUntil("30 %") { h.controller.progress == 30 }
+ stream.emit(.progress(100))
+ await waitUntil("hidden") { h.controller.progress == nil }
+ }
+
+ @Test func onceReadyItHides2sAfterTheLastProgress() async {
+ let h = Harness()
+ let stream = await h.openAndConnect()
+ stream.emit(.progress(30))
+ stream.emit(.contentReady)
+ await waitUntil("live") { h.state == .live(.peek) }
+ #expect(h.controller.progress == 30)
+ h.advance(by: .milliseconds(1999))
+ #expect(h.controller.progress == 30)
+ h.advance(by: .milliseconds(1))
+ #expect(h.controller.progress == nil)
+ }
+
+ @Test func aLoadThatNeverReports100StillHidesWhenReady() async {
+ let h = Harness()
+ let stream = await h.openAndConnect()
+ stream.emit(.progress(30))
+ await waitUntil("30 %") { h.controller.progress == 30 }
+ h.advance(by: .seconds(5))
+ stream.emit(.contentReady)
+ await waitUntil("live") { h.state == .live(.peek) }
+ #expect(h.controller.progress == nil)
+ }
+
+ @Test func endingASessionHidesTheBar() async {
+ let h = Harness()
+ let stream = await h.openAndConnect()
+ stream.emit(.progress(40))
+ await waitUntil("40 %") { h.controller.progress == 40 }
+ stream.emit(.ended(.closed))
+ await waitUntil("failed") { h.state == .failed(.start("The VM closed the connection.")) }
+ #expect(h.controller.progress == nil)
+ }
+
+ @Test func progressAfterReadyShowsAgainThenHides() async {
+ let h = Harness()
+ let stream = await h.goLive()
+ stream.emit(.progress(20))
+ await waitUntil("20 %") { h.controller.progress == 20 }
+ h.advance(by: .seconds(2))
+ #expect(h.controller.progress == nil)
+ }
+}
+
+@MainActor
+@Suite(.timeLimit(.minutes(1)))
+struct SessionToolbarTests {
+ @Test func navigateSendsTheURLAndUpdatesTheAddress() async throws {
+ let h = Harness()
+ let stream = await h.goLive()
+ let url = try #require(URL(string: "https://example.net/page"))
+ h.controller.navigate(url)
+ #expect(stream.sent == [.navigate("https://example.net/page")])
+ #expect(h.controller.openedURL == url)
+ }
+
+ @Test func backForwardAndReloadRunScripts() async {
+ let h = Harness()
+ let stream = await h.goLive()
+ h.controller.goBack()
+ h.controller.goForward()
+ h.controller.reload()
+ #expect(stream.sent == [.script("history.back()"), .script("history.forward()"), .script("location.reload()")])
+ }
+
+ @Test func toolbarActionsNeedALiveSession() async {
+ let h = Harness()
+ let stream = await h.openAndConnect()
+ h.controller.reload()
+ h.controller.navigate(Harness.otherURL)
+ #expect(stream.sent.isEmpty)
+ #expect(h.controller.openedURL == Harness.url)
+ }
+
+ @Test func aNonWebLinkShowsANoticeFor2s() async throws {
+ let h = Harness()
+ h.controller.open(try #require(URL(string: "ftp://files.example.com")))
+ #expect(h.controller.notice == .noWebLink)
+ #expect(h.state == .idle)
+ h.advance(by: .milliseconds(1999))
+ #expect(h.controller.notice == .noWebLink)
+ h.advance(by: .milliseconds(1))
+ #expect(h.controller.notice == nil)
+ }
+
+ @Test func navigateRejectsNonWebLinks() async throws {
+ let h = Harness()
+ let stream = await h.goLive()
+ h.controller.navigate(try #require(URL(string: "file:///etc/passwd")))
+ #expect(stream.sent.isEmpty)
+ #expect(h.controller.notice == .noWebLink)
+ #expect(h.controller.openedURL == Harness.url)
+ }
+
+ @Test func textWithoutALinkShowsANotice() {
+ let h = Harness()
+ h.controller.open(text: "call me maybe")
+ #expect(h.controller.notice == .noWebLink)
+ #expect(h.state == .idle)
+ }
+
+ @Test func textWithALinkOpensIt() {
+ let h = Harness()
+ h.controller.open(text: "Your parcel: https://example.com/ (tracking)")
+ #expect(h.state == .starting(.booting, folded: false))
+ #expect(h.controller.openedURL == Harness.url)
+ }
+}
diff --git a/Tests/KnotchyCoreTests/SessionRuntimeInstallTests.swift b/Tests/KnotchyCoreTests/SessionRuntimeInstallTests.swift
new file mode 100644
index 0000000..35c9431
--- /dev/null
+++ b/Tests/KnotchyCoreTests/SessionRuntimeInstallTests.swift
@@ -0,0 +1,82 @@
+import Foundation
+import Testing
+@testable import KnotchyCore
+
+@MainActor
+@Suite(.timeLimit(.minutes(1)))
+struct SessionRuntimeInstallTests {
+ @Test func aFreshInstallHoldsLinksThenStartsTheServiceAndBuilds() async {
+ let h = Harness()
+ let hold = await h.controller.beginRuntimeInstall(replacing: nil)
+ #expect((try? hold.get()) != nil)
+ #expect(h.state == .settingUp(.cliMissing))
+ #expect(h.controller.setupFolded)
+ h.controller.open(Harness.url)
+ #expect(h.state == .settingUp(.cliMissing))
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls == [.sweep(keeping: [])]) // The link waits: no preflight, no start.
+
+ h.backend.queuePreflight(.issue(.imageMissing))
+ #expect(await h.controller.finishRuntimeInstall(.installed) == .ready)
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ #expect(Array(h.backend.calls.prefix(5))
+ == [.sweep(keeping: []), .fix(.serviceStopped), .preflight, .fix(.imageMissing), .preflight])
+ }
+
+ @Test func anUpdateStopsTheServiceFirst() async {
+ let h = Harness()
+ let hold = await h.controller.beginRuntimeInstall(replacing: "1.3.0")
+ #expect((try? hold.get()) != nil)
+ #expect(h.state == .settingUp(.cliOutdated(found: "1.3.0")))
+ #expect(h.backend.calls == [.sweep(keeping: []), .stopService])
+ }
+
+ @Test func aServiceThatWontStopEndsTheHold() async {
+ let h = Harness()
+ h.backend.failStopService(with: VMBackendError.failed("still running"))
+ guard case .failure(let refusal) = await h.controller.beginRuntimeInstall(replacing: "1.3.0") else {
+ Issue.record("The hold should have been refused")
+ return
+ }
+ #expect(refusal == .stopFailed("still running"))
+ #expect(h.state == .idle)
+ }
+
+ @Test func theHoldWaitsForTheBrowserToClose() async {
+ let h = Harness()
+ await h.goLive()
+ guard case .failure(let refusal) = await h.controller.beginRuntimeInstall(replacing: "1.3.0") else {
+ Issue.record("The hold should have been refused")
+ return
+ }
+ #expect(refusal == .sessionOpen)
+ #expect(h.state == .live(.peek))
+ #expect(!h.backend.calls.contains(.stopService))
+ }
+
+ @Test func theHoldIsAcceptedAfterAFailedStart() async {
+ let h = Harness()
+ h.backend.failStarts(with: VMBackendError.failed("boot failed"))
+ h.controller.open(Harness.url)
+ await waitUntil("the start fails") { if case .failed(.start) = h.state { true } else { false } }
+ let hold = await h.controller.beginRuntimeInstall(replacing: nil)
+ #expect((try? hold.get()) != nil)
+ #expect(h.state == .settingUp(.cliMissing))
+ }
+
+ @Test func aCancelledInstallGoesBackToIdle() async {
+ let h = Harness()
+ _ = await h.controller.beginRuntimeInstall(replacing: nil)
+ #expect(await h.controller.finishRuntimeInstall(.cancelled) == .needs(.cliMissing))
+ #expect(h.state == .idle)
+ }
+
+ @Test func aFailedInstallShowsItsCardToAWaitingLink() async {
+ let h = Harness()
+ _ = await h.controller.beginRuntimeInstall(replacing: nil)
+ h.controller.open(Harness.url)
+ #expect(await h.controller.finishRuntimeInstall(.failed("Couldn't install the runtime."))
+ == .failed(.cliMissing, "Couldn't install the runtime."))
+ #expect(h.state == .setupRequired(.cliMissing, error: "Couldn't install the runtime."))
+ }
+}
diff --git a/Tests/KnotchyCoreTests/SessionSetupRunTests.swift b/Tests/KnotchyCoreTests/SessionSetupRunTests.swift
new file mode 100644
index 0000000..f7b1782
--- /dev/null
+++ b/Tests/KnotchyCoreTests/SessionSetupRunTests.swift
@@ -0,0 +1,121 @@
+import Foundation
+import Testing
+@testable import KnotchyCore
+
+@MainActor
+@Suite(.timeLimit(.minutes(1)))
+struct SessionSetupRunTests {
+ @Test func aWindowRunFixesEachIssueInTurnAndEndsIdle() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.imageMissing))
+ #expect(await h.controller.runSetup(.serviceStopped, continuing: true) == .ready)
+ #expect(h.state == .idle)
+ #expect(h.backend.calls == [.sweep(keeping: []), .fix(.serviceStopped), .preflight, .fix(.imageMissing), .preflight])
+ }
+
+ @Test func aWindowRunStartsFolded() async {
+ let h = Harness()
+ h.backend.hold(.fix)
+ let run = Task { await h.controller.runSetup(.imageMissing, continuing: false) }
+ await waitUntil("building") { h.backend.parkedCount(.fix) == 1 }
+ #expect(h.state == .settingUp(.imageMissing))
+ #expect(h.controller.setupFolded)
+ h.backend.release(.fix)
+ #expect(await run.value == .ready)
+ }
+
+ @Test func aWindowRunNeverFixesTheSameIssueTwice() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.serviceStopped))
+ #expect(await h.controller.runSetup(.serviceStopped, continuing: true)
+ == .failed(.serviceStopped, SessionController.stillBrokenMessage))
+ #expect(h.state == .idle)
+ #expect(h.backend.calls.filter { $0 == .fix(.serviceStopped) }.count == 1)
+ }
+
+ @Test func anotherImageIssueAfterABuildIsTheSameFix() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.imageOutdated(found: 2, need: 3)))
+ #expect(await h.controller.runSetup(.imageMissing, continuing: true)
+ == .failed(.imageOutdated(found: 2, need: 3), SessionController.stillBrokenMessage))
+ #expect(h.backend.calls.filter { if case .fix = $0 { true } else { false } }.count == 1)
+ }
+
+ @Test func aFailedWindowRunLeavesNoCardWithoutALink() async {
+ let h = Harness()
+ h.backend.scriptFix(output: [], error: VMBackendError.failed("container build failed"))
+ #expect(await h.controller.runSetup(.imageMissing, continuing: true) == .failed(.imageMissing, "container build failed"))
+ #expect(h.state == .idle)
+ }
+
+ @Test func aLinkDuringAWindowRunWaitsForTheWholeChain() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.imageMissing))
+ h.backend.hold(.fix)
+ let run = Task { await h.controller.runSetup(.serviceStopped, continuing: true) }
+ await waitUntil("starting the service") { h.backend.parkedCount(.fix) == 1 }
+ h.controller.open(Harness.url)
+ #expect(h.state == .settingUp(.serviceStopped))
+ #expect(!h.controller.setupFolded) // A waiting link shows its card.
+ h.backend.release(.fix)
+ #expect(await run.value == .ready)
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ #expect(Array(h.backend.calls.prefix(5))
+ == [.sweep(keeping: []), .fix(.serviceStopped), .preflight, .fix(.imageMissing), .preflight])
+ }
+
+ @Test func aBusyControllerRefusesTheWindow() async {
+ let h = Harness()
+ await h.goLive()
+ #expect(await h.controller.runSetup(.imageMissing, continuing: true) == nil)
+ #expect(await h.controller.checkSetup() == nil)
+ }
+
+ @Test func checkingStartsAStoppedServiceButNeverBuilds() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.serviceStopped), .issue(.imageMissing))
+ #expect(await h.controller.checkSetup() == .needs(.imageMissing))
+ #expect(h.state == .idle)
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight, .fix(.serviceStopped), .preflight])
+ }
+
+ @Test func checkingOpensALinkACardWasHolding() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.imageMissing))
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") { h.state == .setupRequired(.imageMissing, error: nil) }
+ #expect(await h.controller.checkSetup() == .ready)
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ #expect(h.controller.openedURL == Harness.url)
+ }
+
+ @Test func checkingAReadyMacFixesNothing() async {
+ let h = Harness()
+ #expect(await h.controller.checkSetup() == .ready)
+ #expect(!h.backend.calls.contains { if case .fix = $0 { true } else { false } })
+ }
+
+ @Test func setupOutputKeepsTheLast200Lines() async {
+ let h = Harness()
+ h.backend.scriptFix(output: (1...250).map { "line \($0)" })
+ _ = await h.controller.runSetup(.imageMissing, continuing: false)
+ #expect(h.controller.setupOutput.count == 200)
+ #expect(h.controller.setupOutput.first == "line 51")
+ #expect(h.controller.setupOutput.last == "line 250")
+ }
+
+ @Test func waitingForSetupReturnsOnlyWhenItEnds() async {
+ let h = Harness()
+ h.backend.hold(.fix)
+ let run = Task { await h.controller.runSetup(.imageMissing, continuing: false) }
+ await waitUntil("building") { h.backend.parkedCount(.fix) == 1 }
+ let waiter = Task {
+ await h.controller.waitWhileSettingUp()
+ return h.state
+ }
+ await Task.yield()
+ h.backend.release(.fix)
+ #expect(await waiter.value == .idle)
+ _ = await run.value
+ }
+}
diff --git a/Tests/KnotchyCoreTests/SessionSetupTests.swift b/Tests/KnotchyCoreTests/SessionSetupTests.swift
new file mode 100644
index 0000000..0bc8caa
--- /dev/null
+++ b/Tests/KnotchyCoreTests/SessionSetupTests.swift
@@ -0,0 +1,301 @@
+import Foundation
+import Testing
+@testable import KnotchyCore
+
+@MainActor
+@Suite(.timeLimit(.minutes(1)))
+struct SessionSetupTests {
+ @Test func aPreflightIssueNeedsSetupWithoutStartingAVM() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.imageMissing))
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") { h.state == .setupRequired(.imageMissing, error: nil) }
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight])
+ #expect(h.controller.liveIDs.snapshot.isEmpty)
+ }
+
+ @Test func theSetupActionShowsItsOutputThenTheLinkOpens() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.imageMissing))
+ h.backend.scriptFix(output: ["Step 1/9", "Step 9/9"])
+ h.backend.hold(.fix)
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") { h.state == .setupRequired(.imageMissing, error: nil) }
+
+ h.controller.performSetupAction()
+ #expect(h.state == .settingUp(.imageMissing))
+ await waitUntil("the output shows") { h.controller.setupLog == "Step 9/9" }
+
+ h.backend.release(.fix)
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ #expect(h.controller.openedURL == Harness.url)
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight, .fix(.imageMissing), .preflight, .start("knotchy-00000002")])
+ }
+
+ @Test func aSetupActionFoldsAwayAndItsLinkStartsFolded() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.imageMissing))
+ h.backend.hold(.fix)
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") { h.state == .setupRequired(.imageMissing, error: nil) }
+ h.controller.clickedOutside()
+ #expect(!h.controller.setupFolded) // Only a running action folds.
+
+ h.controller.performSetupAction()
+ h.controller.clickedOutside()
+ #expect(h.controller.setupFolded)
+ h.controller.pointerEntered()
+ #expect(!h.controller.setupFolded)
+ h.controller.foldSetup()
+ #expect(h.controller.setupFolded)
+
+ h.backend.release(.fix)
+ await waitUntil("loading, folded") { h.state == .starting(.loading, folded: true) }
+ #expect(!h.controller.setupFolded)
+ }
+
+ @Test func aFoldedSetupOpenedByHoveringFoldsWhenThePointerLeaves() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.imageMissing))
+ h.backend.hold(.fix)
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") { h.state == .setupRequired(.imageMissing, error: nil) }
+ h.controller.performSetupAction()
+ h.controller.foldSetup()
+
+ h.controller.pointerEntered()
+ #expect(!h.controller.setupFolded)
+ h.controller.pointerExited()
+ h.advance(by: SessionController.foldGrace)
+ #expect(h.controller.setupFolded)
+
+ h.controller.showPanel()
+ h.controller.pointerEntered()
+ h.controller.pointerExited()
+ h.advance(by: SessionController.foldGrace)
+ #expect(!h.controller.setupFolded)
+ }
+
+ @Test func aFailedSetupShowsTheErrorOnTheCard() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.imageMissing))
+ h.backend.scriptFix(output: [], error: VMBackendError.failed("container build failed"))
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") { h.state == .setupRequired(.imageMissing, error: nil) }
+ h.controller.performSetupAction()
+ await waitUntil("the error shows") {
+ h.state == .setupRequired(.imageMissing, error: "container build failed")
+ }
+ }
+
+ @Test func aSecondIssueAfterSetupShowsItsOwnCard() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.imageMissing), .issue(.imageOutdated(found: 2, need: 3)))
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") { h.state == .setupRequired(.imageMissing, error: nil) }
+ h.controller.performSetupAction()
+ await waitUntil("the next issue") { h.state == .setupRequired(.imageOutdated(found: 2, need: 3), error: nil) }
+ }
+
+ @Test func aMissingOrOldRuntimeOpensSetup() async {
+ for issue in [SetupIssue.cliMissing, .cliOutdated(found: "1.3.0")] {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(issue))
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") { h.state == .setupRequired(issue, error: nil) }
+ h.controller.performSetupAction()
+ #expect(h.recorder.setupRequests == 1)
+ #expect(h.state == .setupRequired(issue, error: nil))
+ await h.controller.waitForBackendIdle()
+ #expect(!h.backend.calls.contains(.fix(issue)))
+ }
+ }
+
+ @Test func lowDiskNeedsSetupAndHasNoAction() async {
+ let h = Harness()
+ h.disk.available = 1_000_000_000
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") { h.state == .setupRequired(.lowDisk(bytesFree: 1_000_000_000), error: nil) }
+ h.controller.performSetupAction()
+ #expect(h.state == .setupRequired(.lowDisk(bytesFree: 1_000_000_000), error: nil))
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight])
+ }
+
+ @Test func dismissDropsThePendingLink() async {
+ // Only visible when setup runs again afterwards: here, a requested rebuild.
+ let h = Harness()
+ h.backend.queuePreflight(.ready(appRoot: "/fake/appRoot", staleImage: StaleImage(builtDaysAgo: 20)),
+ .issue(.imageMissing))
+ await h.goLive()
+ h.controller.requestImageUpdate()
+ h.controller.open(Harness.otherURL)
+ await waitUntil("setup required") { h.state == .setupRequired(.imageMissing, error: nil) }
+
+ h.controller.dismiss()
+ #expect(h.state == .settingUp(.imageStale(builtDaysAgo: 20)))
+ await waitUntil("idle after the rebuild") { h.state == .idle }
+ #expect(!h.backend.calls.contains(.start("knotchy-00000003")))
+ }
+
+ @Test func aNewLinkDuringAnAutomaticStartOpensAfterIt() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.serviceStopped))
+ h.backend.hold(.fix)
+ h.controller.open(Harness.url)
+ await waitUntil("starting the service") { h.backend.parkedCount(.fix) == 1 }
+ #expect(h.state == .settingUp(.serviceStopped))
+ #expect(!h.controller.setupFolded)
+ h.controller.open(Harness.otherURL)
+ #expect(h.state == .settingUp(.serviceStopped))
+ h.backend.release(.fix)
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ #expect(h.controller.openedURL == Harness.otherURL)
+ }
+
+ @Test func aStaleImageWarnsButNeverBlocks() async {
+ let h = Harness()
+ h.backend.queuePreflight(.ready(appRoot: "/fake/appRoot", staleImage: StaleImage(builtDaysAgo: 20)))
+ await h.goLive()
+ #expect(h.controller.staleImage == StaleImage(builtDaysAgo: 20))
+ }
+
+ @Test func updateNowRebuildsOnceTheSessionEnds() async {
+ let h = Harness()
+ h.backend.queuePreflight(.ready(appRoot: "/fake/appRoot", staleImage: StaleImage(builtDaysAgo: 20)))
+ await h.goLive()
+ h.controller.requestImageUpdate()
+ #expect(h.controller.staleImage == nil)
+
+ h.controller.destroy()
+ await waitUntil("destroyed") { h.state == .destroyed }
+ h.advance(by: .milliseconds(1500))
+ #expect(h.state == .settingUp(.imageStale(builtDaysAgo: 20)))
+ await waitUntil("idle after the rebuild") { h.state == .idle }
+ #expect(h.backend.calls.suffix(2) == [.fix(.imageStale(builtDaysAgo: 20)), .preflight])
+ }
+
+ @Test func aRebuildThatEndsInAnotherIssueShowsItsCard() async {
+ let h = Harness()
+ h.backend.queuePreflight(.ready(appRoot: "/fake/appRoot", staleImage: StaleImage(builtDaysAgo: 20)),
+ .issue(.serviceStopped))
+ await h.goLive()
+ h.controller.requestImageUpdate()
+ h.controller.destroy()
+ await waitUntil("destroyed") { h.state == .destroyed }
+ h.advance(by: .milliseconds(1500))
+ await waitUntil("the next issue") { h.state == .setupRequired(.serviceStopped, error: nil) }
+ }
+
+ @Test func aFailedRebuildStillOpensAPendingLink() async {
+ let h = Harness()
+ h.backend.queuePreflight(.ready(appRoot: "/fake/appRoot", staleImage: StaleImage(builtDaysAgo: 20)))
+ h.backend.scriptFix(output: [], error: VMBackendError.failed("container build failed"))
+ h.backend.hold(.fix)
+ await h.goLive()
+ h.controller.requestImageUpdate()
+ h.controller.destroy()
+ await waitUntil("destroyed") { h.state == .destroyed }
+ h.advance(by: .milliseconds(1500))
+ await waitUntil("rebuilding") { h.backend.parkedCount(.fix) == 1 }
+
+ h.controller.open(Harness.otherURL)
+ #expect(h.state == .settingUp(.imageStale(builtDaysAgo: 20)))
+ h.backend.release(.fix)
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ #expect(h.controller.openedURL == Harness.otherURL)
+ }
+
+ @Test func aLinkOpenedAfterARebuildStartsUnengaged() async {
+ // The pointer was on the panel before it hid; nothing says it is there now.
+ let h = Harness()
+ h.backend.queuePreflight(.ready(appRoot: "/fake/appRoot", staleImage: StaleImage(builtDaysAgo: 20)))
+ h.backend.hold(.fix)
+ await h.goLive()
+ h.controller.pointerEntered()
+ h.controller.requestImageUpdate()
+ h.controller.destroy()
+ await waitUntil("destroyed") { h.state == .destroyed }
+ h.advance(by: .milliseconds(1500))
+ await waitUntil("rebuilding") { h.backend.parkedCount(.fix) == 1 }
+ h.controller.open(Harness.otherURL)
+ h.backend.release(.fix)
+
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ h.connector.connections.last!.emit(.contentReady)
+ await waitUntil("live") { h.state == .live(.peek) }
+ h.advance(by: .seconds(30))
+ #expect(h.state == .live(.collapsed))
+ }
+
+ @Test func aFreshImageBuildSatisfiesARequestedRebuild() async {
+ let h = Harness()
+ h.backend.queuePreflight(.ready(appRoot: "/fake/appRoot", staleImage: StaleImage(builtDaysAgo: 20)),
+ .issue(.imageMissing))
+ await h.goLive()
+ h.controller.requestImageUpdate()
+ h.controller.open(Harness.otherURL)
+ await waitUntil("setup required") { h.state == .setupRequired(.imageMissing, error: nil) }
+ h.controller.performSetupAction()
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+
+ h.controller.destroy()
+ await waitUntil("destroyed") { h.state == .destroyed }
+ h.advance(by: .milliseconds(1500))
+ #expect(h.state == .idle)
+ await h.controller.waitForBackendIdle()
+ #expect(h.backend.calls.filter { if case .fix = $0 { true } else { false } } == [.fix(.imageMissing)])
+ }
+
+ @Test func laterHidesTheWarningForThisSession() async {
+ let h = Harness()
+ h.backend.queuePreflight(.ready(appRoot: "/fake/appRoot", staleImage: StaleImage(builtDaysAgo: nil)))
+ await h.goLive()
+ h.controller.dismissStaleImageWarning()
+ #expect(h.controller.staleImage == nil)
+
+ h.controller.destroy()
+ await waitUntil("destroyed") { h.state == .destroyed }
+ h.advance(by: .milliseconds(1500))
+ #expect(h.state == .idle)
+ }
+
+ @Test func aStoppedServiceStartsByItselfAndTheLinkOpens() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.serviceStopped))
+ h.controller.open(Harness.url)
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ #expect(h.backend.calls == [.sweep(keeping: []), .preflight, .fix(.serviceStopped), .preflight,
+ .start("knotchy-00000002")])
+ }
+
+ @Test func aServiceThatWontStayUpShowsItsCardOnce() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.serviceStopped), .issue(.serviceStopped))
+ h.controller.open(Harness.url)
+ await waitUntil("setup required") {
+ h.state == .setupRequired(.serviceStopped, error: SessionController.stillBrokenMessage)
+ }
+ #expect(h.backend.calls.filter { $0 == .fix(.serviceStopped) }.count == 1)
+
+ h.backend.queuePreflight(.issue(.serviceStopped))
+ h.controller.open(Harness.url) // A new request gets its own automatic start.
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ #expect(h.backend.calls.filter { $0 == .fix(.serviceStopped) }.count == 2)
+ }
+
+ @Test func retryStartsTheServiceAgain() async {
+ let h = Harness()
+ h.backend.queuePreflight(.issue(.serviceStopped))
+ h.backend.failStarts(with: VMBackendError.failed("boot failed"))
+ h.controller.open(Harness.url)
+ await waitUntil("the start fails") { if case .failed(.start) = h.state { true } else { false } }
+
+ h.backend.failStarts(with: nil)
+ h.backend.queuePreflight(.issue(.serviceStopped))
+ h.controller.retry()
+ await waitUntil("loading") { h.state == .starting(.loading, folded: false) }
+ #expect(h.backend.calls.filter { $0 == .fix(.serviceStopped) }.count == 2)
+ }
+}
diff --git a/Tests/KnotchyCoreTests/SetupFlowTests.swift b/Tests/KnotchyCoreTests/SetupFlowTests.swift
new file mode 100644
index 0000000..06cc12e
--- /dev/null
+++ b/Tests/KnotchyCoreTests/SetupFlowTests.swift
@@ -0,0 +1,242 @@
+import Foundation
+import Testing
+@testable import KnotchyCore
+
+@MainActor
+@Suite(.timeLimit(.minutes(1)))
+struct SetupFlowTests {
+ let host = FakeHost()
+ let installer = FakeInstaller()
+ let driver = FakeSetupDriver()
+
+ func makeFlow() -> SetupFlow {
+ SetupFlow(host: host, installer: installer, driver: driver, retryDelay: .zero)
+ }
+
+ @Test func aReadyMacShowsEveryRowDone() async {
+ let flow = makeFlow()
+ await flow.refresh()
+ #expect(flow.mac == .done("macOS 27.0 · 212 GB free"))
+ #expect(flow.runtime == .done("container 1.4.1 installed"))
+ #expect(flow.vm == .done("Ready"))
+ #expect(flow.allRequiredDone)
+ #expect(!flow.canSetUp)
+ }
+
+ @Test func aMissingRuntimeOffersAnInstallWithoutCheckingTheVM() async {
+ driver.runtimeStatuses = [.missing]
+ let flow = makeFlow()
+ await flow.refresh()
+ #expect(flow.runtimeAction == .install)
+ #expect(flow.runtime == .pending("Apple's container 1.4.1 · 118 MB · installs with Apple's Installer"))
+ #expect(flow.vm == .pending("About 3 minutes · downloads about 225 MB"))
+ #expect(flow.canSetUp)
+ #expect(driver.calls == ["runtimeStatus"])
+ }
+
+ @Test func anOldRuntimeOffersAnUpdate() async {
+ driver.runtimeStatuses = [.outdated("1.3.0")]
+ let flow = makeFlow()
+ await flow.refresh()
+ #expect(flow.runtimeAction == .update)
+ #expect(flow.runtime == .pending("container 1.3.0 is too old · updates to 1.4.1 with Apple's Installer"))
+ }
+
+ @Test func aMacThatCantRunVirtualMachinesShowsOnlyThat() async {
+ host.current.unsupported = .noVirtualization
+ let flow = makeFlow()
+ await flow.refresh()
+ #expect(flow.unsupported == .noVirtualization)
+ #expect(driver.calls.isEmpty)
+ #expect(!flow.canSetUp)
+ }
+
+ @Test func lowDiskBlocksOnlyWhileSomethingNeedsSpace() async {
+ host.current.bytesFree = 2_500_000_000
+ driver.runtimeStatuses = [.missing]
+ let flow = makeFlow()
+ await flow.refresh()
+ #expect(flow.mac == .failed("Setting up needs about 3 GB free. 2.5 GB is free.", details: []))
+ #expect(!flow.canSetUp)
+
+ driver.runtimeStatuses = [.current("1.4.1")]
+ await flow.refresh()
+ #expect(flow.mac == .done("macOS 27.0 · 2.5 GB free"))
+ #expect(flow.allRequiredDone)
+ }
+
+ @Test func installingWithInstallerFinishesTheChain() async throws {
+ driver.runtimeStatuses = [.missing, .current("1.4.1")]
+ installer.session.hasQuit = false
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(driver.calls == ["runtimeStatus", "begin(nil)", "runtimeStatus", "finish(installed)"])
+ #expect(flow.mac == .done("macOS 27.0 · 212 GB free"))
+ #expect(flow.runtime == .done("container 1.4.1 installed"))
+ #expect(flow.vm == .done("Ready"))
+ #expect(flow.allRequiredDone)
+
+ // Installer still reads the package while its summary is open.
+ try await Task.sleep(for: .milliseconds(50))
+ #expect(installer.calls == ["download", "open"])
+ installer.session.hasQuit = true
+ await waitUntil("the package is discarded") { installer.calls.contains("discard") }
+ #expect(installer.calls == ["download", "open", "discard"])
+ }
+
+ @Test func anUpdatePassesTheOldVersionOn() async {
+ driver.runtimeStatuses = [.outdated("1.3.0"), .current("1.4.1")]
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(driver.calls.contains("begin(1.3.0)"))
+ #expect(flow.allRequiredDone)
+ }
+
+ @Test func aMismatchedDownloadIsNeverInstalled() async {
+ driver.runtimeStatuses = [.missing]
+ installer.failDownload(with: .mismatch)
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(flow.runtime == .failed("The download didn't match the expected package, so it wasn't installed.", details: []))
+ #expect(installer.calls == ["download"])
+ #expect(!driver.calls.contains { $0.hasPrefix("begin") })
+ }
+
+ @Test func anOfflineDownloadSaysSo() async {
+ driver.runtimeStatuses = [.missing]
+ installer.failDownload(with: .failed("The Internet connection appears to be offline."))
+ let flow = makeFlow()
+ await flow.setUp()
+ guard case .failed(let message, _) = flow.runtime else {
+ Issue.record("Expected a failure")
+ return
+ }
+ #expect(message == "Couldn't download the runtime. Check your connection and try again.")
+ }
+
+ @Test func quittingInstallerWithoutInstallingIsCancelled() async {
+ driver.runtimeStatuses = [.missing]
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(flow.runtime == .pending("Installing was cancelled."))
+ #expect(flow.runtimeAction == .install)
+ #expect(flow.canSetUp)
+ #expect(driver.calls == ["runtimeStatus", "begin(nil)", "runtimeStatus", "runtimeStatus", "finish(cancelled)"])
+ await waitUntil("the package is discarded") { installer.calls.contains("discard") }
+ #expect(installer.calls == ["download", "open", "discard"])
+ }
+
+ @Test func aChangedDownloadIsNotOpened() async {
+ driver.runtimeStatuses = [.missing]
+ installer.open(with: .changed)
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(flow.runtime == .failed("The download changed after it was checked, so it wasn't opened.", details: []))
+ #expect(installer.calls == ["download", "open"])
+ #expect(driver.calls.last?.hasPrefix("finish(failed") == true)
+ }
+
+ @Test func installerThatWontOpenSaysSo() async {
+ driver.runtimeStatuses = [.missing]
+ installer.open(with: .failed("x"))
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(flow.runtime == .failed("Couldn't open Installer.", details: ["x"]))
+ #expect(installer.calls == ["download", "open", "discard"])
+ #expect(flow.canSetUp)
+ #expect(driver.calls.last?.hasPrefix("finish(failed") == true)
+ }
+
+ @Test func anUpdateWaitsForTheBrowserToClose() async {
+ driver.runtimeStatuses = [.outdated("1.3.0")]
+ driver.holdResult = .failure(.sessionOpen)
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(flow.runtime == .failed("Close the Knotchy browser first.", details: []))
+ #expect(installer.calls == ["download", "discard"])
+ }
+
+ @Test func quittingWhileInstallerIsOpenLeavesItToFinish() async {
+ driver.runtimeStatuses = [.missing]
+ installer.session.hasQuit = false
+ let flow = makeFlow()
+ flow.start()
+ await waitUntil("Installer is open") { flow.runtime == .running("Finish the install in Installer…", fraction: nil) }
+ flow.cancel()
+ await waitUntil("the flow stops") { !flow.isRunning }
+ #expect(!driver.calls.contains { $0.hasPrefix("finish(") })
+ #expect(!installer.calls.contains("discard"))
+ installer.session.hasQuit = true // Ends the cleanup task.
+ }
+
+ @Test func aClosingBrowserIsWaitedFor() async {
+ driver.runtimeStatuses = [.outdated("1.3.0")]
+ for state in [SessionState.destroying, .failed(.destroyStuck)] {
+ driver.state = state
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(flow.runtime == .failed("Wait for the Knotchy browser to finish closing, then try again.", details: []))
+ }
+ #expect(installer.calls.isEmpty)
+ }
+
+ @Test func aFailedServiceStartStopsSetUp() async {
+ driver.checkResults = [.failed(.serviceStopped, "Couldn't start the service: x")]
+ driver.setupOutput = ["x"]
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(flow.runtime == .failed("Couldn't start the service: x", details: ["x"]))
+ #expect(driver.calls.filter { $0 == "checkSetup" }.count == 1)
+ #expect(!driver.calls.contains { $0.hasPrefix("runSetup") })
+ }
+
+ @Test func aBuildFailureShowsItsOutput() async {
+ driver.checkResults = [.needs(.imageMissing), .needs(.imageMissing)]
+ driver.runResults = [.failed(.imageMissing, "The image build failed: out of space")]
+ driver.setupOutput = ["Step 7/9", "error: out of space"]
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(flow.vm == .failed("The image build failed: out of space", details: ["Step 7/9", "error: out of space"]))
+ #expect(driver.calls.contains("runSetup(imageMissing, continuing: true)"))
+ }
+
+ @Test func aSetupTheNotchStartedIsFollowed() async {
+ driver.state = .settingUp(.imageMissing)
+ driver.checkResults = [nil, nil, .ready]
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(driver.calls.contains("wait"))
+ #expect(flow.vm == .done("Ready"))
+ }
+
+ @Test func theRowsShowTheControllersProgress() {
+ let flow = makeFlow()
+ driver.state = .settingUp(.imageMissing)
+ driver.setupLog = "Step 3/9"
+ #expect(flow.vm == .running("Step 3/9", fraction: nil))
+ driver.state = .settingUp(.serviceStopped)
+ #expect(flow.runtime == .running("Starting the runtime…", fraction: nil))
+ }
+
+ @Test func anOpenBrowserCountsAsAReadyVM() async {
+ driver.state = .live(.peek)
+ driver.checkResults = [nil]
+ let flow = makeFlow()
+ await flow.refresh()
+ #expect(flow.vm == .done("Ready"))
+ #expect(flow.allRequiredDone)
+ }
+
+ @Test func anOpenBrowserIsReportedBeforeDownloadingAnUpdate() async {
+ driver.state = .live(.peek)
+ driver.runtimeStatuses = [.outdated("1.3.0")]
+ let flow = makeFlow()
+ await flow.setUp()
+ #expect(flow.runtime == .failed("Close the Knotchy browser first.", details: []))
+ #expect(installer.calls.isEmpty)
+ }
+
+ @Test func downloadProgressReadsInMegabytes() {
+ #expect(SetupFlow.downloadText(58_886_932, of: ContainerRuntime.pinned.size) == "Downloading… 59 of 118 MB")
+ }
+}
diff --git a/Tests/KnotchyCoreTests/Support/Fakes.swift b/Tests/KnotchyCoreTests/Support/Fakes.swift
new file mode 100644
index 0000000..1d293c1
--- /dev/null
+++ b/Tests/KnotchyCoreTests/Support/Fakes.swift
@@ -0,0 +1,336 @@
+import Foundation
+import Synchronization
+import Testing
+@testable import KnotchyCore
+
+/// A forgotten `release` fails the test after this instead of hanging the run.
+private let heldCallLimit: Duration = .seconds(10)
+
+final class FakeVMBackend: VMBackend {
+ enum Call: Equatable, Sendable {
+ case sweep(keeping: Set)
+ case preflight
+ case start(String)
+ case destroy(String)
+ case forceDestroy(String)
+ case fix(SetupIssue)
+ case destroyBlocking([String])
+ case stopService
+
+ var kind: Kind {
+ switch self {
+ case .sweep: .sweep
+ case .preflight: .preflight
+ case .start: .start
+ case .destroy: .destroy
+ case .forceDestroy: .forceDestroy
+ case .fix: .fix
+ case .destroyBlocking: .destroyBlocking
+ case .stopService: .stopService
+ }
+ }
+ }
+
+ enum Kind: Hashable, Sendable {
+ case sweep, preflight, start, destroy, forceDestroy, fix, destroyBlocking, stopService
+ }
+
+ struct StartArguments: Equatable, Sendable {
+ var id: String
+ var url: URL
+ var renderSize: PixelSize
+ var blockCIDRs: [String]
+ }
+
+ private struct State {
+ var calls: [Call] = []
+ var startArguments: [StartArguments] = []
+ var active = 0
+ var maxActive = 0
+ var held: Set = []
+ var nextParkID = 0
+ var parked: [Kind: [(id: Int, continuation: CheckedContinuation)]] = [:]
+ var preflightResults: [PreflightResult] = []
+ var startError: (any Error)?
+ var destroyError: (any Error)?
+ var forceDestroyError: (any Error)?
+ var fixOutput: [String] = []
+ var fixError: (any Error)?
+ var runtimeStatus: RuntimeStatus = .current("1.4.1")
+ var stopError: (any Error)?
+ }
+
+ private let state = Mutex(State())
+
+ var calls: [Call] { state.withLock { $0.calls } }
+ var startArguments: [StartArguments] { state.withLock { $0.startArguments } }
+ var maxConcurrentCalls: Int { state.withLock { $0.maxActive } }
+
+ /// Used in order; after them, preflight is ready.
+ func queuePreflight(_ results: PreflightResult...) {
+ state.withLock { $0.preflightResults += results }
+ }
+
+ func failStarts(with error: (any Error)?) { state.withLock { $0.startError = error } }
+ func failDestroys(with error: (any Error)?) { state.withLock { $0.destroyError = error } }
+ func failForceDestroys(with error: (any Error)?) { state.withLock { $0.forceDestroyError = error } }
+
+ func scriptFix(output: [String], error: (any Error)? = nil) {
+ state.withLock {
+ $0.fixOutput = output
+ $0.fixError = error
+ }
+ }
+
+ func hold(_ kind: Kind) {
+ precondition(kind != .destroyBlocking, "destroyBlocking is synchronous and can't be held")
+ _ = state.withLock { $0.held.insert(kind) }
+ }
+
+ func release(_ kind: Kind) {
+ let parked = state.withLock { s in
+ s.held.remove(kind)
+ return s.parked.removeValue(forKey: kind) ?? []
+ }
+ for call in parked { call.continuation.resume() }
+ }
+
+ func parkedCount(_ kind: Kind) -> Int {
+ state.withLock { $0.parked[kind]?.count ?? 0 }
+ }
+
+ func sweepOrphans(keeping: Set) async {
+ await begin(.sweep(keeping: keeping))
+ end()
+ }
+
+ func preflight() async -> PreflightResult {
+ await begin(.preflight)
+ defer { end() }
+ return state.withLock { s in
+ s.preflightResults.isEmpty ? .ready(appRoot: "/fake/appRoot", staleImage: nil) : s.preflightResults.removeFirst()
+ }
+ }
+
+ func start(id: String, url: URL, renderSize: PixelSize, blockCIDRs: [String]) async throws -> VMSession {
+ state.withLock {
+ $0.startArguments.append(StartArguments(id: id, url: url, renderSize: renderSize, blockCIDRs: blockCIDRs))
+ }
+ await begin(.start(id))
+ defer { end() }
+ if let error = state.withLock({ $0.startError }) { throw error }
+ return VMSession(id: id, socketPath: "/fake/\(id).sock")
+ }
+
+ func destroy(id: String) async throws {
+ await begin(.destroy(id))
+ defer { end() }
+ if let error = state.withLock({ $0.destroyError }) { throw error }
+ }
+
+ func forceDestroy(id: String) async throws {
+ await begin(.forceDestroy(id))
+ defer { end() }
+ if let error = state.withLock({ $0.forceDestroyError }) { throw error }
+ }
+
+ func fix(_ issue: SetupIssue, output: @escaping @Sendable (String) -> Void) async throws {
+ record(.fix(issue))
+ state.withLock { $0.fixOutput }.forEach(output)
+ await parkIfHeld(.fix)
+ defer { end() }
+ if let error = state.withLock({ $0.fixError }) { throw error }
+ }
+
+ func destroyBlocking(ids: [String], deadline: Duration) {
+ state.withLock { $0.calls.append(.destroyBlocking(ids)) }
+ }
+
+ func setRuntimeStatus(_ status: RuntimeStatus) { state.withLock { $0.runtimeStatus = status } }
+ func failStopService(with error: (any Error)?) { state.withLock { $0.stopError = error } }
+
+ func runtimeStatus() async -> RuntimeStatus {
+ state.withLock { $0.runtimeStatus }
+ }
+
+ func stopService() async throws {
+ await begin(.stopService)
+ defer { end() }
+ if let error = state.withLock({ $0.stopError }) { throw error }
+ }
+
+ private func begin(_ call: Call) async {
+ record(call)
+ await parkIfHeld(call.kind)
+ }
+
+ private func record(_ call: Call) {
+ state.withLock { s in
+ s.calls.append(call)
+ s.active += 1
+ s.maxActive = max(s.maxActive, s.active)
+ }
+ }
+
+ private func end() {
+ state.withLock { $0.active -= 1 }
+ }
+
+ private func parkIfHeld(_ kind: Kind) async {
+ await withCheckedContinuation { (continuation: CheckedContinuation) in
+ let id: Int? = state.withLock { s in
+ guard s.held.contains(kind) else { return nil }
+ s.nextParkID += 1
+ s.parked[kind, default: []].append((s.nextParkID, continuation))
+ return s.nextParkID
+ }
+ guard let id else { return continuation.resume() }
+ Task {
+ try? await Task.sleep(for: heldCallLimit)
+ let forgotten = self.state.withLock { s -> CheckedContinuation? in
+ guard let index = s.parked[kind]?.firstIndex(where: { $0.id == id }) else { return nil }
+ return s.parked[kind]?.remove(at: index).continuation
+ }
+ if let forgotten {
+ Issue.record("A held \(kind) call was never released")
+ forgotten.resume()
+ }
+ }
+ }
+ }
+}
+
+/// Queued errors go to connects in call order; `connections` is in completion order.
+final class FakeStreamConnector: StreamConnector {
+ private struct State {
+ var socketPaths: [String] = []
+ var connections: [FakeStreamConnection] = []
+ var errors: [StreamError] = []
+ var held = false
+ var nextParkID = 0
+ var parked: [(id: Int, continuation: CheckedContinuation)] = []
+ }
+
+ private let state = Mutex(State())
+
+ var socketPaths: [String] { state.withLock { $0.socketPaths } }
+ var connections: [FakeStreamConnection] { state.withLock { $0.connections } }
+ var parkedCount: Int { state.withLock { $0.parked.count } }
+
+ func failNextConnect(with error: StreamError) {
+ state.withLock { $0.errors.append(error) }
+ }
+
+ func hold() {
+ state.withLock { $0.held = true }
+ }
+
+ func release() {
+ let parked = state.withLock { s in
+ s.held = false
+ defer { s.parked = [] }
+ return s.parked
+ }
+ for call in parked { call.continuation.resume() }
+ }
+
+ func connect(socketPath: String) async throws -> any StreamConnection {
+ let scriptedError = state.withLock { s -> StreamError? in
+ s.socketPaths.append(socketPath)
+ return s.errors.isEmpty ? nil : s.errors.removeFirst()
+ }
+ await withCheckedContinuation { (continuation: CheckedContinuation) in
+ let id: Int? = state.withLock { s in
+ guard s.held else { return nil }
+ s.nextParkID += 1
+ s.parked.append((s.nextParkID, continuation))
+ return s.nextParkID
+ }
+ guard let id else { return continuation.resume() }
+ Task {
+ try? await Task.sleep(for: heldCallLimit)
+ let forgotten = self.state.withLock { s -> CheckedContinuation? in
+ guard let index = s.parked.firstIndex(where: { $0.id == id }) else { return nil }
+ return s.parked.remove(at: index).continuation
+ }
+ if let forgotten {
+ Issue.record("A held connect was never released")
+ forgotten.resume()
+ }
+ }
+ }
+ if let scriptedError { throw scriptedError }
+ let connection = FakeStreamConnection(socketPath: socketPath)
+ state.withLock { $0.connections.append(connection) }
+ return connection
+ }
+}
+
+final class FakeStreamConnection: StreamConnection {
+ let socketPath: String
+ let events: AsyncStream
+ private let continuation: AsyncStream.Continuation
+
+ private struct State {
+ var decodeEnabled = true
+ var decodeChanges: [Bool] = []
+ var sent: [InputEvent] = []
+ var closed = false
+ }
+
+ private let state = Mutex(State())
+
+ init(socketPath: String) {
+ self.socketPath = socketPath
+ let (stream, continuation) = AsyncStream.makeStream(of: StreamEvent.self)
+ events = stream
+ self.continuation = continuation
+ }
+
+ var decodeEnabled: Bool {
+ get { state.withLock { $0.decodeEnabled } }
+ set {
+ state.withLock {
+ $0.decodeEnabled = newValue
+ $0.decodeChanges.append(newValue)
+ }
+ }
+ }
+
+ var decodeChanges: [Bool] { state.withLock { $0.decodeChanges } }
+ var sent: [InputEvent] { state.withLock { $0.sent } }
+ var isClosed: Bool { state.withLock { $0.closed } }
+
+ func setFrameHandler(_ handler: @escaping @Sendable (DecodedFrame) -> Void) {}
+
+ func send(_ input: InputEvent) {
+ state.withLock { $0.sent.append(input) }
+ }
+
+ func close() {
+ state.withLock { $0.closed = true }
+ continuation.finish()
+ }
+
+ func emit(_ event: StreamEvent) {
+ continuation.yield(event)
+ }
+
+ /// Without an `.ended` event, as a buggy client might.
+ func finishEvents() {
+ continuation.finish()
+ }
+}
+
+final class FakeDiskSpace: DiskSpaceChecking {
+ private let free = Mutex(100_000_000_000)
+
+ var available: Int64? {
+ get { free.withLock { $0 } }
+ set { free.withLock { $0 = newValue } }
+ }
+
+ func bytesFree(atPath path: String) -> Int64? {
+ free.withLock { $0 }
+ }
+}
diff --git a/Tests/KnotchyCoreTests/Support/Harness.swift b/Tests/KnotchyCoreTests/Support/Harness.swift
new file mode 100644
index 0000000..31214f9
--- /dev/null
+++ b/Tests/KnotchyCoreTests/Support/Harness.swift
@@ -0,0 +1,87 @@
+import Foundation
+import Testing
+@testable import KnotchyCore
+
+@MainActor
+final class Recorder {
+ var quitRequests = 0
+ var setupRequests = 0
+}
+
+@MainActor
+final class Harness {
+ static let url = URL(string: "https://example.com/")!
+ static let otherURL = URL(string: "https://example.org/")!
+
+ let backend = FakeVMBackend()
+ let connector = FakeStreamConnector()
+ let disk = FakeDiskSpace()
+ let clock = TestClock()
+ let recorder: Recorder
+ let controller: SessionController
+
+ init(hostNetworks: [String] = ["192.168.1.0/24"]) {
+ let recorder = Recorder()
+ self.recorder = recorder
+ var sessions = 0
+ controller = SessionController(
+ backend: backend,
+ connector: connector,
+ diskSpace: disk,
+ clock: clock,
+ hostNetworks: { hostNetworks },
+ requestQuit: { recorder.quitRequests += 1 },
+ makeSessionID: {
+ sessions += 1
+ return String(format: "knotchy-%08x", sessions)
+ }
+ )
+ controller.showSetup = { recorder.setupRequests += 1 }
+ }
+
+ /// Lets go of held calls, so the fakes' 10 s check can't fire later against another test.
+ deinit {
+ for kind in [FakeVMBackend.Kind.sweep, .preflight, .start, .destroy, .forceDestroy, .fix, .stopService] {
+ backend.release(kind)
+ }
+ connector.release()
+ for stream in connector.connections { stream.close() }
+ }
+
+ var state: SessionState { controller.state }
+
+ func advance(by duration: Duration) {
+ clock.advance(by: duration)
+ controller.fireDueTimers()
+ }
+
+ @discardableResult
+ func openAndConnect(_ url: URL = Harness.url) async -> FakeStreamConnection {
+ let before = connector.connections.count
+ controller.open(url)
+ await waitUntil("the stream connects") {
+ self.connector.connections.count > before && self.state == .starting(.loading, folded: false)
+ }
+ return connector.connections.last!
+ }
+
+ func enter(_ mode: LiveMode) {
+ switch mode {
+ case .peek:
+ break
+ case .expanded:
+ controller.pointerEntered()
+ controller.expand()
+ case .collapsed:
+ controller.clickedOutside()
+ }
+ }
+
+ @discardableResult
+ func goLive(_ url: URL = Harness.url) async -> FakeStreamConnection {
+ let stream = await openAndConnect(url)
+ stream.emit(.contentReady)
+ await waitUntil("the session is live") { self.state == .live(.peek) }
+ return stream
+ }
+}
diff --git a/Tests/KnotchyCoreTests/Support/SetupFakes.swift b/Tests/KnotchyCoreTests/Support/SetupFakes.swift
new file mode 100644
index 0000000..394a745
--- /dev/null
+++ b/Tests/KnotchyCoreTests/Support/SetupFakes.swift
@@ -0,0 +1,117 @@
+import Foundation
+import Synchronization
+@testable import KnotchyCore
+
+final class FakeHost: HostChecking {
+ private let value = Mutex(HostFacts(unsupported: nil, osVersion: "macOS 27.0", bytesFree: 212_000_000_000))
+
+ var current: HostFacts {
+ get { value.withLock { $0 } }
+ set { value.withLock { $0 = newValue } }
+ }
+
+ func facts() async -> HostFacts { current }
+}
+
+@MainActor
+final class FakeInstallerSession: InstallerSession {
+ var hasQuit: Bool
+
+ nonisolated init(hasQuit: Bool = true) {
+ self.hasQuit = hasQuit
+ }
+}
+
+final class FakeInstaller: RuntimeInstalling {
+ enum Opening: Sendable {
+ case opened
+ case changed
+ case failed(String)
+ }
+
+ private struct State {
+ var downloadError: DownloadError?
+ var opening: Opening = .opened
+ var calls: [String] = []
+ }
+
+ private let state = Mutex(State())
+ /// What `.opened` hands out; it has already quit unless a test says otherwise.
+ let session = FakeInstallerSession()
+
+ var calls: [String] { state.withLock { $0.calls } }
+ func failDownload(with error: DownloadError) { state.withLock { $0.downloadError = error } }
+ func open(with opening: Opening) { state.withLock { $0.opening = opening } }
+
+ func download(_ release: ContainerRuntime.Release,
+ progress: @escaping @Sendable (Int64) -> Void) async throws -> DownloadedPackage {
+ let error = state.withLock { s -> DownloadError? in
+ s.calls.append("download")
+ return s.downloadError
+ }
+ if let error { throw error }
+ return DownloadedPackage(directory: URL(fileURLWithPath: "/fake/knotchy-runtime"), name: release.url.lastPathComponent)
+ }
+
+ @MainActor
+ func openInInstaller(_ package: DownloadedPackage, release: ContainerRuntime.Release) async -> InstallerOpening {
+ let opening = state.withLock { s -> Opening in
+ s.calls.append("open")
+ return s.opening
+ }
+ switch opening {
+ case .opened: return .opened(session)
+ case .changed: return .changed
+ case .failed(let message): return .failed(message)
+ }
+ }
+
+ func discard(_ package: DownloadedPackage) {
+ state.withLock { $0.calls.append("discard") }
+ }
+}
+
+@MainActor
+final class FakeSetupDriver: SetupDriving {
+ var state: SessionState = .idle
+ var setupLog: String?
+ var setupOutput: [String] = []
+ /// Used in order; the last one repeats.
+ var runtimeStatuses: [RuntimeStatus] = [.current("1.4.1")]
+ /// Used in order; then `.ready`.
+ var checkResults: [SetupRunOutcome?] = []
+ var runResults: [SetupRunOutcome?] = []
+ var holdResult: Result = .success(())
+ var finishResult: SetupRunOutcome = .ready
+ private(set) var calls: [String] = []
+
+ func runtimeStatus() async -> RuntimeStatus {
+ calls.append("runtimeStatus")
+ return runtimeStatuses.count > 1 ? runtimeStatuses.removeFirst() : runtimeStatuses[0]
+ }
+
+ func checkSetup() async -> SetupRunOutcome? {
+ calls.append("checkSetup")
+ return checkResults.isEmpty ? .ready : checkResults.removeFirst()
+ }
+
+ func runSetup(_ issue: SetupIssue, continuing: Bool) async -> SetupRunOutcome? {
+ calls.append("runSetup(\(issue), continuing: \(continuing))")
+ return runResults.isEmpty ? .ready : runResults.removeFirst()
+ }
+
+ func beginRuntimeInstall(replacing found: String?) async -> Result {
+ calls.append("begin(\(found ?? "nil"))")
+ return holdResult
+ }
+
+ func finishRuntimeInstall(_ result: RuntimeInstallResult) async -> SetupRunOutcome {
+ calls.append("finish(\(result))")
+ return finishResult
+ }
+
+ func waitWhileSettingUp() async {
+ calls.append("wait")
+ state = .idle
+ }
+}
diff --git a/Tests/KnotchyCoreTests/Support/TestClock.swift b/Tests/KnotchyCoreTests/Support/TestClock.swift
new file mode 100644
index 0000000..884723a
--- /dev/null
+++ b/Tests/KnotchyCoreTests/Support/TestClock.swift
@@ -0,0 +1,66 @@
+import Synchronization
+@testable import KnotchyCore
+
+final class TestClock: KnotchyClock {
+ private struct Sleeper {
+ let id: Int
+ let deadline: ContinuousClock.Instant
+ let continuation: CheckedContinuation
+ }
+
+ private struct State {
+ var now: ContinuousClock.Instant
+ var nextID = 0
+ var sleepers: [Sleeper] = []
+ }
+
+ private let state: Mutex
+
+ init(now: ContinuousClock.Instant = .now) {
+ state = Mutex(State(now: now))
+ }
+
+ var now: ContinuousClock.Instant {
+ state.withLock { $0.now }
+ }
+
+ var sleeperCount: Int {
+ state.withLock { $0.sleepers.count }
+ }
+
+ func sleep(until deadline: ContinuousClock.Instant) async throws {
+ let id = state.withLock { s in
+ s.nextID += 1
+ return s.nextID
+ }
+ try await withTaskCancellationHandler {
+ try await withCheckedThrowingContinuation { (continuation: CheckedContinuation) in
+ let outcome: Result? = state.withLock { s in
+ if Task.isCancelled { return .failure(CancellationError()) }
+ if deadline <= s.now { return .success(()) }
+ s.sleepers.append(Sleeper(id: id, deadline: deadline, continuation: continuation))
+ return nil
+ }
+ if let outcome { continuation.resume(with: outcome) }
+ }
+ } onCancel: {
+ let sleeper = state.withLock { s -> Sleeper? in
+ guard let index = s.sleepers.firstIndex(where: { $0.id == id }) else { return nil }
+ return s.sleepers.remove(at: index)
+ }
+ sleeper?.continuation.resume(throwing: CancellationError())
+ }
+ }
+
+ /// The woken tasks run concurrently, in no particular order.
+ func advance(by duration: Duration) {
+ let due = state.withLock { s -> [Sleeper] in
+ s.now += duration
+ let now = s.now
+ let due = s.sleepers.filter { $0.deadline <= now }.sorted { $0.deadline < $1.deadline }
+ s.sleepers.removeAll { $0.deadline <= now }
+ return due
+ }
+ for sleeper in due { sleeper.continuation.resume() }
+ }
+}
diff --git a/Tests/KnotchyCoreTests/Support/Waiting.swift b/Tests/KnotchyCoreTests/Support/Waiting.swift
new file mode 100644
index 0000000..d753101
--- /dev/null
+++ b/Tests/KnotchyCoreTests/Support/Waiting.swift
@@ -0,0 +1,19 @@
+import Testing
+
+/// For work on other executors; controller timers run on the `TestClock` and never need it.
+@MainActor
+func waitUntil(
+ _ description: String,
+ timeout: Duration = .seconds(5),
+ sourceLocation: SourceLocation = #_sourceLocation,
+ _ condition: @MainActor () -> Bool
+) async {
+ let deadline = ContinuousClock.now + timeout
+ while !condition() {
+ if ContinuousClock.now >= deadline {
+ Issue.record("Timed out waiting until \(description)", sourceLocation: sourceLocation)
+ return
+ }
+ do { try await Task.sleep(for: .milliseconds(1)) } catch { return }
+ }
+}
diff --git a/Tests/KnotchyCoreTests/WireProtocolTests.swift b/Tests/KnotchyCoreTests/WireProtocolTests.swift
new file mode 100644
index 0000000..eb33ff6
--- /dev/null
+++ b/Tests/KnotchyCoreTests/WireProtocolTests.swift
@@ -0,0 +1,216 @@
+import Foundation
+import Testing
+@testable import KnotchyCore
+
+struct WireProtocolTests {
+ private let size = PixelSize(width: 1024, height: 640)
+
+ private func decodeAll(_ bytes: Data, into decoder: inout AgentMessageDecoder) throws -> [AgentMessage] {
+ decoder.append(bytes)
+ var messages: [AgentMessage] = []
+ while let message = try decoder.next() { messages.append(message) }
+ return messages
+ }
+
+ private func decodeAll(_ bytes: Data) throws -> [AgentMessage] {
+ var decoder = AgentMessageDecoder()
+ return try decodeAll(bytes, into: &decoder)
+ }
+
+ private func violation(_ bytes: Data) -> AgentMessageDecoder.ProtocolViolation? {
+ do {
+ _ = try decodeAll(bytes)
+ return nil
+ } catch {
+ return error as? AgentMessageDecoder.ProtocolViolation
+ }
+ }
+
+ private func raw(_ type: UInt8, _ payload: [UInt8]) -> Data {
+ framed(type, Data(payload))
+ }
+
+ @Test func matchesTheImageProtocolVersion() throws {
+ let root = URL(filePath: #filePath).deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent()
+ let containerfile = try String(contentsOf: root.appending(path: "vm/Containerfile"), encoding: .utf8)
+ let arg = containerfile.split(separator: "\n").first { $0.hasPrefix("ARG KNOTCHY_PROTOCOL=") }
+ #expect(arg == "ARG KNOTCHY_PROTOCOL=\(WireProtocol.version)")
+ }
+
+ @Test func pageURLMustBeShortUTF8() throws {
+ let hello = raw(MessageType.hello, [1, 0x04, 0x00, 0x02, 0x80])
+ #expect(try decodeAll(hello + raw(MessageType.pageURL, Array("https://a.test/ü".utf8)))
+ == [.hello(version: 1, size: size), .pageURL("https://a.test/ü")])
+ #expect(violation(hello + raw(MessageType.pageURL, [0x68, 0xC3])) != nil) // cut-off UTF-8
+ #expect(violation(hello + raw(MessageType.pageURL, [])) != nil)
+ let long = [UInt8](repeating: 0x61, count: WireProtocol.maxPageURL + 1)
+ #expect(violation(hello + raw(MessageType.pageURL, long)) != nil)
+ }
+
+ @Test func helloAndVideoBytesAreAsSpecified() throws {
+ #expect(AgentMessage.hello(version: 1, size: size).encoded() == Data([0x01, 0, 0, 0, 5, 1, 0x04, 0x00, 0x02, 0x80]))
+ let hello = raw(MessageType.hello, [1, 0x04, 0x00, 0x02, 0x80])
+ let video = raw(MessageType.video, [0x04, 0x00, 0x02, 0x80, 0xAA])
+ #expect(try decodeAll(hello + video) == [.hello(version: 1, size: size), .video(size: size, accessUnit: Data([0xAA]))])
+ }
+
+ @Test func roundTripsEveryAgentMessage() throws {
+ let messages: [AgentMessage] = [
+ .hello(version: 1, size: size),
+ .navigated,
+ .progress(0),
+ .progress(100),
+ .video(size: size, accessUnit: Data([0, 0, 0, 1, 0x09, 0xF0])),
+ .pageURL("https://example.com/a?b=c#d"),
+ .unknown(type: 0x7F),
+ ]
+ let stream = messages.reduce(into: Data()) { $0.append($1.encoded()) }
+ #expect(try decodeAll(stream) == messages)
+ }
+
+ @Test func decodesAcrossArbitraryChunkBoundaries() throws {
+ let messages: [AgentMessage] = [
+ .hello(version: 1, size: size),
+ .video(size: size, accessUnit: Data(repeating: 0xAB, count: 3000)),
+ .progress(42),
+ ]
+ let stream = messages.reduce(into: Data()) { $0.append($1.encoded()) }
+ var decoder = AgentMessageDecoder()
+ var decoded: [AgentMessage] = []
+ for chunkStart in stride(from: 0, to: stream.count, by: 7) {
+ decoded += try decodeAll(stream.subdata(in: chunkStart..S4ZQK2|Ic?jvZQHhO_s+j(&+cCA%cai$di4
zM3#k-trHM5Sc-)a6EhGHsz|t^yaYT94h#?w5WJM6sPaEA_@6;R{5zIgIBfrOz)s2%
z!a&v2cxV4Qq9z(rrgCyX)c@L0K)|6EKw$rc{4<1IF-BkI5oB6zQby~hoR-7};8}RTG
z5N=1PVAum&Mz)4|G#ywD3>g=afn2u08|WMCqMOqnqz|zjFjC|l~Jy08oNBs0$E-}!V`WFUz@z!n^-x=$uVM#SbX7}Dpo7z&}V_Ntxr
zApc!Jsi(ijA<|C_yFJV~w~3iT{XL^j8Pqg^WEn`&APLFwde9>Ns7Dl316RVD=KEK
zc#Igvj0fmUw!P~LzQTd+Ejh2F~uV$&-YsX9$-~*rftPblYKH*RE
z@||4fXNb+`#Nsvsm;*5}d<@CLb!IGut-&S3>BEaufTtRk6b6JmBiPkmq|ip_VK$Df
zFp>53gjMP>>8w7gnfM`uWU#BtgiF+8@7>at_XESzQ&H54txZ+BPKP|1pwG^u3;Gc3
z#Wq-Sxl#8;>69=`my^TGU@^^kbg4SJ_`5X?U4okN2D{(J&g9xDWC7eCweOitxqsxZ
zr=%2!<29`fYh;%W)As5+`Pa%x8fU(bBNbEzHDU->T{$-5Unl9NctmI|}ut|0E{MNK*jy$xkgGPM=8M4-v|bW0{j*pqe?4
z?&z*&AR+L-lWH2eb!sK=yu~Vc*wmLJ2mej8Yo<z$iDeA%H7ZFbO+BTH<85PhQ*
z*qPM!SU#b|kz_a<8}m_z>wMcSLsBWP;EUh!atr<3MGd;|b3=2(H?VrD#gmTxG5T*L!C)g_cAis
z&
zn-&jAkA$(lG8#4XqxTo*36v;Z6kmIDHQ%pqC9o^&RXl{1%!d@T!wo`gK@^-WLWv%|
zE#`99F}9869hiTQT#%#w
z4BC3l3B^wi8XrP4ORK+nn#&Y?KPnO0;N2%87w%IO43)(7v{5DXy6Y)(LMqwKC4g204hd45K>&d}J#E!&%V&
zM}d@ZjLCrTv7&fBaOEbg+#?bec`C)N>LG-*cs~BRwvxA4pAJWgj4wF2U3r6Afgjrb
z%oTcjP;476Z7>eS?P{|-pPgSna&{!|vVl4y^7aha*WqW=F64g{?0k|uW8z8639Esa
zr%ZI?%+G<@Ajl?L-S;zPDqP5qIFezs+&0YhI9e(#(?LnFBwy7e9bNO$8kPJ!Y)~Yc
z<%F-9J@CK~ZEdnoQdSR^u_S)oNs5tA&`X)y+k`BMd)_K0b#v4Up>qYcJ>pGO;JEKn
zL<5~puIF{?gos3gQp|k4wY#LwI0pjpMn3ehA;wC97nnj<<#Uc^46);k`#xiGH^Ds8
z0uzP_1O_KI%M#x8ETj;yk}i-A7$30<2ezQf?<
zK+$%+Fwl&a``UrzK(`2R(EV@>pZ7__E4BPtNp$;YaQBhO>TXnjIywTmgi9pOT+d0-
zwl{|{pWy9CQ^h*m@y09_N%`rA?awAZ)6gEm3rI(*~X
zsvtk4g15IK|AHtENAND4%B{D~cJ}D#-3dP)|2@yLpe)_ltrHN0n$U(4{y81`ZY&r%
z3DPfkNk8_@qhPu0r^!GdpCk06zuCz+eHW?}3B5Ek*$3{r@gG%FGM#^FY=$
zpAdUwn0*rjwiQ%$1BI!$B(bt7HX=osT|Qbhqpz+HzF5v2Vf{(b+&QHoaotm?knB=`
z));-owkDt)g19N&zcJQwbi+N-K2lhlWm>jPJVQ{!nadfj2I=!skr
zBw5mTL<6gA?72j>a*vOv&NY9nIApSRp#s4Dwp(YSQaIS^yYJ5IWJQ_S`7=w0X+V9(
zEdJrk9d*EUP#!A&h5F20&V?=9J7+{UkqHly23_Iuabmjz=ClX1q5
zmk?23YdtZ{_~bUqxq0aR#H!X#prB6$(AXbS{<=@ED#|_H#+EO;v1;`
z?vAYU&-+y9un9wRH@A6hy3$A>B6n4)lK;>iPR7j|v|>>$)b7^C%8YcuRv9F$d^aHJ
zi<@UDz#(Ev{fhYhb1q`j+c)J_M^U|hS2o-v)oBxqmeKpT;4W*`!*-L2EP)pqqW4N3
zv4me+`~&-Qfec9DfRl8RNkkZualZQ3q=$FbZ*$jsHd^0|)!R
zl5hZTn8ZQP8W-8jK9go2%86X6jUkA{j{B!I7kL(762=}jv?aFyl#Tlro_+aZ=gJe=
zL}hP^r*3vDAYt7PKl87`{!$7Es!%8$@nYHiVsr#f)p*y3*^w=6W}$X2RnK!DV-YTE
zj3V7u^xq_)D|`s_`E$yzMxdl&vy+Z>`i8`}sn*b6%Yy>GhIkCp)Q;Q2lP;a`=l$A7
zAef^Z#dTHDD~DXNNq<^>U$U|^pf*g9aC=X(GZQss1KPQqNv$=XQ
ze>=2nQOjJ`Uc}7dI2fx#FdbpUCzgX_T-x@jmz#$Mdzl1lWnk?TFV*i`p(BNZcuzcR
z+oLEj(OfwB0L==g;B?y!kaYZ3X}O#2w4mC|f8h^InjL_tjO9!Z^!DJwDwBZoc-6;G
zFXz~^E)YkBcW&roj!zAq>n(hXGhF3sg+gGtb}#29YCzC)hTCr;K}dfJ<{hsb;t}P$
z^EmTqKjP}hvpF#=omliD`1-9kpwSs6p$ToTWFbH;qf@>}16f6KP&fAz?G|L2S^sJ`
zaCPABk%l2SS|FQ2rcf=$>kq3gNR51
zyx0da|LeXH)%m{gt|nzJJD{3sBkX~X2DtQ0tIc4>#+x3AvkC(5ILk34Y1v<_yB(5&
z0s0dTOW0#4WMu7EkBcI9=vrv!2FLTbBBaj!{b0-0kh;FRLGCi=lCxVMMJ&~TzyNWT
z=WI-31Hd{qm&Qf%-zsW|Xo!qn%XTkND+UUFF0+Qxu!~ZHoA{^cq~vH8tODq(a{!ax
zBH@GKD&gr}StKjLNhraMxckb%u@?L-2-T!bB;gc<^@DEJn*_n)hM}AJ#ZER+2{BuA
znZB1J|A2Oh*4&brX}~u;Tl{jxIwQ_bZ?RwoYTDs%le^z*Z&4TXUTh=ZH*aouzR=@|
zq32Yy6xANx-wbBkb8{A3)}e7?ESqEe7Kc#oZVw+BbpHak=$=|-Mv*}a%!wFp!!IMY
zTSRvnc|X5*0bgoPmnR<3m0h}w!OqzmPhJdx${iNg?Yj({bA&4;Vh;#wl2qRKF^x(<
z)0C}+iocC&nVOz+Td<{`n%ch9B!YZMB7#1C1J<{}OQFukAYgLWCpVcB#JWF`9I-bC
z$s3}+W&IsE`;5IqHvXR004}?cJa0+w)E79q4Awvkq_hl2)s#S`s9d9~mkv}IdzRaU
zx7p$`_LbjnAQ^ehQ6FPNMi|j}ti$am%DVL>b#v(E4Qg>>!d#+hTO=*+IbNx)5uOw^
zuCY>ezI^s8)40~}?IUC^43cJ}UB{tmTB`A2raO`)ofAH!7XABIx0d$yk#0I(Z;b%K
z2qIz3E<7r6*^YzXxfide{)X`5F@uD5Igu4|;mJanIo39<w82V}W-yYczShG)Da&+y}?zoRRf|Yf>F?)^Q=F8vHS=@5E
zY}LM~TB$a}iy)@uMZj?6B_)1uUZG6)Vz^-Fzs&^Sw!>qo?_F)92Aq{+=e9Fr8t&%T
z$5g`d)8;@GYCqp#?-#+0Re?Sl27c?5`7HYe2vyoeFu{bl{HB7>4oIr0fKVs43trwe
z2Za$?cb-jN&zfl&<6et;R_OOLFMr
zQOK~cdNE9+jFxr#n(4UeAZrYG{TD~CaJF$Y3)_cYboMG?_?++C;;!!Xv
z;k`+?pKY&ZpaXKodO|2x?VGYO1sbVvU@Swk}+7#3$33;%JYqd<@MZ+W}=z(W_PX^Xe;^Z$V>DKUA`YGM6A3nNAjARyM%{|7?z{}<-}KM~phzrn=6&i@yL
z=Kp^owEt!Rl8ga!0|H`s|6d5r2fEQj)#JGPr8{rC!n5W$(2y1hpbSi5nk2O`x*KK`
zzszn)s%gROJhHl#Zq6D+zp%<48TLGng(?MViC3o$4FZ8~Ob&$xqKYP>BsTSQ?Dg^S
z?dNxL>2=+8v;9yGqfxO_&3*DSv;FgV(=fyTk?o`l^Ou|SQ@CG$0
zq5t2|>kkb`(n)K_jLU~7yk3ENzghbA8k~K32WDoS)LHhKM$(+Rth?tXtgiTq?i_yt
za1wpLa{(xKHoQ8nffgx8l^6LPYuotFAMi!75;k2>U)x?FCt
z5_zCxYf_@=`RQv{7x^x~XK80@zA711@=QiK-}G0D#yU_W#|-Hh%^A9+pn)!i4`%bk
zB2wx(*>}OsFe{ma8HBjI<&YExd>p>pILn{YaxJ}`c}p98)A8zL)0X)p
zk;7BCcmY3wsj2IV8M)h}tb$#Y!qqBk^Fg?T*|YT;40wYJ2)XVCsl6?)+6a=JDdPIE
z4mU&rKy-Y!_>kr-s8ohyX(jFuJyN}juYLdw{yB&m>P7w|eRQ18I#mS{8Dl
zs1a&LMY1UhlsM8pR*ptMWn{CdgrT-WBitH&XWiDd5YF^>cVx`sMZ!Y#`(*a;r;(5hUm##vPM$u_<~k^kNl#Za
zS1{>4_LBa%D>-6;P6BMwvY67u2Z?N*xsxt#RvFIEW%SARYS
zl4|+fHsJE{l&&+N!=tpCysU7&Qk$c?nvaF=yri14Wy__@s9zE&yNd>mjii|_7F4wb
zWo^Y+yT{8qF0SpP7^-O4%1478vzTkz;)x(a4BrRJN;&Hfi$6Z+DLX${w5wUxmvCof
zLb|!_FZ~T}^ug7PZ-*yHGc10{Eq_6EAMZ^havoy8V3Rv@wW(l>?mdnf
zv>ad0Fk|p;0~OROzAn+Kh8mz|W)t_vHMLUqEg7U`Ey5b0P@2rSe>a_{n=eW74HhYI
z=9z<03AV0Beill>o{1*xXFY~v)GA-$V(B>df;aX3ojTaysEmwf#m;=t(Wl4vFSeQ=
z86yb&7L!@--0$BzlJEsvwaaQuRBtXCdwpk3LN#xdr_%D
z#z-N{08O>MmL0Y9Ph46u2%wk{E%lB2TnmUV2ILjhl*30`wOQ7bx|i3+DJRJSU^^
zLlXo#z7Yv;17&d0X(x$z&O%&y$c>d&$wbFU4~O+(JoPoxY~=^|BDuxOS%y^7(JmN=w`R2*O2}3#m8E#
ze#Vlt-oqV>#@cKQWxa5&2XD&OjLqTH>AyCN^vzPl2NS=A`#QB>(W
z&+hajKpvOfJ$A-Rlc>E$XSEIaP37A_H_5*AESQ0w+4jL7yDS^C`g3
z>CC}(1t|AVFAN&a8h$
zpZAEZTZB{h%VS)wywxR;tq&9u-!F7O+s@>Z;*l
z>At%rNI@D&%@7UDk&hw-=I~S&AQiWA$C4#EOWO}FZRgh%iE!3XM7C1IFb*x*I;LsN
zleIH{DVD}87xK(=Ed5Qc|HYcgtn&6T_7kv2HW_>b9>;aw2Kwj;9jEAu)d9Bn9=gn2
zn)&8wpNIZi7m}Lh%_Sw2-}y*{Q>3_EcYTWig6o}P@gT;MNbLkYJ_|n0<_cUJO}%i&
z=GU@THqH0SJ4R)&OFNi3Sgv}6Y{gw&@d|>VBTOU0EQjN*bfw}0JEIK$ovm1w2>$Sy
z6RroW$y=oB!)Vv2g>p^=ehfwN${5NWS0=8{wvg750LSMD{vMJObC=VByn8i5F3}{6
zluoe*1=b&z$2Q+(BB9DU0P&wFB>R5X3^G(3z%T|Xt#6GnMpo~2OTflg6IDJxyELNW
zLMY$bEGcCNSk}l{n^_(yhVaN1dx_1{$Wg~kJdI?w*}~5pxZx^#YHF_EduKhf@H{TYWTYVOOr)F9tk+lUT63Q_z+Ne{QKbzI6K~waG
z9H>8so-ka%hDQG$7!Pi$HP1z{tWAl%vBs?l9dTP4Xt${~T5xVXt1GKDnWV6-F7Ny?
z)u^|s=VKw58HGp40jr-eT7Y8Ire+TBas^^mBx<21nBa*o!O5;MYQ~EP8T#X#X|rZA
zRxW857rH8`F#5~8v-A
z3zDKT2+PAkJ+4ffe=E5fuR8c477wn5&yXmy(~}79{?ky(dCeiwiIe*Tnr1a-NprD|
zX6t_Nck6j~o&D3-fdS&mMPY(5Zxj;IfaZxgZb(0bDugmtYmL?*|}wFCR6eKOUT{Mjk(&S;Y=u
zMVJPq*X>2C(_%0mc*(QAQK?5&YQX%qr-BjuLdb#k?r_|a_$$XdPLB?bpIgUuM5FaH
zhR?uI>&|j{rlG?_`3lv#=ThjD*7NrEteN7b`<*OzJti74(q3^qln}3x#-`Is!gM9M
z5VZ4(zf$aA5v+=vYE27{7Ns%CCW)fz8Zjl44`-Qn*+Q)_DIcq|-#~^rvYE)DXOkJ7
zzRgA9^|>9IrAZZZW=;Bal_u`>y
zVZ=o}Xn^+nY4~w5!A-{l&T<~1R}aRF&P1N2yaAqXKKrI1;nQpyr6dO#XId>Xk4;ph
zvfusy{JHx86Hu|!N?M6s#PxSM*rdJ-#|Fj3jCd4!fhFF%nl*GWq}|Bj>U%>yHpFVX
zo-{McBUm*%*yrC=*VH>mid$?%N2kYoiAn$<7
zc_>jBbRBaF()!T+_nBgH!82Y}lL~;0DJ(6~qA={3
zfb+cl>+4yhbr_SGm~4Pt_XQD(hF}2AsF?ZZ{+^I-%z)@MZjBz^_Xrn>!CEe21I+PQ
z#RuaU^3L`JbCtUZQBbc(_}gn4>_AQ?uXUY1p5ZC8`QtH3?P-P!%I>=a!TxZpKMO}V
zCF-2biVS3&4@786r55S{NXH~;=pbwcc38Wt;3emBfPW96+4m5`!Gduv&>x6!Ob$;&
zR#8PjLvY@Wn_h;l2_VxS$^kY
zv*95IO)P$Y8959N6?7vUmkw25K~-8n^|BF-?=iUr26j1jiY~W*tDJrjw=+_W=%xmk
zSfVh_@Gnpm_xS*yy@HY$cl&6B#z3WJa5)fk=zg>uE1s0U#AamTA3c6sl-8Pnj}r0L
zr?N66_0&Hz{EH@mWW4>c+0CQ$5|_A-dW=I2zNj1M67AJksAjfM`@`kcMY52&jG3K2
zG(6b5$Rul*np*xI+hk^Y(KXhkY;&7=q90W(Koqjg+@?0plWzq1-u~>=G^oe1`2zwH25DP`i=7wHiPE&BwCX`xvsBn
z`T`eFHT9@vNMPgwQjW
zp6vHpnjxMWQ0K~CH;$$x-${60Sy)3Y=3N<141v!QYOtU$bEn8wj-GU;tN|&$E>5Y#
z(HS!!t0&%p>q>fkMP+w%dfWHCvEN|KZy?Zm#0^ChD|5azr;T<`T3RxQm8fu4oaawX
z>w%c{W1#dw7Vwe!*|@=xx1A&q13WPXdi{T&E?22Dk$!HxEy+9gGPG?hQj|3*(-!B6
zc%_NLn*{jgYUlQ4G(OkZl}65W^swSfl)8~+6c>a@X#3%p-fACmu5l4LY%}3rtkXj9
zT6?X=$x~
z))O_=LZ~xX)xfNXN~M&^i{*ye8%CK1LC%|5Cup-X+#O7!_TVndW=Qky&zW9@0wVEC
z+QRuVgGvM=*sn1+{P^s#Ggu1MvD04vsvZj`jy|cP6=S)X;;SsGh$&ljJei+}83UL%
z>jx|53$s2gmaRC|o%&K5U5W;-G@BqJXB8VFaL%T&B5y6=P7!WCZXMCoTaDSF$OEJz
z2w$W2Bc;UWkz*V_zb_tZ1I*OQl)FK9>zr{6htc3}v4~#(_QnJAvLL-$XsEoPBp{@m
zs%gELaa_S@k0^!yu&;}wKn(tP*^e5z{Oy2xzYCgsNLlWuhU@c#NyGGhIJ-qs+pp|>
zhC^YnHRpvI>)G!tGGOA3p=T3%AM$(~0e#Ed&zOVef3NA#a*?Ef2ljpMBfx#9?Eyb(
z$^FDAgwml#(;;~NJ?`o+T@a%xh-DQc98A>2ghdNzoi1b;YJXCurrci
z-M2~*l#?F_olL7B#tW-!Wg+$Hxo~F}F(6G%0Ox23OH#`2l*yV-H$>B&g&MYrs?Z#~
z+yP^lcfZ*YHqc!7&xoM!em?Jm_huBdv62mw6yDWHT2l;;Za_ZUUxX@$ewJojJ3PcVeon7u@HXZ##D>jH($;dF7doQ)Fe#?196077)h*z~#zKum?R6H7!
z@)hy#nfsPA+y$QuIT>xv{-1n6SSDR@!)XD~)=uK93>DaPos8L&xFY0ctT?k&7=37F
z_#AU6YW>WUjRIc7VM|&KXTPY-3#!RR_afEbiH0@5#a8lB{Rh|ObPCZG0G;R`m)Mc^
z+Gj1M_u8{ZGKe--_{guBff<>-fdt-xD{
z%fm*5H7P|#1&-#)ry;*jN4jr=#wAw~SnZ>$(-H0+XfA#nowH>nApdyXR`%+Ag)S96
zXr}iGiyUAJnvx0cW5hv)XOINuZU8nqriX%NO1vm14#n0q1@mb`vT-fI+CW~5Pxc<0
zsas;3*=)=Y9Iv)oYg+nU6KQ<8F!+6B9Fk)o4k#ua&N(miFNCTE*3F;AGbY`3#eP=y
zV+zNzC%bj{Q(CsX2rbYc$McB;2UUK8gGzr>?Eu^3?iQzVF^V8zMIH7`N~IfybjV$}
z$r%;FX8D`(T!4##y2B8_VfVK5%gQHSZB}{BJ?^D{OUb@(VvVzln-Numys7K2?)=v1
zH+eAgt)uWhA*RnR3#(IIrBEP*#w#}|5}6h1UK90etrO)8;}_Xk$1E8t8R#eBseAq_
z<%)mhao-%ZojrFUy4Bt740#){5PWBBM9hkJke?g-*M4$X8gZ199=K=lJQbOVk(3_H
zs3g=dq0I0E(dZz?lt9#D4N)5COS-(pTvG%o?lUZQ>xOP0UndK8S
z#(u0)D}w87V0jHCSUXv#t!PhAI
zy+3v)s6{rU-zYFt_Rxg|?s@kUt>LwMgN)rn!;;k;>8kr+uakSOpR*w^av)wfl%r$K
zu!_eG^mVJN0Dc}!#jpLLa96Qj;O@$=MUdz5cQN?(q(q-MwBfi=GUf0gWoU;#CK8tE
z7ltGRne8EXH*&&EPj|3D+?`_k<>>j~%{tEBLeDBb!2zHtoIM^UH@f}H&ATSidTm6D
zUfieum}0g9HPkU2RU99;_PcMjmG01*?&`2&x=dw9>uqCcvJBK7V>G%&H!x&?N=Wxz
z11#8S`{l@Q02EVH1BwkBO;pjH$BpW`qb}2qnJT3Zne^NAvv%<4NH*jUnfwS$iy+9ju@_z6tuO$gmd85d(lumh
zfJ?*U1B)Q@x00E%|IQRKr;^^{45ajRU%~E9uN|yw!uY?Z7THF~m$nrU^HCW2tlMQv
zyBP$jBwPFjE*AJ3$HCRVQX>nx={Yv5lQA>M#2C-`F$7n{_O&@2n}-T5hj-7|Xyirt
zF~_x@KGu$2g?CH;3}KeEc9&7vCI$ru!LTpU4pR5z{nBR4B{>>gQ#`gEaaSVi2W4gN
ztTciBwo#6*6U_;H4qISj0X{mXjjj5P$7Dfw?^jg36BO6s)Y0FtdlHAi91ctDTJ{I@
zr_Yx?)VtmjSOuY%8E}L9%S>KF(Jx5b*uiy1^}{mfei0Qu^!D=jf_yQ}X~ec{
z2>Kv*SftrDp9-n_l^-C!IX!+fGmJ4{bt$m(sN?#;pFWeh0>P^M2xTyb!Q2n?y~VP<
zZwogsjAw~m)7NHP4&x}SZHpFC#BjqOabN6zu|)W3bX%}*K+};>V@gc*4@>S+KW=j3
zrsYO~JnR3#PYAu%j4ZUR;@UZk$eJ}Y?C=UGg^i_Ul1vrIQTz}l0#(js%UomUf4flMv%ZaFd5ly%dUt|GI=*pzk5s_)V$+%~0J*F{`=CcDj4QPg_ZCL^JPo1q
zD4q}CE)YU9GS4P%2HpL?+GSIq;db^9EbC$(l4)k};ctes!c$6D>*X_2D49Su9TpGbkiAJ}RJLzIdY35>R#6j;0FDxE!X+y=u0G3`gLm)Y|MM9g;^DcL+
zq?ePSK-YCYE^+2$j$9GlSdJL^5f*@HPk16NQYx>oasklylTF6}L-wH2=^dfP>x>0F
zOD65G=@oAnD?hN{CNiuX5@mlB^#NnOhe|8eiUHXf9R!2IG
zj`7j@i8~Clc3C*J+rm#Yc<;Z`)M?@D_$>o|z|5LOkLoq!94AdSf-`b5p$R)(B_>!R
z;^jsStASIn>`Htr-E_WXOjAKtw2QrcGcmivXdLA9f=QGaOVdAq3U*n2M^yZ=SEL;3SlOtvRnsdjIZ
zuf}7TWrE-Oq!{XEoeg~hs4>!chz%z_6n6s)Z-9DNdgvbA*<9b4%M=HK--AmHaVbxz
z3$(lt&G7*s_83@?7_HcSZ$IB6)?mYz>^9XUgV_Bb+g;u|Ey^@K%7{g14DSkX-U-Qq
z6Zk1mH`k*gzno%RHCQH`9O5~~VqL+O90bp)ADkRFI4B4VmS{O5%TwM3;$QAd@7R6X
zQ+P+GD6Pe>rVN3_M?Rw;T#dij?vT%KfzKl)p{Zx(u7hdr07gU^XK8f^-6z;K2K4r)
z)^-M;)c7)O^acRev3JIFn4$IA!?LM#nukJ~&>T)vJGJ6i*rg$Q1E2ef-d#aimrS2%
zliDp=vqc~^kGJ+7+@*$|BC$ia9+PcSzES?oP4rGo##HP|
zsiW9EELd0Kb=lSLl%oerCpEkQg=hqPO#I1y!&)6xWBYI*n-xjZjW~mc7v1nmQ==Jm
z^PXFcHEOP~{r6WiH`G};ZXx@4vUBh`B?E^Dg0%RV=7pt4Y^DWs|8A4}4Xa+w%to#Lj
z%g=;E4L<&Y77hW4F*FYHQt+NMa41V8HrgPZ4=YRWo
znp#+xTqh{g!2n)da)VdPoaY
zgt;%i%{*8k?1wD1-N9cT;s}eT9X8Z^uSp$8U|~vM(nqA#{FnKu=N3++8;M*>IAij;
z0>zOpcJc?WxI=_6TQMYbnkh_
z^Y?lKz%8PaO2HMHZ|Azr^h@;hnMB34BdwZ-7xnvtjAe(KaBYT#uWtC(lHi45io7Wg3%xeqz|daO_VF5G!3un5^DGkx
zc0$Hh+70Z_n!+97)@eL4hP=SLyE>$&bejJtX$0+}+**#-f%w!6zCi5wJnFkY{HzgN
z57~WuZ1_d`gt~Vq9X%iM2tMPp4QKQ@NH+C10ES#yxSLUD)>S1;(K2Z3__)m*rJ12;
zpPfCchU(CT@NNrayww+l}-jV8TuMe4wZ--`0~Wed(|?zmRbk2@LjTHOeCDr*|W>=4s6NAi(NcHla5*
zpTAE0Owo{r<(Q24mJ8ftf0rlX0~2*J{j2H&sJ6Gs$n!S6SOD-^Bfv6i-vLN!K(Vc!okxHA!I}Q#xOH$*-}i5g1a|)V`RHS!RqD9X#1m}n`Ah+(yKC7@b-6F4pHGti!I%&Ymq8=*m3Aea?%=ko`Hcu)o7Xgb(`$7JeYm!}TcExprYg
zzk*XbcKQ#C{S~*r`3yx{ppyL3fHJn7)z3&<|DVMq!O-a1g{(f}d{cR5Pl7(Y^as{p
zYwG?#i7mhs(WhY1MJ!)I?mCw|ud4J1Bwg+-9`62N6t^pPZh;7UD7Ml@hx7su6wCO5
zmCdKZBpQPK2$95w8Xd{0C1CDuk0m!?dCv?wV
zZ^i7x5n@aSU%okW_tAt2R#R~njzSbr1ip^D47W(54M#m`*_Y=}@5`sM$~-(;#h@CA
z=TB)RrkH6h>!I3-J^uJcR9N!`z^9#vD84wR$G
zXbk5Cn+p3bRV({d90UHesc
zMGD_}Bz5HNGQM(qOgVhlS3ipEo}a9o%lqTf1!EWrSqCaw_^pne;OdUsx73q}9~dYn
z&=f3eTfU_F6rkx^`-6quhy*@|H1f>w0#h;+bCo;)x2-xhMg~LSVEZ7_)A?#PuztH;
zmy4pHj)9W9P)eS&7Wv(hm@vr=ev^QGA`qAr5=7}{
zg2=7O_>23?$&Hx>(n`(Jt;Y0*7$6yoFrQY%u%nhNA!{Ys3tK1BrS8W=zOs3Leeiy+
zadf95GbAD`A%mf2Z)Q{GnAXNYn1FUWc=Kn|b%HRsYZwt
zfKi&bA>}19ZB}LV08}yTpVBSRiDyv$1J_0WcA_k_DghICRn#2J1hPuc!WHu4;6zS?
z^`ohGK*CBmhv2G0p|t!OJq|;4lnK)J&IRtoW(duGzOvbS(4f0C$?AP-9H+QBamesk
zZ)whueMmCC{o@PEzJ>u_%wOVO%uvVmuyKBB_Q)1g8R25{IkMW0fQAR0TJRePfd_Mo
z$EA2w+Z=~S*2aFWJg9u>yMgOtu?k@ffVy6H#ivkdkr%q6cCu~8c@ahEICzk+VHbZH
zXUv^9Wx@u0pVdjo$Bth;D7^*5Pv^w?ZP}6y5~7Gnaco|*1bXrU=!p`%nMnZ&saz4(n#RU}qvd|Q-9r!EN^+Hlv5^Leg@)Gin{B9JX@3ovs(>U@%C%EP$$Z^|)C5b#B0o}Okm?vp9-VCmB+3`md
z_!HR@G3-#G-q=!FU_Fq2#AH2O)R2@yU
zH3|WOTObgEL$KiP?jGFTWkYZ_?gV#t3GVLhwsH531lYLyF^
z)sc{zhs5e|px_^bsrMy0_qtx`g^bHP9NQHexFQs>eHb=6Ud&zfJHp_`uf8=Q3Vr|L
zE3FTvnvgK|g!B;Go7_@L3wo(F%zEJ0=cUV-;jCGEB|5Hlx*+JqEj|Ka&IlYEq({zRyLT^T}pc8a0!5uraT;oJ|
zIe1DYku5$uD!f0J=d}UM#Kg
zO?wMbv`ULq1PB5umjd@o%GeD|^*D%nHX$LulI<&1;E1z6-7ET`bh#GGC)Mfpr
zR?c$bZq}+iS}O}Mp7wb}dJUGK*!Hb{QQ|>hJ2S-hYPd?i;ZTIgHS?|J;bI{|Qo}^P
z2RAXCu*o8f5CP9#J~Of~H~054Sup7rRQzD9x`w91>p!m8;vU7L_u`Mh@%0+JH*&;V
z056f?Pg~z0^4jD8D|66a2!c?rY7gLZI45bDMqQnrH0aCi6-z80D_$fW$0y-kE0GE6
zZ0U*^i^Q1^-oxe8>Ejm0#R<>e%1glXK7umQhv&_HEZAKcLf%3E0yp8OKz6B&L
zkX!Dp$7Im-I2ZN@F)zA3GBYlh8Gjc6i*~@4)W`a4qAo%N*x_U;R*#B5iu(-dxDlh?QBost*=FC^#ku}XZbr3eJ#qS;#kv$(RIRWQ41o~wY#9WyO|UH?7F*3bqmOb6360i1P%=Q~vY{t|lXGDJ}J03OIpP*fSGgG=ZF;BDOw
zn83)Qc{I$HWP-dbEL4#j|3Wp&K*N;rd_mS|KSnrIM!HHB%5ud{;mB}TuemAdF6T>0
zK355*sZvN@#I(S?A&1~cS%dQl@$Fw3F1RJM~W)64~x}9Dp4g3u$y0s)n3sxph)v(QegZB&DoNr|nvyV>RIf#h$
zb+LbSgm6&(Q6`a)rey&y^TP7@Q#7y((!a!iJHTQ&{Rw5lPW{TVJ4GLOJ%!_;;
z&!PmoKiy%6dW0C}B)={|o0_g-25E#Q6E@cQT8`?JFLY^y$h@X{bUKpQfiB31)N$#_
z;`C-n8}e->>ybkT(Pk=P#PSfSoojKRNs<)ud(6m!8=Mi;iw3{_QYx3*HF0gfa2&(p
z5Wmdwj~M@<9wCp3hT$FFzQ`{q`W_gn
z-hVS@-PlB+*b%*r<3t+359?L)k<-FwdcgP%1M=ax@Sp!FKw!yi(ez=PcPAy4yhkpwNn|IsBe
zvqC{d&Hlf2N&i*pfrk1YU6QV2iTQt5{~wh0frk1&x}^VFfP%6({x1Dr9iji#B|$n7
zGXWY(j2)hB&F7gJX^}w~U%teWPKd?=J^TWYke<9ih+>^+J2bonZG>UbU5AcIE$`6)8gw|
zZ?$o+7x>fu+Mp_sTsE#glr+wBa`S-q%`KmiqFHt0A=`^k%7+|nu`AU^-+Q9!3`{>L
zn7qSWQE5^Oea5VYX5ydf(Q0Ll!2spaF5J4_2S<=G@-8cFg8Nd
zB-;ec;TOFwpO~(#+s;$@zBX2ZU2ah5*lUm5yw)WnmO|4s=5Cq!$2;1pRW+{9zYM$W
z`%`Z{$97CCU2=^?k2^l5vdK1`W+tbcs8JqU
zH7+S3v737bdJly7s4FT#6HDucsj%x&^4Smhp?NnyasUzL8FYLC4C9x482dUyeA4W37O`4m7^7Hs
z3n~g;GkDTV_?p2~ZRo5q&U%(^nJiW7TusrEX%1BV%8soH&L1rudCcuiQa@RaV2#cd
zfxA3bQcz2hMi~u8cFL>NIo3so8KtGDDk^jJzq0jUvA6LapqB>0g-XA)l>xGuh}sn$#Nt&{#WE-V|+HPO}8Ej&Su6K@z~8N-cmsGWeCGk}_d
z36xjWQeZNOJHZFO;<%qu;oc`5#lT9hOf;_94Z)fz-;h;8VFoj6-
zFX2q&FP~U9U2NHBhn+B9Qr|y7llaE{(J8n{uY5}1DvPY>zl!aJlW)l?3@wJ>ruGeA
zbGwtyq63a>c7FC@=`Pd+Hy;mc*QOnU1HV0?Q+kNXVyV5jtdFX9^~?a|c>F7wEI%nX
zaNwkz^Y35RK-Bd{uw;cKE}BX2wy}ddsBfmfnT|-n{dA_^vzn*nFeK)@{qeY*w9nQN
z42xsUayVKQRwceI^$){_`)IrgBj2nhwo4^K;wbA_jE%wI&nlZ$7%(7Vu@EH1O^*cJ
z#qYeXkR|4B-=7~ZI^-~5leNaIOYfB`h=)TNEhJ*zndgy4Gi|32Db%u+_F6@I|+dW?RT6^+qe0To!;^U%iT&|EmcRg*cRdw#d
zNJUY$Q`S+s^B=K425S@iVDzR`#b>RCP3W2nmw3%O5MrYf{Ikv#7nVM78+7;sgnx1Z
z@EF!g5%B15V$Bg~H@fy_+EMH&=b19=cP#AY83+;u`IX{&&6vHZ-kueG&=vhY0cR);
zg}PLgONym9%gX!rpLOs`&{FKH^+~$Wb`7?9qsif22?ZM71<_7h&*}
ze2#;GYR=0>1dKH6RT4)N%%_>Gn!_LM^$}hqj^ou&j|*8?UT8WWW~F6O#|r|^vmP{M
zJwaBYbf$8$volJEsrK4}^?KA7zUGI~sdaV&f&(^JR(ahCFrQ`q>ZkvlRr4(8_x+4t
z(Lu0psP-Q9?Y(bzr$7=7^4zz>&-wZaFaW-1#P#y^o{WOP{roIESX@;&{w!$aMz!jp
z);T2_-ue2I?7d;>FJdzsN1Ue}+b;mO_WSqLm6q4pv=!8P9{S+*9^|W@$f93AZ-a=w
zU2w6F+$EI7m66xY+e3doW)@utp*5_Qmi*#s8hD$3n{4dN@4|;ZZy(j}J7sf!a_ROg
z>Md&8dl(}bO|a}en2j%R?di7edW+jLYn&Sf8fD~RL`wu0!3iO#f1_#~636--mC<-G
z@0$IR{@@|LG_X{-G{Cv;v-lT%&1;wc?eHdq-a>KhsaNi)yq2eeXxb$g=4t_!IMr|=
zh;X|4_~h;wtleEz{aU@BqGPZ|T+>YCtL2^i=)seZsfyDmH=
zi{+$;)rS3}t8{iFE|h@LRbi#nE=CV^y9Y|}f!TBBYd?*YJ!^j4i!fm3ZN8P8)9<^T
z!5Z)sK|303e!q>IVt7TW4Wgwj<5|3uIAXOMl!F(q9^Ts0gLxdlTkYHFTsrOCAJc%e
zzRl(MCF6WzfC{ZyKo-`AZGfWQ=zANY>RD*X@jIfBuhRo~fb5H}w@=jc6ZE+_dD~r{
zM{xyqI4wA`f71wpPH1mEEp5aLc)rVrnxH(mD%bEIl@3&yxT+*O@H_pu{J>qLhQk(SX}?v
z)9q^Mo$@nn+yl7`N?-3WkTeKT@cVg#`0*y|P~auz;_If?osobf&v;KH)RuYZ(zBw>a*?)=}AL^u_`Tsh>I94
z_Q)M~VI_UFK}^od`0LS;($muw$cv%
zkchDdQemd#c?<9J*x5zt+pEIhF=Rgl;6GwfkUm$)!FKk#2`cHEGY!M+iB3kX56xO-
znpC=C)*K6}NXNJ8j%Q5ZeyJa&BaXM1DfD7IMW;hhgQ@#^C;7xFLv&lG)My&|v6g>p
z9q%o*SZOr6X+-AaloM>Yop{>4Kr(#4#9bzJZ#uj7)I(*X{-g67*)4CL!`iSRkZ*`H
z%{+C$KS?4ke&JPUdnongZZ|r?<6w@@GurF%D~B(U$RQ(UCzBjqx;1l`gjw(-Iwig-
z>?aY&8m2Bdouh2}T|M3Z;bBN?T)Dh@yioK?qMf$C*=W4Yx$V;T+A*~v5TN{+6!$|G
z`dBU>RGyM-TdnbCD1x7>El~eN1v{TkzHTWzTQudk99ZEBToRj`JG^>#cxe8#^cPRI
z{@_Z=Ha}M|^7geUyhMJb-}=KNh^agu4moy5gsdXp-af2F(xeP@opK$&AEmVdG8B2<
z*Unl@mez35H@g@EruRNPnxqHPCXO0)WTCUBu2B&B+nDE@mfV}lxx>nqJjix^^+5bF
zk7kyI#zU%e;E$Ht?qKpaEd(AHeyRffr23M1S;6qQV9V;C73QSoN~JLklEO4&vF=I~
zO#?xDOP61Du#Mv?e_QguncWI9uy3_I2C;VC_PpuY>-}T+6!%N^H*qD}gdR#v#mywmd;m6GsiF-HcJuOy%b(e~7
zYDO`=1$7Ayw!Nk~Zi;y9XL5eSFhI(2B
zeQ}x{RD3)+T6qKjmKXeJ$YWj{I5=dvLG*&Tr1H+`jeFvw2|wn_80$8hPTJ^KFx$dy
z+dH0xS6?0QX8UC-8F|6G9xub9?}{M1<)PXr{l!nY&0Xp6nOLiABtiY3hncTe9tx2I
zw~MwLj%lDh&by&=?%t=?U+$h6K&1OplfQI2d}LeI8)_D}zvtHL*P{quLbz716rn7|
zbKtm6@3c>57govE29mzg+%+#*sC=)$qOaJOd_2ivSR>sy;2$n=zEz_tS0=D9Iz)pyA9O=5{fpTWary-wxi
zo?iRpl2%7R-@VY`*S%sENZrXy70}(pGEH>m)L=HuE!b@Dy4D^|uu@PBA@}xI5>J=zpFpH?|D2ueEFldW*-<6
zm=ieNU&JDv56Jvh7`DvT!hWH&K$B=j^KIy_fvq$pBm=AH2mr_Z#ZvK2S<^X)HJA9z
z-RYP4`mPe!+R1~AU~T2F;I7QT2$$1vUncXYo9jDRr;4@MyjZ~f;tszXshNw<9Y<&a
zAB{?9aTmp}6-1kX^QnK5YW-TndqDK(=kDnzBwJEeQPRA_F`#-dp_$g7SuAbynMXKQ
zRKj|EzKpQkN`!s}U>)cnlG3;!WZIGdfo7PjA<(ifE1c)T)SyiaS1-l@_)9|D)`^$S
zSC@%CWk8O$yEnuAy}uV2{d&jBob}Zyaqlspe>6!t2bvm#Y;9J<=Wb^!nw8jbW$4uH
znZc7HVke3r=v(`Ug{;6>1A0JJ!;*>1a88l5hKM?0XK-?;M8N_MYs`&dT=iMpDrHr2
zx3y6tg!%KTcFdNi3ht#FMJFC2PwkQEaiMH_RnkcWLqEu28BXm>JLcZ^qn4Pf
zDfUIMy{8{g87E4A{B2lo`p_-=n$=Q+F_wdIH+4hRjaW~2fu$5qNa5!nk1LR^z|k(U
zxp{NuxRYLn2#*Drjs#E-t(QQVH&+s-U`!5!m(N4%<>P)BU`}-%13>gX=BcKZO0#5h
z?VF}3Xgq8R{WF&^jcYYz*!%v`@b#~!SNxK92hMUQZd@jwn?5dE%nRs-F;5PTus)?K
zX~lVX-!>%cv!H9DI~!Kk>q8Va1$hPi9I9_v%tn51&}d~N1t_u<2JRAK{6{q!wz39}
zeXH4Cab9|i{5#Z-ZTcR4V{aZWn+_9!PkNR#hHI_lI%FryOHK~ptXq)YPIz-9gP+0m;?aY7`A^iR%&kZ{;Jf$s|DaV
zqz_D^(!kqz-O{%ubzBZ6=y@;|E^CW8k(!h(4q*hRPu64N)$;soMw_#Er{E^;`8oDxXHYeAT_f+UyImkgI|M)=F~c6Uc7!QCGI?3++UDzh$Q?7Ark)
zh0NHbU!=f+nk~ted`>+rsB~{g+Z1F$WQF#b)CwnW#sT9E=#9fPb)k31JU6Quv&HIw
zd*YjcwNVchO$IpLP#c!+go_1>RNC?lv1450qDB2cH$-r--Uh~*p@mV_xqI^tFGKwe
zQ|FSVE*~Z1IT4+%99$RAx@pzUn2g1(^r)Wr;u1Y;zS3a~Pc8)RZ
z=y+AP^nKThMyJu<`-lR60D5OhkgUEAP1X^0Tllq-f7NPOk5$Lyx9i*sY9Pm#D6kJY
zcFVggIL&)f>%8UF(F}fzY0b+MonOzh*-g-ItXs8*_Hu6bbkrO%yl@yEdal=&KGfhT
zJS``jyN2$yGr2@0&#nzv`l}bscU(K_ieXkvU8@>LnCE5l>aukk-M6KkTiHj#-7zTa
z`EkloZ89F8*mu0;WMv($*8o4wcVJpCU$qdf?^a=GctXeGJ8GBYnirXKLT=DfEG^Fb
zq`%@wqM{ia?C6>#9c0ew#!=As)$0FlnZ;M+{`)NhjlEeBui0Y3wmuc!>}u-he%QNE
z2B657=43L&zUc8XBM1m>D*d#ObKY+L?qo+&Xk-s<4C~q_cmSg?@nK1c%PUPeqtk=>1cuclC!A@^OJ(=UQ6mcGPO%%xtW(Tb=$WHb1|^B5
z#))Uj?o(;%iQYLq-klP+o&4;FG=Ikw}4R1XJ^qzTSM(dDq^|UAcV#v&P=O
z-S;xLUw*+L;PYPFhT@T!vSx&GOt%YT;9{-cK`HNn%!%ZNG0dA1@${a4*Ou$@qOUwC
zWIsk8s(};7Qj_xClP!97uV_ZZk4PNVKwe~H(CU1SUO9NlVx4SVGf!u2nqs2@q+7dA
zDRO356sM!QhYk-OBKSN2Fa83DcKtqyJ81LvqTTDF
zp|S;m1$@Avfd@s?&knWRo@=&Fn}~BgX$Nu#rbOH;Y#X*&{pY(DMd@05X3*Xq5C25!
z(Loa{-j=nkX73_S{Em*3*}(_LYtd{5o8AMa6L$`)@8LQnUHBjP)LAeqt5YVq+0>78
z;8z1_%JbB*|Hd8?U1yp(#2%wFvc0DaN6t+2SBdR1D9yqdg^7ahnuWh2n??5PBg=eu
z+3V!D9&|wy(d$2~hw1QH982qmiLK@;_Ue*aXC95j$o&>I7+zOJ>qGe9j5KD-K@@Ay6EI9(G*9hvO;VOTV`@%^p?YiJJlK
zxB|BwQIo9at+l{;E&TK-cQ~C0M^qfYd$0Xp*9x}hod<^fh_x^InqhR~F$Op#@*b=>
z9g;bnwZOhs{0vEQ;zQd*3{BxuCxd78Ru2S=U+0~7zpf8J#I|oo5%3NNxv9z4I-9ah
zEZWb%qK0MKA_=tc*?m6qomko5qY}R-zjEq7B90LC3>_jkg6m;{{TQzzHEf8R;mBaE
zN)erPu19zrzpQ(A2>OJ5H@>|OQ@$#pDq*xPiN_ah9y77=g0ge(S=;N^`;B=%WGvt7
z&nS+K;^H%6$=2H_^X;nb#2-gFanH8zQVJTo{Zn7>!Rb42dQ%~_R>`M2WLQ12-3Fv
zp^cJBKC1NVEIo^u_j7KCX-l!mH1#~2Sq^%R>QqxbaGO-$RLaw8@z
z_Kj1YZ*ybCcZA?`T~_F#QCJnU=1ZfvUFbM=S6R*y8TpkBb=J*~6UDI^vT?F0W87*9aK|Tt38}F{8
zUf1#Pc2)}go{z>clTmeg?W%*S8jOdj7NlD)=kk+odTd)S$Wur@C*;rRv|VGms%D8X
z1y5o9eYQW^zh{^_Af(F84}(@N!EhGyx1{P&r=Y0`gGdwY(PWDF%7|uT-BUQB=#fVp
z3(m|nbIL)I_>ufQ>)%|>8yS3cntMtV_=#Wijzu}v#+^5IAi`IEd`YjZq4vW+z%UU7
zrWUGY8$=sO!ilKH}{1;t5BYQ`*yTN#2<$lS_^u{4Jc9+3qtyS7ft7
zS^Yts;4GDg+0nZpl=7KOaU0*(+DV|mm}l7DM#xW4=1DTV$6gOHTS?9nKif{Q2b4cn&&xN3%|
zTP3i6xZRH~Xy|nP&VLjXQv3=|Dl_5rkG3!ZD!-my>Vy{Obk{!KA#<*L`n|t|#wmFj
z)+&IFpCmYrOHjJcDW}Npd)I)KK5lzOJ34;t-r(#j_m@=?|DTj@jZ+g48b`vX{leaW
z-_$-^&VXF;DQfS|7AsRkXiA*ai14%H2sKR
zJQ~ZT5m|IzVogF(UjDo$q~YmHt4AHrFKL`MmIbSUcWS#^^M$gGV3H)Md#6QV0Ev0qJiJqhj~XL4>1l~xeOduDz{Nio
zw92#4aTTYNfiC!NnptPxw-f_V|GQ!_bX-F&6aCQlY~O^=Cu^&kEI1%nA5C%nBY}B5
zRm2Xn;RxQGf2Of(RI*+8x^fo8=PY}DaG1GVW3M$YbLb~$tBz~wOi>*iXUP^6R5W2%
zNXFdOK%(iQP@%D19%EDHZ#c
zD)gpBhE?goA(d_!Wg`Cdc)p8-!l<9kPm#|}^!mdx!tQhquwkYy90WihxKF?=0`RE`i1pwH5*P~(wwHXqbu(2u{CzA69QnNA`>Pb}!k0(G8VayQG4~i$m;_
zo%t<1nffP_k#a>`+g|CwO_Rb%!?E|TeoEfptRS*Pl(_2O)t+O~=I#8sD3SiX*d4oE
z2nAt3eg*l=Z7HfYf+KQS*dxj?Tu;;Z_>;ue-G~8wdf3|&Ic@ih27yGh?1!M1=g1mND4L|`QFC~oytm5Ii}fF9;31_
zHuABet_r!@fon&Hmwp-X@@(Jb^0K}vNArzQrt_@@Na{4jF%pI4W_|DU<=#AbAA#B3
zkUqA|cu=LPwl8p_WK@)I0sLwzq}34*@Sw|M)B%sN;?1iWTaLN^_?2v#ld#>rVbKL-
z+{9U?skK?wr!-CWcG`^QGSTcS%4oSZuDg?bOgUaTggm$13@Ym5RsX8FL^4I!%nmYz
zJxv_{7UN|*OMlnrI?B1<1J2CT$1YPSl(UA8?H?#DeUv|>HZ=EduwXQfXA8!PaL!^{
zq4^_i$QFn7sVP{Zp8m>sPJ?3rcgt7yy8oW|YDVmIq$Jy%mu^NsFY4dg0_rb`4x&dU
z5C)*&k2_^mAn7Omx2!H;+oMY6m-jPp^V*7^V`3aoThni{!v6I3bWf0Z&bw|q>Nl`Z
z=#FMiH2tIn_Fg~I22VfeZ7FrcAwr$-!=S3;k7H-9?pE>q59;@I?zvUzZ&k
zaiAVIPG;6`Lgo^MTzRZcyzn*Ffy#-6k(A*q*`mPvh(D_RF{^rW~wDaK>c;0j+fL7Cf8gOV|*wf=ru*J6f(hyG#PB
z|IaTD*65oUSHm6%&#Pm{tLN1Qr{+YsPOAL>4y$<-Q1mJu%Ch$r*Z}a@2^^iH7}<+*
zlHdr<%_mgmC-Q8>@mo(PAphRU#qJ#*0A41O-y8bKzMo~k4vI`PIBg^^xnY&usZs&S
z6s-(imjRY361{&okj!_IW>?IMsLUBTd6P=l~HR(j(%&
z82gG;1yzexo0M)42a6t^nRyXK?0*k4X-Id#bKm)(TL`%giyK5HiKkjc6@M>PBvJxv
zE*A^RWb@EP%&}7OnmJLMhl7f@tC1@1K9NY)J852+D_m^u{4h&0+2eIr9_3H5s@8A}
zOH00^&g{qE{@5?jp7DOt)!cg(tX^PRsn+W4Y02v-iJ_M>Hia~z
z^VS(rn(^)dAhG7S;_H3WU`g+ew;jbC50Pg8g1h}&AM|q?gB11(1>Ox)j^qNa&Q8H-
zAdz`>GBJ74Zb7U5^9caZ9~|}m9JZFBg-Sh!MsL*brS;~1ml#R(-U9q=k3KY2CQDqM
zjQ8x`hzrHO?&4@|{t+A%5S5!9wPea^-111A`8K{7ep*xbt+i@|KbAeW=ioW>dXVv)
z6@cDIEoAZq`@^)qilCy9s`8ejKe93YkPn$gJgglHR|_CBW?l0)r?Pw$C7k_983U6)
zgGf(}6i`g2w_@_u%DAZ4bC>%~zL(!Y5$5SmZ9QX~QE+_guh6FM_SBys5?;Rf3}_LorZ5kjQbJ@ZkdACqK1D&2MUO}v-g
zizLcLW$log5x34<%yRH)CQK+OA79Z3?@;fdd)QD7UPZz=thh@7KYz$`FR8ug0h`H*
zZnNyxut17Vz7XM;kCJC`z&y&(&t;_z`lue^JRcR9+Ku3VDi14X#!mfj1ud77bL;;2
z`gC;LLnN9W&32jA3Inc40+BY|=IGu}q{Pb{D??yt*^#dw{20cxZS_z>twBQf7{a+p
zo$Su~$6hyx-KNvz&H=7qOEVDr4EP(}hupAMSm#a3Eir}?os`74`1keZ;K5=b@?>^k
z#H5keL{CPkZF-iSD;ZTW_*2oQ4f?Tr3Z}~FVXVL_vo7T3UW2elUd#RVv?l*^aHB3K
zO(59e=#s8HVorsigsrI3&QdL!sucq>ZOu2=*#FqSA|A$}(^O?;Lo4VBWWfl8_=IFStfKh*BZ`
zx9dqf9rJW#g-olnz%8P6V$NB2YCD#`K_hpg$cpor#!7r+lgNi=@caWPr>Wqv^d2&Z
z*F!kzwAIlLeDz(K$@C5A!il_VB$-|za;8@NOmxrmxzU4$W1H-S8goCXXwx_64Pk^a>xx%Pgurnj-KH<{S6-3F3Rw~
zuyDRE)_<9BQvgkE5#H2A`1b7P6e_3XQXNu~I%N$*d9c>Ng4ML!Y+
zAB8W?SKaozgVxkK&*tFMeOsRVHa2ZaR!og(;$hB>=|0Esd!lu>=M3+UI$h`q+**~{
zY4SBrQ9s(fR{J^|T(4h4kR9oJcMQnHllfSeEJnqjqiLEw6p1*dS(86cX
zG9QWNyBhB~oPktoN%#)+uP1#!Bs+HPI1#^wMV1azy<@+1E3RyU-w!x+T6l|GYSt;+
z`o+{GcKhOB4BC#yIQfYJyv|)Pbh>B|6qWvs%FH3DF^)w>YlJuSgRojID*}+Ant`_X
zimmsoTb!(%AkVB`vj@m{8L@FSK^(Jnz|zwo4j_LIy5D344DY)Yjt@-Cm(ZJ3p~oSwdPd#xDW$r&QN-w{cb>?tXZS}?Op33Y0K%Xu@=ZcDb&hT3=5OL#UDdD
z9!5lAuvFkL_%z>ja41-V-d&~B@chJ&-%amMqMrrq?(T0<-{#5WxmMS+f4|B*SY3N{
z6(56}8AAf6tU=zbykf_@ypBYhcC#Z09F?qd7JSnwU0!1gUtbs8*cg2diCB4
+
+# Knotchy
+
+Open suspicious links in a throwaway browser that lives in your Mac's notch.
+
+> **Status:** 0.1.0, the first release. It works, but it's young. If something breaks, please open an issue.
+
+Some links you'd rather not open. A shortened link in a text from a number you don't know. An "invoice" from a
+company you've never dealt with. Knotchy opens them somewhere else: a small Linux virtual machine that exists for
+that one link. The page appears in a panel under the notch, you look at it, and when you're done the whole machine
+is deleted, along with anything the page did inside it.
+
+The VM can reach the internet. It can't reach your Mac or anything else on your network.
+
+## Requirements
+
+- A Mac with Apple silicon
+- macOS 26 or later
+- About 3 GB of free space for the first setup
+- An administrator password, once, for Apple's installer
+
+## Install
+
+1. Download `Knotchy-0.1.0.dmg` from [Releases](https://github.com/aculix/knotchy/releases/latest). It's signed
+ and notarized, so macOS opens it without warnings.
+2. Open the disk image and drag Knotchy to Applications.
+3. Open Knotchy. A knot appears in the menu bar and the setup window opens.
+4. Click **Set Up**, and Knotchy works through the list:
+ - It checks that your Mac can run virtual machines and has enough space.
+ - It downloads Apple's [`container`](https://github.com/apple/container) runtime (version 1.4.1, 118 MB),
+ checks it against the SHA-256 built into Knotchy, and opens it in Apple's Installer. Click through Installer
+ and enter your password there. Knotchy never asks for administrator rights itself.
+ - It starts the runtime, which downloads a Linux kernel the first time.
+ - It builds the browser VM image on your Mac. That takes about 3 minutes and downloads about 225 MB.
+5. When every row has a green tick, click **Done**.
+
+If `container` 1.4 or newer is already installed, Knotchy uses it and goes straight to the build. You can close the
+window at any point and setup carries on; **Set Up Knotchy…** in the menu bar brings it back.
+
+### The browser extension
+
+Safari and Mail need nothing extra. Chrome, Edge, Brave and Arc do, because they pass the Services menu a link's
+text instead of its address. Until the extension is on the Chrome Web Store, install it by hand:
+
+1. Download `open-in-knotchy-1.0.0.zip` from [Releases](https://github.com/aculix/knotchy/releases/latest) and unzip
+ it somewhere you'll keep it. (The same files are in [`extensions/chrome`](extensions/chrome).)
+2. Open `chrome://extensions` and turn on **Developer mode** in the top-right corner.
+3. Click **Load unpacked** and choose the unzipped folder.
+4. Right-click any link and choose **Open in Knotchy**. The first time, the browser asks whether to open Knotchy.
+ Allow it.
+
+The extension has one permission, adding that menu item, and only passes `http` and `https` links to the app.
+It won't update itself, and deleting the folder removes it from the browser.
+
+## Opening links
+
+- In Safari, Mail and most other apps, right-click a link and choose **Services → Open in Knotchy**. It also works
+ on selected text that contains a link.
+- In Chrome and other Chromium browsers, right-click a link and choose **Open in Knotchy**.
+- Anywhere else, copy the link and press **⌃⌥⌘L**, or choose **Open Copied Link** from the menu bar.
+
+Only web links open. Anything else gets a brief "No web link found" in the notch.
+
+## Using the panel
+
+The page opens in a panel that drops down from the notch. Scroll, click and type as you would in any browser. The
+toolbar has back, forward and reload, an address field, and a button that makes the panel bigger.
+
+Click anywhere outside the panel and it folds back into the notch, with a countdown beside it. Hover over the notch
+to bring the page back. Leave it folded and the VM is destroyed when the countdown runs out, after 5 minutes unless
+you change it. **Destroy** in the toolbar, or ⌘W, ends it right away.
+
+Knotchy shows one page at a time. Opening a new link replaces the current VM with a fresh one.
+
+## Settings
+
+The knot in the menu bar opens a menu with the open page (show it or destroy it), **Open Copied Link**, the
+connection picker and **Rebuild VM**. **Settings…** has three sections.
+
+General sets how long a folded page lives, whether pages open in the small or large panel, the ⌃⌥⌘L shortcut, and
+whether Knotchy opens at login.
+
+Network sends pages through an HTTP or SOCKS5 proxy, with a username and password if it needs them, or through a
+WireGuard VPN. For a VPN, import the `.conf` files or the `.zip` your provider gives you; Mullvad, Proton VPN and IVPN
+all offer them. If the proxy or VPN is down, pages don't load. They never fall back to your normal connection.
+Proxies on your Mac or your local network are refused, because a page could reach your network through them.
+Passwords and VPN keys are kept in your keychain.
+
+VM shows the runtime version and when the image was built, and has **Rebuild Now**. Rebuilding picks up WebKit
+security fixes, and Knotchy suggests it once the image is two weeks old.
+
+## How it works
+
+There are two programs: the Mac app, and a small agent inside each VM.
+
+When a link comes in, the app checks that it's `http` or `https` and asks Apple's `container` tool to start a new VM
+from the `local/knotchy-vm` image. That's Debian with WPE WebKit and GStreamer, given 4 CPU cores and 2 GB of memory.
+Each VM gets a random name (`knotchy-` and 8 hex digits) and is deleted when it stops.
+
+The VM's first process is [`vm/knotchy-init`](vm/knotchy-init), a shell script. Before anything else runs, it sets up
+an nftables firewall. On a direct connection the firewall allows the public internet and blocks private and
+link-local addresses, carrier-grade NAT, IPv6, and the networks your Mac is on. With a proxy, the proxy is the only
+thing the VM can reach. With WireGuard, it's the VPN server and the tunnel. If the firewall can't be put in place,
+the VM stops instead of starting without it. Init then drops all its capabilities and starts the agent as an
+unprivileged user, so nothing the browser runs can change the firewall.
+
+The agent, [`vm/knotchy-agent.c`](vm/knotchy-agent.c), loads the page in WPE WebKit at 1024 × 640, encodes what it
+draws as H.264 with x264, and writes the frames to a Unix socket. `container` exposes that socket to the Mac as a
+file, so there's no network connection between the two. The app decodes the video with VideoToolbox and draws it
+in the panel. Clicks, scrolls, keys and address changes go back over the same socket. The message format is at the
+top of the agent's source.
+
+Destroying a page stops and deletes its VM. If Knotchy quits with a VM running, it deletes it on the way out, and
+any VM left behind by a crash is deleted at the next launch.
+
+The image is built on your Mac from the [`vm`](vm) folder that ships inside the app, so what runs in the VM is what's
+in this repository. Proxy passwords and VPN keys reach the VM through a shared folder that init reads, deletes and
+unmounts before the browser starts. They're never passed as environment variables, which `container` saves to disk.
+
+### What's where
+
+| Path | Contents |
+|---|---|
+| `Sources/Knotchy` | The Mac app: menu bar, notch panel, setup window and Settings |
+| `Sources/KnotchyCore` | The session state machine, the VM backend, the stream protocol and decoder, setup logic |
+| `Sources/knotchyctl` | A command-line tool that opens a link in a VM and saves a screenshot, for testing without the UI |
+| `Tests` | Unit tests for KnotchyCore; none of them need a VM |
+| `vm` | The VM image: `Containerfile`, `knotchy-init` and `knotchy-agent.c` |
+| `extensions/chrome` | The Open in Knotchy extension |
+| `scripts` | Build, release, test and icon scripts |
+
+## Known limitations
+
+- The "Isolated" badge means isolated, not safe. A page can still try to trick you inside the VM.
+- There's no sound. Clipboard, downloads, popups and links that open a new window stay inside the VM or don't work.
+- The picture is streamed at 1×, so it's slightly soft on Retina screens.
+- Proxy and VPN routes are IPv4 only, a WireGuard config can have only one peer, and OpenVPN isn't supported.
+- The firewall runs in the VM's own kernel, so a kernel exploit inside the VM could get around it.
+- A site can still reach your router through your network's public address (hairpin NAT), and routes that a VPN
+ on your Mac adds for public addresses aren't blocked. Knotchy reads your Mac's networks when each page starts.
+- Unprivileged user namespaces are on in the VM, because WebKit's sandbox needs them.
+
+## Building from source
+
+You need a Mac with Apple silicon, macOS 26 or later, Xcode 26 or later, and Apple's `container` installed.
+
+```bash
+git clone https://github.com/aculix/knotchy.git
+cd knotchy
+scripts/bundle-app.sh
+```
+
+`bundle-app.sh` builds Knotchy.app and installs it in `~/Applications`. It signs with your Developer ID certificate
+if you have one and ad hoc if you don't, which is fine for your own Mac. The app builds its VM image the first time
+it opens, the same as a downloaded copy.
+
+The other scripts:
+
+- `swift test` runs the unit tests.
+- `scripts/build-vm.sh` builds the VM image from the command line.
+- `scripts/test-egress.sh` starts a VM and checks what it can and can't reach. Run it after any change in `vm`.
+- `scripts/test-routes.sh` checks the proxy and VPN routes, kill switch included. Build its test server first with
+ `container build --dns 1.1.1.1 -t local/knotchy-route-server scripts/route-server`.
+- `scripts/release.sh` builds a signed, notarized disk image. It needs a Developer ID certificate and notarization
+ credentials saved with `xcrun notarytool store-credentials`.
+- `scripts/package-extension.sh` zips the browser extension.
+- `scripts/make-icons.sh` redraws every icon from the knot in `scripts/icons/knot.py`.
+
+A VM image you build yourself is exactly as trustworthy as the checkout you built it from.
+
+## Uninstalling
+
+Quit Knotchy and move it to the Trash. Then remove its VM image in Terminal:
+
+```bash
+container image rm local/knotchy-vm
+```
+
+If nothing else on your Mac uses Apple's `container`, you can remove it as well. This deletes all of its data:
+
+```bash
+/usr/local/bin/uninstall-container.sh -d
+```
+
+## Security
+
+To report a security problem, please use GitHub's private reporting. [SECURITY.md](SECURITY.md) has the details.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000..2bab937
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,25 @@
+# Security
+
+Knotchy exists to keep untrusted pages away from your Mac, so a security bug here is the worst kind of bug. If you
+find one, thank you.
+
+## Reporting a vulnerability
+
+Please report it privately: on this repository's **Security** tab, choose **Report a vulnerability**. Don't open a
+public issue for it.
+
+Tell us what you found, how to reproduce it, and which versions of Knotchy and macOS you used. We'll reply within a
+few days, and we'll have a fix or a plan before anything is made public.
+
+## What counts
+
+- A page in the VM reaching your Mac, your local network, or anything else the firewall should block
+- Getting around a proxy or VPN route's kill switch
+- Knotchy running code on the Mac, or installing anything other than Apple's pinned `container` package
+- Proxy passwords or VPN keys leaking from the keychain or from the VM's secrets share
+
+A page taking over the browser inside the VM is expected; that's what the VM is for. Escaping the VM is what counts.
+
+## Supported versions
+
+Only the latest release gets fixes.
diff --git a/Sources/Knotchy/AppDelegate.swift b/Sources/Knotchy/AppDelegate.swift
new file mode 100644
index 0000000..5ad9081
--- /dev/null
+++ b/Sources/Knotchy/AppDelegate.swift
@@ -0,0 +1,249 @@
+import AppKit
+import KnotchyCore
+
+@MainActor
+final class AppDelegate: NSObject, NSApplicationDelegate {
+ let backend: ContainerCLIBackend
+ let controller: SessionController
+ let services: ServicesProvider
+ let settings = AppSettings()
+ let vmStatus: VMStatus
+ let unsupported: Unsupported?
+ let setupFlow: SetupFlow
+ var isSupportedMac: Bool { unsupported == nil }
+ private(set) lazy var setupWindow = SetupWindowController(
+ unsupported.map(SetupWindowController.Content.unsupported) ?? .setup(setupFlow))
+ private(set) lazy var settingsWindow = SettingsWindowController(app: self)
+ private var notch: NotchWindowController?
+ private var copiedLinkHotKey: GlobalHotKey?
+ private var wantsCopiedLinkHotKey = false
+ private var signalSources: [DispatchSourceSignal] = []
+ private var quitting = false
+
+ override init() {
+ unsupported = Self.detectUnsupported()
+ let vmSources = Bundle.main.resourceURL?.appendingPathComponent("vm")
+ let hasSources = vmSources.map { FileManager.default.fileExists(atPath: $0.appendingPathComponent("Containerfile").path) } ?? false
+ backend = ContainerCLIBackend(vmSources: hasSources ? vmSources : nil)
+ controller = SessionController(
+ backend: backend,
+ connector: StreamClient(renderSize: SessionController.renderSize),
+ diskSpace: SystemDiskSpace(),
+ hostNetworks: { HostNetworks.current() },
+ requestQuit: { NSApp.terminate(nil) }
+ )
+ services = ServicesProvider(controller: controller)
+ vmStatus = VMStatus(backend: backend, controller: controller)
+ setupFlow = SetupFlow(host: SystemHost(), installer: SystemRuntimeInstaller(), driver: controller)
+ super.init()
+ controller.quitsWhenIdle = false
+ controller.showSetup = { [weak self] in self?.setupWindow.show() }
+ if isSupportedMac {
+ settings.onChange = { [weak self] in self?.applySettings() }
+ applySettings()
+ } else {
+ services.redirect = { [weak self] in self?.setupWindow.show() }
+ }
+ }
+
+ private static func detectUnsupported() -> Unsupported? {
+ #if DEBUG
+ if ProcessInfo.processInfo.environment["KNOTCHY_PRETEND"] == "no-virtualization" { return .noVirtualization }
+ #endif
+ return SystemHost.unsupported()
+ }
+
+ private func applySettings() {
+ settings.apply(to: controller)
+ backend.setNetworkRoute(settings.route)
+ guard settings.copiedLinkShortcut != wantsCopiedLinkHotKey else { return }
+ wantsCopiedLinkHotKey = settings.copiedLinkShortcut
+ if wantsCopiedLinkHotKey {
+ copiedLinkHotKey = GlobalHotKey.openCopiedLink { [services] in services.openCopiedLink() }
+ if copiedLinkHotKey == nil { ServicesLog.write("\(GlobalHotKey.openCopiedLinkLabel) is taken by another app") }
+ } else {
+ copiedLinkHotKey = nil
+ }
+ }
+
+ func applicationWillFinishLaunching(_ notification: Notification) {
+ NSApp.setActivationPolicy(.accessory)
+ // Registered before launch finishes, so a Services request that launched the app isn't lost.
+ NSApp.servicesProvider = services
+ NSUpdateDynamicServices()
+ }
+
+ func applicationDidFinishLaunching(_ notification: Notification) {
+ #if DEBUG
+ if let directory = DebugTour.argument(after: "--setup-snapshot") {
+ Task {
+ await DebugTour.snapshotSetup(app: self, to: URL(fileURLWithPath: directory))
+ NSApp.terminate(nil)
+ }
+ return
+ }
+ #endif
+ guard isSupportedMac else { return setupWindow.show() }
+ notch = NotchWindowController(controller: controller, routeLabel: { [backend] in backend.lastStartedRoute.label })
+ vmStatus.refresh()
+
+ // Route Ctrl-C, kill and logout through applicationShouldTerminate so the VMs get destroyed.
+ for sig in [SIGINT, SIGTERM, SIGHUP] {
+ signal(sig, SIG_IGN)
+ let source = DispatchSource.makeSignalSource(signal: sig, queue: .main)
+ source.setEventHandler { NSApp.terminate(nil) }
+ source.resume()
+ signalSources.append(source)
+ }
+
+ #if DEBUG
+ let all = CommandLine.arguments
+ if let index = all.firstIndex(of: "--tour"), index + 2 < all.count, let url = URL(string: all[index + 2]),
+ let notch {
+ let directory = URL(fileURLWithPath: all[index + 1])
+ Task { await DebugTour.run(controller: controller, snapshot: { notch.snapshot(to: directory, name: $0) }, url: url) }
+ return
+ }
+ if all.contains("--settings-timing") {
+ Task {
+ await DebugTour.timeNetworkSwitching(app: self)
+ NSApp.terminate(nil)
+ }
+ return
+ }
+ if let index = all.firstIndex(of: "--settings-snapshot"), index + 1 < all.count {
+ let directory = URL(fileURLWithPath: all[index + 1])
+ Task {
+ await DebugTour.snapshotSettings(app: self, to: directory)
+ NSApp.terminate(nil)
+ }
+ return
+ }
+ if let index = all.firstIndex(of: "--tour-timing"), index + 1 < all.count, let url = URL(string: all[index + 1]) {
+ Task { await DebugTour.run(controller: controller, snapshot: nil, url: url) }
+ return
+ }
+ #endif
+
+ Task { await openSetupIfNeeded() }
+ let arguments = CommandLine.arguments.dropFirst().filter { !$0.hasPrefix("-") }
+ if let first = arguments.first { controller.open(text: first) }
+ }
+
+ private func openSetupIfNeeded() async {
+ let runtime = await backend.runtimeStatus()
+ let completed = UserDefaults.standard.bool(forKey: SetupLaunchRule.completedKey)
+ if SetupLaunchRule.shouldOpen(hostSupported: true, setupCompleted: completed, runtime: runtime) {
+ setupWindow.show()
+ }
+ }
+
+ // From the browser extensions: Chrome's Services menu never sees a link's address.
+ func application(_ application: NSApplication, open urls: [URL]) {
+ guard isSupportedMac else { return setupWindow.show() }
+ for url in urls where url.scheme == "knotchy" && url.host() == "open" {
+ let link = URLComponents(url: url, resolvingAgainstBaseURL: false)?
+ .queryItems?.first { $0.name == "url" }?.value
+ ServicesLog.write("knotchy:// request, link \(link == nil ? "missing" : "present")")
+ if let link, let target = URL(string: link) {
+ controller.open(target)
+ } else {
+ controller.open(text: "")
+ }
+ }
+ }
+
+ func applicationShouldTerminate(_ sender: NSApplication) -> NSApplication.TerminateReply {
+ guard !quitting else { return .terminateNow }
+ quitting = true
+ setupFlow.cancel()
+ if setupFlow.isDownloading { SystemRuntimeInstaller.removeLeftovers() }
+ // Not Now mid-build closes the window before the build ends.
+ if setupFlow.allRequiredDone { UserDefaults.standard.set(true, forKey: SetupLaunchRule.completedKey) }
+ // Synchronous on purpose: terminate: often runs inside a non-reentrant main-queue block; awaiting here deadlocked.
+ notch?.hide()
+ CATransaction.flush()
+ CLIRunner.stopBuilds()
+ controller.closeBackendChain()
+ let ids = Array(controller.liveIDs.snapshot)
+ if !ids.isEmpty { backend.destroyBlocking(ids: ids, deadline: .seconds(20)) }
+ return .terminateNow
+ }
+}
+
+@MainActor
+final class ServicesProvider: NSObject {
+ private let controller: SessionController
+ /// In minimal mode, requests only bring the explanation window forward, so the calling app gets a normal reply.
+ var redirect: (@MainActor () -> Void)?
+
+ init(controller: SessionController) {
+ self.controller = controller
+ }
+
+ @objc func openLink(_ pasteboard: NSPasteboard, userData: String?, error: AutoreleasingUnsafeMutablePointer