@hasna/recordings 0.4.0 → 0.5.0

package/src/native/Recordings/RecordingsTests/RecordingStartTimingTests.swift

@@ -61,9 +61,24 @@ private final class FakePCMRecorder: PCMRecordingSource, @unchecked Sendable {
 @MainActor
 private func makeStartableEngine(
     recorder: FakePCMRecorder,
+    intentDetectionEnabled: Bool = false,
     selectionCapture: @escaping @Sendable (pid_t) -> AccessibilitySelectionToken? = { _ in nil }
 ) -> RecordingEngine {
-    let engine = RecordingEngine(homePath: makeIsolatedTestHome("start-timing-tests"))
+    let engine = RecordingEngine(homePath: makeIsolatedTestHome("start-timing-tests"), installsGlobalHandlers: false)
+    // The legacy engine persists this setting. Keep the explicit mode on this instance,
+    // restoring the exact application-domain value before another MainActor test can run.
+    // This factory and the restoration are synchronous: there is no suspension in between.
+    let defaults = UserDefaults.standard
+    let domain = Bundle.main.bundleIdentifier ?? ProcessInfo.processInfo.processName
+    let priorIntent = defaults.persistentDomain(forName: domain)?["intentDetectionEnabled"]
+    defer {
+        if let priorIntent {
+            defaults.set(priorIntent, forKey: "intentDetectionEnabled")
+        } else {
+            defaults.removeObject(forKey: "intentDetectionEnabled")
+        }
+    }
+    engine.intentDetectionEnabled = intentDetectionEnabled
     engine.openAIAPIKeyProvider = { "" }
     engine.microphoneAuthorization = { .authorized }
     engine.accessibilityTrustCheck = { true }
@@ -82,6 +97,27 @@ private func makeStartableEngine(
     return engine
 }
 
+/// An entered callback is essential evidence: with intent detection disabled the engine
+/// correctly skips selection capture, so merely installing a blocked closure proves nothing.
+private final class BlockedSelectionCapture: @unchecked Sendable {
+    private let lock = NSLock()
+    private let gate = DispatchSemaphore(value: 0)
+    private var capturedPIDs: [pid_t] = []
+    private var returned = false
+
+    var pids: [pid_t] { lock.withLock { capturedPIDs } }
+    var isPending: Bool { lock.withLock { !capturedPIDs.isEmpty && !returned } }
+
+    func capture(_ pid: pid_t) -> AccessibilitySelectionToken? {
+        lock.withLock { capturedPIDs.append(pid) }
+        gate.wait()
+        lock.withLock { returned = true }
+        return AccessibilitySelectionToken.unsafeTestToken(selectedText: "frozen words")
+    }
+
+    func release() { gate.signal() }
+}
+
 @MainActor
 private func waitUntil(
     timeout: TimeInterval = 5,
@@ -138,14 +174,12 @@ private func expectEmptyAttemptDisclosed(
 @MainActor
 struct RecordingStartTimingTests {
     @Test("the recorder starts on keydown even while the AX selection capture is blocked")
-    func recorderStartDoesNotWaitOnSelectionCapture() async {
-        let captureGate = DispatchSemaphore(value: 0)
+    func recorderStartDoesNotWaitOnSelectionCapture() async throws {
+        let capture = BlockedSelectionCapture()
+        defer { capture.release() }
         let recorder = FakePCMRecorder()
-        let engine = makeStartableEngine(recorder: recorder) { _ in
-            // Simulates a beachballing target app: the capture IPC hangs far longer than
-            // any acceptable start budget.
-            captureGate.wait()
-            return nil
+        let engine = makeStartableEngine(recorder: recorder, intentDetectionEnabled: true) { pid in
+            capture.capture(pid)
         }
 
         // `startRecording` runs synchronously on the MainActor through recorder start.
@@ -157,25 +191,29 @@ struct RecordingStartTimingTests {
         #expect(engine.isWarmingUpCapture, "start() returning is warm-up, not captured audio")
         #expect(engine.captureIsActive)
         #expect(engine.flowPhase == .listening)
+        try #require(await waitUntil { capture.isPending })
+        #expect(capture.pids == [99_999])
 
         #expect(await confirmCapture(engine, recorder))
         #expect(!engine.isWarmingUpCapture)
 
-        captureGate.signal()
+        capture.release()
         engine.cancelRecording()
         #expect(engine.flowPhase == .idle)
     }
 
     @Test("stopping waits for the generation-bound start context instead of dropping the frozen target")
-    func stopAwaitsFrozenStartContext() async {
-        let captureGate = DispatchSemaphore(value: 0)
+    func stopAwaitsFrozenStartContext() async throws {
+        let capture = BlockedSelectionCapture()
+        defer { capture.release() }
         let recorder = FakePCMRecorder()
-        let engine = makeStartableEngine(recorder: recorder) { _ in
-            captureGate.wait()
-            return AccessibilitySelectionToken.unsafeTestToken(selectedText: "frozen words")
+        let engine = makeStartableEngine(recorder: recorder, intentDetectionEnabled: true) { pid in
+            capture.capture(pid)
         }
 
         engine.startRecording(trigger: .manual)
+        try #require(await waitUntil { capture.isPending })
+        #expect(capture.pids == [99_999])
         #expect(await confirmCapture(engine, recorder))
         engine.stopAndTranscribe()
         #expect(engine.isTranscribing)
@@ -183,9 +221,10 @@ struct RecordingStartTimingTests {
         // The pipeline must hold in finalizing while the frozen context is unresolved —
         // it may not deliver without the selection frozen at start.
         try? await Task.sleep(for: .milliseconds(150))
+        #expect(capture.isPending)
         #expect(engine.flowPhase == .finalizing)
 
-        captureGate.signal()
+        capture.release()
         // No audio was produced by the fake recorder, so the pipeline ends in the
         // fail-closed no-audio state — importantly, only after the context resolved.
         #expect(await waitUntil {
@@ -196,6 +235,37 @@ struct RecordingStartTimingTests {
         #expect(engine.canStartRecording)
     }
 
+    @Test("intent detection disabled skips selection capture and can finish the empty attempt")
+    func disabledIntentDoesNotWaitForSelection() async throws {
+        let capture = BlockedSelectionCapture()
+        defer { capture.release() }
+        let recorder = FakePCMRecorder()
+        let engine = makeStartableEngine(recorder: recorder, intentDetectionEnabled: false) { pid in
+            capture.capture(pid)
+        }
+        engine.startRecording(trigger: .manual)
+        try #require(await confirmCapture(engine, recorder))
+        engine.stopAndTranscribe()
+        try #require(await waitUntil { !engine.isTranscribing })
+        #expect(capture.pids.isEmpty)
+        #expect(engine.flowPhase == .failed("No audio captured"))
+        #expect(engine.canStartRecording)
+    }
+
+    @Test("fixture intent modes stay on their engine without changing the process preference")
+    func fixtureIntentModeIsInstanceScoped() {
+        let defaults = UserDefaults.standard
+        let domain = Bundle.main.bundleIdentifier ?? ProcessInfo.processInfo.processName
+        let before = defaults.persistentDomain(forName: domain)?["intentDetectionEnabled"] as? NSObject
+        let enabled = makeStartableEngine(recorder: FakePCMRecorder(), intentDetectionEnabled: true)
+        #expect(enabled.intentDetectionEnabled)
+        #expect((defaults.persistentDomain(forName: domain)?["intentDetectionEnabled"] as? NSObject) == before)
+        let disabled = makeStartableEngine(recorder: FakePCMRecorder())
+        #expect(!disabled.intentDetectionEnabled)
+        #expect(enabled.intentDetectionEnabled)
+        #expect((defaults.persistentDomain(forName: domain)?["intentDetectionEnabled"] as? NSObject) == before)
+    }
+
     @Test("slow microphone shutdown keeps the UI responsive and finishes draining before transcription")
     func stopDoesNotBlockMainActor() async {
         let stopGate = DispatchSemaphore(value: 0)
@@ -219,19 +289,21 @@ struct RecordingStartTimingTests {
     }
 
     @Test("a released key before the capture resolves still cancels cleanly")
-    func cancelDuringPendingCapture() async {
-        let captureGate = DispatchSemaphore(value: 0)
+    func cancelDuringPendingCapture() async throws {
+        let capture = BlockedSelectionCapture()
+        defer { capture.release() }
         let recorder = FakePCMRecorder()
-        let engine = makeStartableEngine(recorder: recorder) { _ in
-            captureGate.wait()
-            return nil
+        let engine = makeStartableEngine(recorder: recorder, intentDetectionEnabled: true) { pid in
+            capture.capture(pid)
         }
         engine.startRecording(trigger: .manual)
+        try #require(await waitUntil { capture.isPending })
+        #expect(capture.pids == [99_999])
         #expect(await confirmCapture(engine, recorder))
         engine.cancelRecording()
         #expect(!engine.isRecording)
         #expect(engine.flowPhase == .idle)
-        captureGate.signal()
+        capture.release()
         #expect(engine.canStartRecording)
     }
 }

package/src/native/Recordings/RecordingsTests/TestHomeDirectory.swift

@@ -16,7 +16,11 @@ import Foundation
 /// back only the engine and so have no scope to remove it from; `CLIRunnerTests` instead
 /// passes the temp home it already creates and already deletes.
 func makeIsolatedTestHome(_ label: String) -> String {
-    let url = FileManager.default.temporaryDirectory
+    // Foundation can ignore TMPDIR under the Darwin test-bundle launcher. An
+    // explicit fixture root keeps confined tests inside their owned write scope.
+    let root = ProcessInfo.processInfo.environment["RECORDINGS_TEST_TMP_ROOT"]
+        .map { URL(fileURLWithPath: $0, isDirectory: true) } ?? FileManager.default.temporaryDirectory
+    let url = root
         .appendingPathComponent("recordings-\(label)-\(UUID().uuidString)")
     try? FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
     return url.path

package/src/native/Recordings/build.sh

@@ -505,7 +505,8 @@ generate_and_verify_native_fs_guard() {
       import { createRequire } from "node:module";
       const addon = createRequire(import.meta.url)(process.argv[1]);
       const expected = [
-        "chmodHandle", "close", "copyRegularNoReplaceAt", "fsyncHandle",
+        "chmodHandle", "close", "copyRegularNoReplaceAt", "duplicateDirectoryDescriptor",
+        "fsyncHandle", "handleHasNoExtendedAcl",
         "linkNoReplaceAt", "mkdirAt", "openDirAt", "openRegularAt", "openTrustedHome",
         "readDir", "readRegularAt", "removeTreeAt", "removeTreeHandleAt",
         "renameHandleNoReplaceAt", "renameNoReplaceAt", "renameReplaceAt",

package/dist/__tests__/helpers/installer-guard-execution.d.ts

@@ -1,22 +0,0 @@
-export declare const EXISTING_IDENTITY_SHA256: string;
-export declare const CANDIDATE_IDENTITY_SHA256: string;
-export declare const MANIFEST_SHA256: string;
-export type ArtifactPolicy = "local-only" | "release";
-export type IncompatibleDirection = "installed-requirement-vs-candidate" | "candidate-requirement-vs-installed" | "both";
-export type GuardExecutionOptions = {
-    identityMigration: boolean;
-    incompatibleDirection?: IncompatibleDirection;
-    artifactPolicy?: ArtifactPolicy;
-    extraArguments?: string[];
-};
-export type GuardExecutionResult = {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-    reachedTransaction: boolean;
-    codesignInvocations: string[];
-    bunInvocations: string[];
-    unstubbedInvocations: string[];
-};
-export declare function runInstallerToIdentityGuard(options: GuardExecutionOptions): GuardExecutionResult;
-//# sourceMappingURL=installer-guard-execution.d.ts.map

package/dist/__tests__/helpers/installer-guard-execution.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"installer-guard-execution.d.ts","sourceRoot":"","sources":["../../../src/__tests__/helpers/installer-guard-execution.ts"],"names":[],"mappings":"AA+DA,eAAO,MAAM,wBAAwB,QAAiB,CAAC;AACvD,eAAO,MAAM,yBAAyB,QAAiB,CAAC;AACxD,eAAO,MAAM,eAAe,QAAiB,CAAC;AAsB9C,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,SAAS,CAAC;AAuFtD,MAAM,MAAM,qBAAqB,GAE7B,oCAAoC,GAGpC,oCAAoC,GAEpC,MAAM,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAAG;IAKlC,iBAAiB,EAAE,OAAO,CAAC;IAG3B,qBAAqB,CAAC,EAAE,qBAAqB,CAAC;IAK9C,cAAc,CAAC,EAAE,cAAc,CAAC;IAEhC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IAKf,kBAAkB,EAAE,OAAO,CAAC;IAG5B,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAG9B,cAAc,EAAE,MAAM,EAAE,CAAC;IAMzB,oBAAoB,EAAE,MAAM,EAAE,CAAC;CAChC,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,qBAAqB,GAC7B,oBAAoB,CA2StB"}

package/dist/__tests__/helpers/installer-preflight.d.ts

@@ -1,22 +0,0 @@
-export declare const POLICY_RELATIVE_PATH = "scripts/policy/local-only-approved-targets.txt";
-export declare const READER_RELATIVE_PATH = "scripts/read_local_only_targets.sh";
-export declare const IDENTITY_GUARD_RELATIVE_PATH = "scripts/enforce_identity_migration.sh";
-export declare const readRepositoryFile: (relativePath: string) => string;
-export type InstallerPreflightOptions = {
-    artifactPolicy?: "release" | "local-only";
-    approvedTarget?: string;
-    hostname?: string;
-    extraArguments?: string[];
-    policyContents?: string | null;
-    removeReader?: boolean;
-    removeIdentityGuard?: boolean;
-    identityGuardContents?: string;
-    symlinkIdentityGuard?: boolean;
-    environment?: Record<string, string>;
-};
-export declare function runInstallerPreflight(options?: InstallerPreflightOptions): {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-};
-//# sourceMappingURL=installer-preflight.d.ts.map

package/dist/__tests__/helpers/installer-preflight.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"installer-preflight.d.ts","sourceRoot":"","sources":["../../../src/__tests__/helpers/installer-preflight.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,oBAAoB,mDAAmD,CAAC;AACrF,eAAO,MAAM,oBAAoB,uCAAuC,CAAC;AACzE,eAAO,MAAM,4BAA4B,0CAA0C,CAAC;AAEpF,eAAO,MAAM,kBAAkB,GAAI,cAAc,MAAM,KAAG,MACA,CAAC;AAc3D,MAAM,MAAM,yBAAyB,GAAG;IACtC,cAAc,CAAC,EAAE,SAAS,GAAG,YAAY,CAAC;IAC1C,cAAc,CAAC,EAAE,MAAM,CAAC;IAGxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAG9B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAG/B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAG/B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC,CAAC;AAEF,wBAAgB,qBAAqB,CACnC,OAAO,GAAE,yBAA8B,GACtC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CA8GtD"}

package/dist/__tests__/helpers/native-fs-guard.d.ts

@@ -1,2 +0,0 @@
-export declare function ensureNativeFsGuardAddon(repositoryRoot?: string): string;
-//# sourceMappingURL=native-fs-guard.d.ts.map

package/dist/__tests__/helpers/native-fs-guard.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"native-fs-guard.d.ts","sourceRoot":"","sources":["../../../src/__tests__/helpers/native-fs-guard.ts"],"names":[],"mappings":"AA2CA,wBAAgB,wBAAwB,CAAC,cAAc,SAAuC,GAAG,MAAM,CActG"}

package/dist/__tests__/helpers/source-assertions.d.ts

@@ -1,171 +0,0 @@
-/**
- * Shared assertions for contract tests that read source text.
- *
- * These live here rather than inside one suite because the defect they exist to prevent is
- * repo-wide: a sweep of every `*.test.ts` found 40 ordering assertions written as
- * `indexOf(a) < indexOf(b)`, across 11 files. `indexOf` answers -1 when the needle is absent and
- * `-1 < anything` is true, so such an assertion PASSES when the thing being ordered is DELETED.
- * The same hole exists in `.slice(indexOf(...), indexOf(...))` region bounds, where a -1 silently
- * slices from the end of the file or to its start — a region assertion over the wrong text, or over
- * none of it, reads exactly like a satisfied one.
- *
- * ---------------------------------------------------------------------------------------------
- * BEFORE YOU BUILD A MUTATION BATTERY: three suites are RED ON A CONTENDED STATION, not on Linux.
- *
- * A mutation battery is evidence only when its clean control is GREEN. Include a suite that was
- * already failing and the run was non-zero before you changed anything, so every mutation "looks
- * caught" and every verdict is manufactured. That already produced one wrong all-clear here.
- *
- * These are the three suites it happens to. NO PASS/FAIL SPLIT IS RECORDED FOR THEM ON PURPOSE —
- * see below. `macos-app-lifecycle.test.ts` has 140 tests, `native-app-companion-contract.test.ts`
- * has 14, `config.test.ts` has 44, and how many of those fail is a property of the MACHINE:
- *
- *   src/__tests__/macos-app-lifecycle.test.ts
- *   src/__tests__/native-app-companion-contract.test.ts
- *   src/__tests__/config.test.ts
- *
- * CORRECTED 2026-07-27, and the correction is the useful part. This block used to call them
- * "PERMANENTLY RED on Linux" and attribute fixed environmental causes — BSD `stat -f`, a fixture
- * port reading `NaN`, a `getDataDir` HOME-ancestor assumption. The first CI run this repository
- * ever had (run 30302342895, ubuntu-24.04) re-ran all three on a clean single-tenant runner and
- * every one of them PASSED:
- *
- *   macos-app-lifecycle            140 pass / 0 fail   (358.85s)
- *   native-app-companion-contract   14 pass / 0 fail   (  4.50s)
- *   config                          44 pass / 0 fail   (  0.10s)
- *
- * So the cause is not the platform. Measure on a quiet machine, or in CI, before recording a suite
- * as red. There were TWO independent station-local causes, and every earlier version of this comment
- * named only one of them. In a 92-fail run of `macos-app-lifecycle.test.ts` on this station the
- * failure messages broke down as 38 × `Home ancestor has an unexpected owner.`, 22 × FIFO
- * synchronisation timeout, 24 × ENOENT on a fixture marker. The first cause is now fixed in the
- * fixture and only the second remains; do not collapse them into one, because a quiet machine with
- * `FORCE_COLOR` set still showed all 38 aborts, so "measure on a quiet machine" was necessary and
- * not sufficient:
- *
- *   1. `FORCE_COLOR` — **FIXED IN THE FIXTURE, no longer a live cause.** The `stat` stub answered
- *      `%u` by shelling out to `bun -e '… console.log(statSync(…).uid)'`
- *      (`macos-app-lifecycle.test.ts:217`) and spread `...Bun.env` into the installer, so with
- *      `FORCE_COLOR` set Bun COLOURED the number: the installer compared `\e[0m\e[33m1000\e[0m`
- *      against `id -u`'s `1000` at `install_macos_app.sh:143` and aborted before reaching any gate.
- *      `NO_COLOR=1` did NOT help — FORCE_COLOR wins in Bun. The stub now writes bare integers with
- *      `process.stdout.write` and `unset FORCE_COLOR`s its own children, which takes that message
- *      from 38 to 0 in place, positive-controlled (the same grep still finds 38 in the pre-fix log).
- *      Nothing about ancestor MODE was ever involved: `verify_secure_parent` and
- *      `verify_safe_home_ancestor` each `stat` only the one path handed to them, the sole call is
- *      `verify_safe_home_ancestor "$HOME"`, and the stub hardcodes every `%Lp` answer anyway.
- *      Kept here rather than deleted because it is the reason this file's split moved, and because
- *      the same trap recurs in any stub that parses `console.log` of a NUMBER: only strings are
- *      left uncoloured.
- *   2. CONTENTION. The station routinely runs several full recordings suites at once out of
- *      different worktrees, and this suite scans a shared /tmp — the hazard this very comment warns
- *      about below. Those were FIFO timeouts at an internal 5000ms budget; the FIFO helper now uses
- *      the suite's configured timeout too, so a raised test budget can distinguish load sensitivity
- *      from a regression. With `FORCE_COLOR` unset the residual failures scaled with load: 132 pass /
- *      8 fail at load ~20, 114 pass / 26 fail at load 44-60 on the same commit, which is why no split
- *      belongs here either. GitHub Actions sets neither `FORCE_COLOR` nor a competing suite, which
- *      is why both causes were absent from the only clean measurement.
- *
- * WHY NO SPLIT IS RECORDED. Every split ever written here has gone stale, including two written as
- * corrections. On one unchanged tree, three consecutive runs measured 48/92, 48/92, 49/91; the
- * single test that flips is `runtime smoke timeout does not wait forever on a live open process`
- * (`macos-app-lifecycle.test.ts:3594`), which races a hardcoded internal `Bun.sleep(2_000)` that no
- * `--timeout` flag reaches either. So a count comparison across two trees shows a phantom delta
- * from this file alone — which is the concrete reason for the rule below: compare failing test
- * NAMES, never counts. Two trees whose failing NAME SETS are identical are identical regardless of
- * what the totals say.
- *
- * `@hasna/events` MUST resolve 0.1.11, as `bun.lock` pins it. A plain `bun install` pulls 0.1.14,
- * which dropped a shipped CLI command inside the patch range and fails `cli.test.ts` — and it can
- * drift back mid-session, so re-check it before quoting any cross-tree comparison.
- *
- * Corollary, also corrected: this repo NOW HAS CI. The repo-root
- * `.github/workflows/ci.yml` gates the whole TypeScript suite with no exemptions on every
- * pull request, so these suites are no longer gated only by somebody remembering to run
- * them. The Swift/C half compiles in CI through the repo-root
- * `.github/workflows/recordings-macos.yml` (`verify:ci-native`); see
- * `.github/native-known-errors.txt` for what that gate means.
- * Compare failing test NAMES, never counts — the suite is nondeterministic at the margin.
- * ---------------------------------------------------------------------------------------------
- */
-/**
- * Assert `first` appears before `second`, requiring BOTH to exist.
- *
- * Use this instead of comparing two `indexOf` results directly. `firstMatch: "last"` selects
- * `lastIndexOf` for the first operand, which has the identical -1 hole.
- */
-export declare function expectOrder(haystack: string, first: string, second: string, options?: {
-    firstMatch?: "first" | "last";
-}): void;
-/**
- * Slice between two markers, requiring both to exist and the region to be non-trivial.
- *
- * The length floor matters as much as the -1 checks: `slice(-1)` yields a ONE-CHARACTER string, not
- * an empty one, so a `expect(region.length).toBeGreaterThan(0)` control passes on a region that
- * contains nothing worth asserting about. Any `not.toContain` over such a region is vacuous.
- */
-export declare function sliceBetween(source: string, open: string, close: string, options?: {
-    minimumLength?: number;
-}): string;
-/**
- * Assert a marker occurs exactly once before slicing on it.
- *
- * A duplicated end marker silently extends a region: `let myPID = ProcessInfo…` occurs twice in
- * `RecordingEngine.swift`, so a region bounded by it could stretch ~127 KB and be satisfied by
- * copies of the needle from an unrelated function.
- */
-export declare function sliceBetweenUnique(source: string, open: string, close: string): string;
-/** Strip Swift line comments so an assertion about code is not defeated by prose. */
-export declare function withoutComments(source: string): string;
-/**
- * Index just past the `close` matching the `open` at `openIndex`, skipping comments and literals.
- *
- * Needed because `lastIndexOf("}")` is not brace matching, and the difference is a live defect: an
- * early exit written between a decision and its use —
- *
- *     }                                        // the decision table closes here
- *     guard stillOwnsChangeCount else { return }
- *     if shouldRestore { … }
- *
- * — puts a NEARER `}` (the `else` block's) between the two, so a "nothing between them" check
- * measured from the last brace saw only whitespace and passed. Counting braces naively fails the
- * other way: one `}` inside a string literal, such as `log("settlement }")`, cancels a real opener.
- * Both were measured surviving at EXIT=0.
- */
-export declare function matchingDelimiterIndex(source: string, openIndex: number, open: string, close: string): number;
-export declare function withoutAnyComments(source: string): string;
-/**
- * The arms of a Swift `switch` body, as a mapping from each matched case to its expression.
- *
- * Order- and grouping-independent, which matters because pinning an arm by its exact TEXT gets both
- * directions wrong. It false-positives on a pure reorder — `.deliveredUnverified, .deliveryNotObserved`
- * is the same table and failed — and it misses a real defect: splitting one outcome out of a group
- * into its own arm with a different expression leaves the pinned needle intact, so
- * `.targetUnavailable` could be given `false` while the six-outcome needle still matched.
- *
- * `body` is the text between the switch's braces, comments already stripped by the caller.
- */
-export declare function switchArmsByOutcome(body: string): Map<string, string>;
-/**
- * Evaluate a Swift boolean condition for a given binding of its identifiers.
- *
- * Folded in from PR #43, which pinned the clipboard-restore guard by evaluating it for BOTH values
- * of the decision rather than comparing its text. That is the half worth keeping: an exact
- * `toBe("shouldRestore")` on a captured condition kills the inversion, but it also fails on
- * `(shouldRestore)` and on a trailing comment — reporting refactors as defects while proving
- * nothing about behaviour.
- *
- * Deliberately narrow and fail-CLOSED: `true`, `false`, `!x`, whole-expression parentheses, and
- * identifiers present in `env`. Anything else throws. An added disjunct
- * (`shouldRestore || stillOwnsChangeCount`) is an unevaluatable expression, not a passing one —
- * which is the behaviour that matters, because that disjunct is exactly how the
- * transcript-destroying defect gets reintroduced. Extend the evaluator when a new shape is
- * legitimate; do not loosen the assertion.
- */
-export declare function evaluateSwiftCondition(condition: string, env: Record<string, boolean>): boolean;
-/**
- * Every Swift source under a root, so an absence claim can be made about the app rather than about
- * whichever files were on the reviewer's mind.
- */
-export declare function swiftSourcesUnder(root: string): Array<[path: string, source: string]>;
-//# sourceMappingURL=source-assertions.d.ts.map

package/dist/__tests__/helpers/source-assertions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"source-assertions.d.ts","sourceRoot":"","sources":["../../../src/__tests__/helpers/source-assertions.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AAEH;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;CAAO,GAC9C,IAAI,CAON;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAA;CAAO,GACvC,MAAM,CAWR;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAMtF;AAED,qFAAqF;AACrF,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKtD;AAuED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,MAAM,CA0BR;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAoEzD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAyBrE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAiC/F;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAIrF"}

package/dist/__tests__/preload.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=preload.d.ts.map

package/dist/__tests__/preload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"preload.d.ts","sourceRoot":"","sources":["../../src/__tests__/preload.ts"],"names":[],"mappings":""}