@smthrs/std 0.0.0-stage → 1.0.0-rc.4

package/dist/esm/TestRun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestRun.js","sourceRoot":"","sources":["../../src/TestRun.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The `test` flow: run the declared suite, and answer with the two facts.\n *\n * Two things this returns that a shell command cannot. First, a *reading*:\n * `{passed, failed}` parsed from the runner's own report, with the raw tail\n * kept for whatever the parse could not carry — a suite's answer is a number\n * and a list of names, not twenty kilobytes of stdout for a model to re-read.\n *\n * Second, `against: \"base\"`: the same selection also runs against the pristine\n * base commit in a scratch checkout, and the two failure sets are differenced\n * here. That is the whole of attribution, in one call. Without it, agents pay\n * for it in frames — sphinx-8721 spent fourteen frames because a pre-existing\n * failure was never baselined, sympy-13878 spent $0.90 on the same mistake, and\n * django-24970 spent three frames. The rule the harness teaches (\"before\n * blaming your own edit, run the same command on the unmodified tree\") is only\n * cheap when the tool can do it.\n *\n * A third thing is answered on the way out: whether a non-zero exit is the\n * tree's failure at all, or the command failing to resolve a name. Jev decides\n * it through `Probe.classify`, so the flow needs an `Evaluator` and a host\n * uses its configured subscription seat. A judge that does not answer fails the call with\n * the code `Probe.unjudged` names, because a run nobody judged is not a run\n * this flow can report on.\n *\n * @since 1.0.0\n */\n\nimport type * as ChildProcessSpawner from \"@smthrs/kernel/ChildProcessSpawner\"\nimport type * as Evaluator from \"@smthrs/model/Evaluator\"\nimport * as Effect from \"effect/Effect\"\nimport * as Option from \"effect/Option\"\nimport * as Schema from \"effect/Schema\"\nimport * as Container from \"./Container.ts\"\nimport { capability, envelope } from \"./internal/Declaration.ts\"\nimport * as Exec from \"./internal/Exec.ts\"\nimport { GitWorktree } from \"./internal/GitWorktree.ts\"\nimport * as Prune from \"./internal/Prune.ts\"\nimport * as TestReport from \"./internal/TestReport.ts\"\nimport { MAX_SHELL_OUTPUT_BYTES, truncateBytes } from \"./internal/Text.ts\"\nimport * as Probe from \"./Probe.ts\"\nimport * as StdError from \"./StdError.ts\"\nimport * as TestRunner from \"./TestRunner.ts\"\n\n/**\n * Registry name for the test flow.\n *\n * @category identifiers\n * @since 1.0.0\n */\nexport const name = \"test\"\n\n/**\n * Model-facing description of the test flow.\n *\n * @category descriptions\n * @since 1.0.0\n */\nexport const description =\n  \"Run this repository's declared test runner and get {passed, failed[ids]}, not raw output. against:'base' also runs it on the pristine base commit, so a pre-existing failure is named, not investigated.\"\n\n/**\n * The parent directory baseline checkouts are written into, relative to the\n * repository root, and therefore also relative to the runner's own directory.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const scratchDirectory = Prune.testBaseScratch\n\n/**\n * Default wall-clock budget for one test run.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const DEFAULT_TIMEOUT_MS = 600_000\n\n/**\n * Maximum bytes retained from each stream while a test run executes.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const MAX_CAPTURE_BYTES = 8_000_000\n\n/**\n * Input schema for the test flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Input = Schema.Struct({\n  selection: Schema.optional(Schema.Array(Schema.String)).annotate({\n    description: \"Test ids, paths or selectors passed to the runner as arguments; all tests when omitted\"\n  }),\n  against: Schema.optional(Schema.Literals([\"workspace\", \"base\"])).annotate({\n    description:\n      \"workspace (default) runs the tree as it stands; base also runs the pristine base commit and reports which failures are new\"\n  }),\n  timeoutMs: Schema.optional(Schema.Number).annotate({ description: \"Wall-clock timeout in milliseconds\" })\n})\n\n/**\n * Decoded input accepted by the `test` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Input = typeof Input.Type\n\n/**\n * One run's outcome.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Outcome = Schema.Struct({\n  command: Schema.String.annotate({\n    description: \"The logical invocation that ran, without container transport arguments\"\n  }),\n  exitCode: Schema.Number,\n  passed: Schema.Number.annotate({ description: \"Tests reported passing; 0 when parsed is false\" }),\n  failed: Schema.Array(Schema.String).annotate({ description: \"Ids of the tests reported failing or erroring\" }),\n  parsed: Schema.Boolean.annotate({\n    description:\n      \"Whether the runner's complete report could be read; when false, tail is all there is. Base attribution is omitted unless both reports are complete\"\n  }),\n  tail: Schema.String.annotate({ description: \"The end of the runner's combined output\" }),\n  // `<field>Truncated` beside `<field>` is the wire convention\n  // `@smthrs/harness/TruncatedOutput` reads to refuse a later write of these\n  // exact bytes. A tail written over a file replaces it with its own end.\n  tailTruncated: Schema.Boolean.annotate({\n    description: \"Whether the runner printed more than tail carries, leaving tail a fragment that must not be written\"\n  }),\n  tailDroppedBytes: Schema.Number.annotate({ description: \"UTF-8 bytes omitted from the start of tail\" }),\n  invalidProbe: Schema.optional(Probe.InvalidProbe)\n})\n\n/**\n * Output schema for the test flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Output = Schema.Struct({\n  ...Outcome.fields,\n  base: Schema.optional(Schema.Struct({\n    ...Outcome.fields,\n    ref: Schema.String.annotate({ description: \"The ref the baseline tree came from\" }),\n    commit: Schema.String.annotate({ description: \"The commit the baseline tree came from\" })\n  })),\n  introduced: Schema.optional(Schema.Array(Schema.String)).annotate({\n    description: \"Failing here and not on the base tree: the failures this working tree is responsible for\"\n  }),\n  preexisting: Schema.optional(Schema.Array(Schema.String)).annotate({\n    description: \"Failing on both trees: not yours, and not worth investigating\"\n  }),\n  fixed: Schema.optional(Schema.Array(Schema.String)).annotate({\n    description: \"Failing on the base tree and passing here\"\n  })\n})\n\n/**\n * Decoded output returned by the `test` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Output = typeof Output.Type\n\n/**\n * Static conservative effect envelope for the test flow.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effects = envelope({ tier: \"irreversible\", mode: \"expected\", reads: [], writes: [] })\n\n/**\n * Narrows the effect envelope for a decoded invocation.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effectsFor = (_input: typeof Input.Type) => effects\n\n/**\n * Capabilities required by the test flow.\n *\n * @category capabilities\n * @since 1.0.0\n */\nexport const capabilities = [capability(\"proc:spawn\", \"*\")]\n\n/**\n * Declaration-only test flow.\n *\n * @category flows\n * @since 1.0.0\n */\nexport const flow = { name, description, input: Input, output: Output, capabilities, effects } as const\n\n/**\n * What a call to this flow does, for a reader of a run.\n *\n * Display metadata only. `@smthrs/registry` `Descriptor.FlowActivity` is the\n * governing vocabulary and `StandardFlows` binds this value onto the flow's\n * descriptor, where the binding site checks it. `declarationDigest` excludes\n * it, so declaring it cannot invalidate a call identity or a cached prompt.\n *\n * @category presentation\n * @since 1.0.0-rc.0\n */\nexport const activity = \"tests\" as const\n\n/**\n * How one recorded call to this flow reads: the verb for each settlement, the\n * input field that is its subject, and the measured output fields a one-line\n * summary may count.\n *\n * Display metadata only, governed by `@smthrs/registry`\n * `Descriptor.CallPresentation` and checked where `StandardFlows` binds it.\n *\n * @category presentation\n * @since 1.0.0-rc.0\n */\nexport const presentation = {\n  verb: { pending: \"running\", success: \"ran\", failure: \"failed to run\" },\n  subject: \"selection\",\n  result: \"tests\"\n} as const\n\n/**\n * The invocation for one run: the declared command line with the selection\n * appended as arguments rather than as text.\n *\n * `bash -c '<command> \"$@\"' <command> id…` is how a selection reaches a runner\n * without being quoted into it. A test id holds `::`, `[`, `]`, spaces and\n * shell metacharacters routinely, and every one of them is data here.\n */\nconst invocation = (\n  runner: TestRunner.Runner,\n  selection: ReadonlyArray<string>\n): { readonly file: string; readonly args: ReadonlyArray<string> } => ({\n  file: \"bash\",\n  args: [\"-c\", `${runner.command} \"$@\"`, runner.command, ...selection]\n})\n\nconst failed = (message: string, code: StdError.Code = \"command_failed\"): StdError.StdError =>\n  new StdError.StdError({ code, message })\n\n/** Runs one invocation, in the container when the declaration names one. */\nconst execute = (\n  runner: TestRunner.Runner,\n  transport: Option.Option<Container.Container>,\n  options: {\n    readonly selection: ReadonlyArray<string>\n    readonly cwd: string | undefined\n    readonly timeoutMs: number\n  }\n): Effect.Effect<\n  { readonly outcome: typeof Outcome.Type; readonly report: TestReport.Report },\n  StdError.StdError,\n  ChildProcessSpawner.ChildProcessSpawner | Evaluator.Evaluator\n> =>\n  Effect.gen(function*() {\n    const plan = invocation(runner, options.selection)\n    const routed: Container.Plan = runner.container === undefined ?\n      { ...plan, env: runner.env } :\n      Option.isNone(transport)\n      ? yield* Effect.fail(Container.unavailable(runner.container))\n      : yield* transport.value.exec({\n        container: runner.container,\n        file: plan.file,\n        args: plan.args,\n        ...(options.cwd === undefined ? {} : { cwd: options.cwd }),\n        ...(runner.env === undefined ? {} : { env: runner.env }),\n        stdin: false\n      })\n    // Report the logical invocation, never the transport or its credentials.\n    const quoted = [plan.file, ...plan.args].join(\" \")\n    const result = yield* Exec.exec(routed.file, {\n      args: [...routed.args],\n      ...(options.cwd === undefined || runner.container !== undefined ? {} : { cwd: options.cwd }),\n      ...(routed.env === undefined ? {} : { env: routed.env }),\n      timeoutMs: options.timeoutMs,\n      maxCaptureBytes: MAX_CAPTURE_BYTES\n    }).pipe(\n      Effect.mapError((error) =>\n        new StdError.StdError({\n          code: Exec.toStdErrorCode(error),\n          message: `The test runner did not run: ${error.message}`,\n          ...(error.limitMillis === undefined ? {} : { limitMillis: error.limitMillis })\n        })\n      )\n    )\n    const combined = result.stderr === \"\"\n      ? result.stdout\n      : result.stdout === \"\"\n      ? result.stderr\n      : `${result.stdout}\\n${result.stderr}`\n    const tail = truncateBytes(combined, MAX_SHELL_OUTPUT_BYTES, { keep: \"tail\" })\n    const report = TestReport.parse(combined)\n    // Judged on the text this call returns rather than the text it captured,\n    // so the attribution is made from the output the reader can see. A judge\n    // that does not answer fails the call: see `Probe.unjudged`.\n    const probe = yield* Probe.classify({\n      command: quoted,\n      exitCode: result.exitCode,\n      output: tail.text\n    }).pipe(Effect.mapError(Probe.unjudged))\n    const capturedDroppedBytes = result.stdoutDroppedBytes + result.stderrDroppedBytes\n    return {\n      outcome: {\n        command: quoted,\n        exitCode: result.exitCode,\n        passed: report.passed,\n        failed: report.failed,\n        parsed: report.parsed,\n        tail: tail.text,\n        tailTruncated: capturedDroppedBytes > 0 || tail.truncated,\n        tailDroppedBytes: capturedDroppedBytes + tail.droppedBytes,\n        ...(probe.invalidProbe === undefined ? {} : { invalidProbe: probe.invalidProbe })\n      },\n      report\n    }\n  })\n\n/**\n * Runs the declared suite, and on request the same suite on the pristine base.\n *\n * Baseline Git and both runners use the caller-provided process service.\n * A host that cannot safely stage the base declares `baseline: false`, which\n * refuses the request before running either suite or Git. Library hosts that\n * support staging remove the detached checkout when the call ends.\n *\n * @category handlers\n * @since 1.0.0\n */\nexport const run = Effect.fn(\"TestRun.run\")(function*(\n  input: typeof Input.Type\n): Effect.fn.Return<\n  typeof Output.Type,\n  StdError.StdError,\n  ChildProcessSpawner.ChildProcessSpawner | Evaluator.Evaluator | TestRunner.TestRunner\n> {\n  const declaration = yield* TestRunner.TestRunner\n  const runner = yield* declaration.declared\n  if (input.against === \"base\" && runner.baseline === false) {\n    return yield* Effect.fail(failed(\n      \"Baseline comparison is unavailable on this host. Run against the workspace.\",\n      \"provider_unavailable\"\n    ))\n  }\n  const transport = yield* Effect.serviceOption(Container.Container)\n  const selection = input.selection ?? []\n  const timeoutMs = input.timeoutMs ?? runner.timeoutMs ?? DEFAULT_TIMEOUT_MS\n  const current = yield* execute(runner, transport, {\n    selection,\n    cwd: runner.cwd,\n    timeoutMs\n  })\n  if (input.against !== \"base\") return current.outcome\n\n  const root = runner.root ?? runner.cwd\n  if (root === undefined) {\n    return yield* Effect.fail(\n      failed(\n        \"The declared runner names no repository directory, so there is no base tree to check out\",\n        \"invalid_input\"\n      )\n    )\n  }\n  const base = yield* GitWorktree.resolveCommit(\n    root,\n    runner.baseRef === undefined ? [TestRunner.captureBase, \"HEAD\"] : [runner.baseRef]\n  ).pipe(Effect.mapError((error) =>\n    error.code === \"not_found\"\n      ? failed(`No pristine base to compare against: ${error.message} Run against the workspace instead.`, \"not_found\")\n      : error\n  ))\n  const baseline = yield* GitWorktree.withDetachedWorktree(\n    root,\n    `${scratchDirectory}/run`,\n    base.commit,\n    (scratch) =>\n      execute(runner, transport, {\n        selection,\n        cwd: runner.cwd === undefined\n          ? scratch\n          : `${runner.cwd.replace(/\\/+$/, \"\")}${scratch.slice(root.replace(/\\/+$/, \"\").length)}`,\n        timeoutMs\n      })\n  )\n  const difference = TestReport.attribute(current.report, baseline.report)\n  return {\n    ...current.outcome,\n    base: { ...baseline.outcome, ref: base.ref, commit: base.commit },\n    ...(difference === undefined ? {} : difference)\n  }\n})\n"]}

package/dist/esm/TestRunner.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The repository's own test invocation, declared once by the host.
+ *
+ * Every repository already knows how to run its tests, and the harness is told
+ * so at setup. What the measured program shows is what happens when that fact
+ * is not a *callable* thing: agents guess labels
+ * (`management_commands.test_flush`, `tests/related_lookup`, `test_axis.py` —
+ * none of which exist), and a guessed label costs a frame each time. Seven such
+ * invocations are documented across the 45 instances.
+ *
+ * So the invocation is a declaration, not a parameter: a caller of the `test`
+ * flow selects *which* tests, never *how* to run them.
+ *
+ * @since 1.0.0
+ */
+import { Context, Effect, Layer } from "effect";
+import * as StdError from "./StdError.ts";
+/**
+ * The default ref naming a tree as it stood before the agent touched it.
+ *
+ * The engine records the pristine checkout under this ref, so a baseline run
+ * reuses what already exists instead of inventing a second notion of "base".
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const captureBase = "refs/flows/capture-base";
+/**
+ * How this repository runs its tests.
+ *
+ * `cwd` is where the runner runs, and `root` is the host directory holding the
+ * git repository. They differ exactly when the runner runs in a container: the
+ * container sees the repository at `cwd`, the host sees it at `root`, and a
+ * baseline checkout created at `<root>/<name>` is visible to the runner at
+ * `<cwd>/<name>` because it is the same directory under two names.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Runner {
+    /** The runner command line, without any test selection. */
+    readonly command: string;
+    /** Where the runner runs; the container's path when `container` is set. */
+    readonly cwd?: string | undefined;
+    /** The host path of the repository, when it differs from `cwd`. */
+    readonly root?: string | undefined;
+    /** A container to route the run through, via the `Container` transport. */
+    readonly container?: string | undefined;
+    /** Environment the runner needs. */
+    readonly env?: Record<string, string> | undefined;
+    /** The ref whose commit is the pristine base; defaults to {@link captureBase}, then HEAD. */
+    readonly baseRef?: string | undefined;
+    /** False refuses baseline requests before any process runs. */
+    readonly baseline?: false | undefined;
+    /** Default wall-clock budget for one run. */
+    readonly timeoutMs?: number | undefined;
+}
+/**
+ * The declaration service.
+ *
+ * @category services
+ * @since 1.0.0
+ */
+export interface TestRunner {
+    readonly declared: Effect.Effect<Runner, StdError.StdError>;
+}
+/**
+ * The {@link TestRunner} service tag.
+ *
+ * @category services
+ * @since 1.0.0
+ */
+export declare const TestRunner: Context.Service<TestRunner, TestRunner>;
+/**
+ * Declares one repository's runner.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: (runner: Runner) => TestRunner;
+/**
+ * Declares that this host knows of no runner.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const makeNoop: () => TestRunner;
+/**
+ * Provides {@link make}.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layer: (runner: Runner) => Layer.Layer<TestRunner>;
+/**
+ * Provides {@link makeNoop}.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layerNoop: Layer.Layer<TestRunner>;
+//# sourceMappingURL=TestRunner.d.ts.map

package/dist/esm/TestRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestRunner.d.ts","sourceRoot":"","sources":["../../src/TestRunner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAC/C,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,4BAA4B,CAAA;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,MAAM;IACrB,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,mEAAmE;IACnE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACvC,oCAAoC;IACpC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IACjD,6FAA6F;IAC7F,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACrC,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,SAAS,CAAA;IACrC,6CAA6C;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAA;CAC5D;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAAE,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,UAAU,CAA6C,CAAA;AAE5G;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,QAAQ,MAAM,KAAG,UAAiE,CAAA;AAEvG;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,QAAO,UASxB,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,QAAQ,MAAM,KAAG,KAAK,CAAC,KAAK,CAAC,UAAU,CAA4C,CAAA;AAEzG;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAAyC,CAAA"}

package/dist/esm/TestRunner.js

@@ -0,0 +1,68 @@
+/**
+ * The repository's own test invocation, declared once by the host.
+ *
+ * Every repository already knows how to run its tests, and the harness is told
+ * so at setup. What the measured program shows is what happens when that fact
+ * is not a *callable* thing: agents guess labels
+ * (`management_commands.test_flush`, `tests/related_lookup`, `test_axis.py` —
+ * none of which exist), and a guessed label costs a frame each time. Seven such
+ * invocations are documented across the 45 instances.
+ *
+ * So the invocation is a declaration, not a parameter: a caller of the `test`
+ * flow selects *which* tests, never *how* to run them.
+ *
+ * @since 1.0.0
+ */
+import { Context, Effect, Layer } from "effect";
+import * as StdError from "./StdError.js";
+/**
+ * The default ref naming a tree as it stood before the agent touched it.
+ *
+ * The engine records the pristine checkout under this ref, so a baseline run
+ * reuses what already exists instead of inventing a second notion of "base".
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export const captureBase = "refs/flows/capture-base";
+/**
+ * The {@link TestRunner} service tag.
+ *
+ * @category services
+ * @since 1.0.0
+ */
+export const TestRunner = Context.Service("@smthrs/std/TestRunner");
+/**
+ * Declares one repository's runner.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export const make = (runner) => TestRunner.of({ declared: Effect.succeed(runner) });
+/**
+ * Declares that this host knows of no runner.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export const makeNoop = () => TestRunner.of({
+    declared: Effect.fail(new StdError.StdError({
+        code: "provider_unavailable",
+        message: "No test runner is declared for this repository, so there is nothing for the test flow to run. Use bash with the command this project's own documentation gives."
+    }))
+});
+/**
+ * Provides {@link make}.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export const layer = (runner) => Layer.succeed(TestRunner, make(runner));
+/**
+ * Provides {@link makeNoop}.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export const layerNoop = Layer.succeed(TestRunner, makeNoop());
+//# sourceMappingURL=TestRunner.js.map

package/dist/esm/TestRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestRunner.js","sourceRoot":"","sources":["../../src/TestRunner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAC/C,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,yBAAyB,CAAA;AA2CpD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAA4C,OAAO,CAAC,OAAO,CAAC,wBAAwB,CAAC,CAAA;AAE5G;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,MAAc,EAAc,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;AAEvG;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,GAAe,EAAE,CACvC,UAAU,CAAC,EAAE,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC,IAAI,CACnB,IAAI,QAAQ,CAAC,QAAQ,CAAC;QACpB,IAAI,EAAE,sBAAsB;QAC5B,OAAO,EACL,iKAAiK;KACpK,CAAC,CACH;CACF,CAAC,CAAA;AAEJ;;;;;GAKG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,MAAc,EAA2B,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;AAEzG;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAA4B,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE,QAAQ,EAAE,CAAC,CAAA","sourcesContent":["/**\n * The repository's own test invocation, declared once by the host.\n *\n * Every repository already knows how to run its tests, and the harness is told\n * so at setup. What the measured program shows is what happens when that fact\n * is not a *callable* thing: agents guess labels\n * (`management_commands.test_flush`, `tests/related_lookup`, `test_axis.py` —\n * none of which exist), and a guessed label costs a frame each time. Seven such\n * invocations are documented across the 45 instances.\n *\n * So the invocation is a declaration, not a parameter: a caller of the `test`\n * flow selects *which* tests, never *how* to run them.\n *\n * @since 1.0.0\n */\n\nimport { Context, Effect, Layer } from \"effect\"\nimport * as StdError from \"./StdError.ts\"\n\n/**\n * The default ref naming a tree as it stood before the agent touched it.\n *\n * The engine records the pristine checkout under this ref, so a baseline run\n * reuses what already exists instead of inventing a second notion of \"base\".\n *\n * @category constants\n * @since 1.0.0\n */\nexport const captureBase = \"refs/flows/capture-base\"\n\n/**\n * How this repository runs its tests.\n *\n * `cwd` is where the runner runs, and `root` is the host directory holding the\n * git repository. They differ exactly when the runner runs in a container: the\n * container sees the repository at `cwd`, the host sees it at `root`, and a\n * baseline checkout created at `<root>/<name>` is visible to the runner at\n * `<cwd>/<name>` because it is the same directory under two names.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Runner {\n  /** The runner command line, without any test selection. */\n  readonly command: string\n  /** Where the runner runs; the container's path when `container` is set. */\n  readonly cwd?: string | undefined\n  /** The host path of the repository, when it differs from `cwd`. */\n  readonly root?: string | undefined\n  /** A container to route the run through, via the `Container` transport. */\n  readonly container?: string | undefined\n  /** Environment the runner needs. */\n  readonly env?: Record<string, string> | undefined\n  /** The ref whose commit is the pristine base; defaults to {@link captureBase}, then HEAD. */\n  readonly baseRef?: string | undefined\n  /** False refuses baseline requests before any process runs. */\n  readonly baseline?: false | undefined\n  /** Default wall-clock budget for one run. */\n  readonly timeoutMs?: number | undefined\n}\n\n/**\n * The declaration service.\n *\n * @category services\n * @since 1.0.0\n */\nexport interface TestRunner {\n  readonly declared: Effect.Effect<Runner, StdError.StdError>\n}\n\n/**\n * The {@link TestRunner} service tag.\n *\n * @category services\n * @since 1.0.0\n */\nexport const TestRunner: Context.Service<TestRunner, TestRunner> = Context.Service(\"@smthrs/std/TestRunner\")\n\n/**\n * Declares one repository's runner.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const make = (runner: Runner): TestRunner => TestRunner.of({ declared: Effect.succeed(runner) })\n\n/**\n * Declares that this host knows of no runner.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const makeNoop = (): TestRunner =>\n  TestRunner.of({\n    declared: Effect.fail(\n      new StdError.StdError({\n        code: \"provider_unavailable\",\n        message:\n          \"No test runner is declared for this repository, so there is nothing for the test flow to run. Use bash with the command this project's own documentation gives.\"\n      })\n    )\n  })\n\n/**\n * Provides {@link make}.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layer = (runner: Runner): Layer.Layer<TestRunner> => Layer.succeed(TestRunner, make(runner))\n\n/**\n * Provides {@link makeNoop}.\n *\n * @category layers\n * @since 1.0.0\n */\nexport const layerNoop: Layer.Layer<TestRunner> = Layer.succeed(TestRunner, makeNoop())\n"]}

package/dist/esm/TreeFingerprint.d.ts

@@ -0,0 +1,140 @@
+/**
+ * The identity of one directory tree, measured where the tree is.
+ *
+ * `@smthrs/agent/WorkspaceObservation` measures the host workspace around
+ * every frame so the loop's mutation accounting is a fact rather than a
+ * claim. A command routed into a container writes to a filesystem that walk
+ * never sees: the SWE-bench rig bind-mounts the checkout into its container,
+ * so a container edit lands on the host too, but a container Harbor or Pier
+ * starts has no such mount, and every edit an agent made there read as an
+ * idle frame. Measured 2026-09-22 on Terminal-Bench 4.0: `read_only_cap`
+ * ended one run after twenty-four frames of container writes, and the claim
+ * judge refused another's completion as "work this run never recorded".
+ *
+ * This module is the same measurement taken inside the container: one POSIX
+ * shell script that lists every kept file under a directory with its size and
+ * modification time, in sorted order, and prints one checksum of the listing.
+ * `bash` runs it through the container transport before and after a
+ * containerised command and reports whether the two answers differ under the
+ * reserved {@link key}. The harness reads that key as a measured write, the
+ * way it reads `invalidProbe` as a measured refusal.
+ *
+ * The same properties as the host walk, and the same stated limits:
+ *
+ * - **Identity, not content.** Size and mtime per file; a rewrite that
+ *   restores both is invisible.
+ * - **Pruning is the signal.** {@link defaultPrune} and
+ *   {@link defaultIgnoreSuffixes} are the one list both measurements use, so
+ *   a derived artifact the host walk skips is skipped here too.
+ * - **A partial listing says so.** The listing stops at {@link maxPaths}, and
+ *   a measurement that stopped there reports `complete: false`; `bash` then
+ *   reports nothing rather than a guess.
+ * - **Every tool it needs is POSIX or busybox.** `find -prune`, `stat -c`,
+ *   `sort`, `head`, `cksum` and `grep -c` are in every Linux base image this
+ *   has been run against, GNU and busybox alike. A container that lacks one
+ *   answers with a non-zero exit, which is read as "unmeasured".
+ *
+ * @since 1.0.0
+ */
+/**
+ * The reserved output key a flow reports a measured write under.
+ *
+ * A wire contract with the harness rather than a shared type, exactly as
+ * `Probe.key` is: `@smthrs/harness` reads this key off a `Schema.Json` result
+ * and must not depend on the tool library to do it. `true` means the tree the
+ * call targeted differed after the call from before it; `false` means it was
+ * measured and held still; absent means it was not measured.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export declare const key = "mutated";
+/**
+ * Directory names never descended into.
+ *
+ * Every entry is a place a tool writes derived state while the run is working:
+ * version-control internals, dependency trees, and the caches Python, Node,
+ * Rust and their test runners keep beside the sources. A run that changes only
+ * these has changed nothing it will be judged on.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const defaultPrune: ReadonlyArray<string>;
+/**
+ * File and directory name suffixes left out of a measurement.
+ *
+ * Compiled output is the case that matters: several SWE-bench projects build
+ * extensions in place, which drops `.so` files next to the `.py` files they
+ * came from. Those move whenever the run executes its test suite, and
+ * counting them would report every probe as an edit.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const defaultIgnoreSuffixes: ReadonlyArray<string>;
+/**
+ * The largest number of files one measurement covers.
+ *
+ * The same bound the host walk uses, for the same reason: a listing that
+ * stopped here covers a prefix chosen by sort order, and a prefix holding
+ * still says nothing about the files being edited outside it.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const maxPaths = 50000;
+/**
+ * One measurement, as {@link parse} reads it off the script's output.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Measurement {
+    /** The checksum of the whole listing; equal for two measurements of an unchanged tree. */
+    readonly digest: string;
+    /** How many files the listing covered. */
+    readonly paths: number;
+    /** Whether the listing covered the whole tree rather than a bounded prefix. */
+    readonly complete: boolean;
+}
+/**
+ * The POSIX shell script that measures the current directory.
+ *
+ * Prints two lines: `cksum`'s `<crc> <bytes>` over the sorted listing, then
+ * the number of listing lines. The listing is capped one past
+ * {@link maxPaths} so the count alone says whether the bound was reached.
+ * Errors from `find` and `stat` are discarded: a path that vanished mid-walk
+ * is movement the next measurement reports, and a file the shell may not
+ * stat is one it could not have measured either way.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const script: (options?: {
+    readonly prune?: ReadonlyArray<string> | undefined;
+    readonly ignoreSuffixes?: ReadonlyArray<string> | undefined;
+}) => string;
+/**
+ * Reads one measurement off the script's standard output.
+ *
+ * `undefined` for anything that is not two well-formed lines: the script did
+ * not run, a tool it needs is missing, or the output was cut. An unmeasured
+ * tree is reported as unmeasured, never as unchanged.
+ *
+ * @category conversions
+ * @since 1.0.0
+ */
+export declare const parse: (stdout: string) => Measurement | undefined;
+/**
+ * Whether two measurements say the tree moved, or nothing at all.
+ *
+ * `true` and `false` are answers; `undefined` is the honest reading whenever
+ * either measurement is absent or bounded, because a prefix that held still
+ * is not a tree that held still.
+ *
+ * @category conversions
+ * @since 1.0.0
+ */
+export declare const moved: (before: Measurement | undefined, after: Measurement | undefined) => boolean | undefined;
+//# sourceMappingURL=TreeFingerprint.d.ts.map

package/dist/esm/TreeFingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeFingerprint.d.ts","sourceRoot":"","sources":["../../src/TreeFingerprint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAIH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,GAAG,YAAY,CAAA;AAE5B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,EAAE,aAAa,CAAC,MAAM,CAM9C,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,MAAM,CAUvD,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,QAAS,CAAA;AAE9B;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,0FAA0F;IAC1F,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAC3B;AAKD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,GAAI,UAAS;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;IAClD,QAAQ,CAAC,cAAc,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;CACvD,KAAG,MAaR,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,GAAI,QAAQ,MAAM,KAAG,WAAW,GAAG,SAapD,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,GAChB,QAAQ,WAAW,GAAG,SAAS,EAC/B,OAAO,WAAW,GAAG,SAAS,KAC7B,OAAO,GAAG,SAGuB,CAAA"}

package/dist/esm/TreeFingerprint.js

@@ -0,0 +1,170 @@
+/**
+ * The identity of one directory tree, measured where the tree is.
+ *
+ * `@smthrs/agent/WorkspaceObservation` measures the host workspace around
+ * every frame so the loop's mutation accounting is a fact rather than a
+ * claim. A command routed into a container writes to a filesystem that walk
+ * never sees: the SWE-bench rig bind-mounts the checkout into its container,
+ * so a container edit lands on the host too, but a container Harbor or Pier
+ * starts has no such mount, and every edit an agent made there read as an
+ * idle frame. Measured 2026-09-22 on Terminal-Bench 4.0: `read_only_cap`
+ * ended one run after twenty-four frames of container writes, and the claim
+ * judge refused another's completion as "work this run never recorded".
+ *
+ * This module is the same measurement taken inside the container: one POSIX
+ * shell script that lists every kept file under a directory with its size and
+ * modification time, in sorted order, and prints one checksum of the listing.
+ * `bash` runs it through the container transport before and after a
+ * containerised command and reports whether the two answers differ under the
+ * reserved {@link key}. The harness reads that key as a measured write, the
+ * way it reads `invalidProbe` as a measured refusal.
+ *
+ * The same properties as the host walk, and the same stated limits:
+ *
+ * - **Identity, not content.** Size and mtime per file; a rewrite that
+ *   restores both is invisible.
+ * - **Pruning is the signal.** {@link defaultPrune} and
+ *   {@link defaultIgnoreSuffixes} are the one list both measurements use, so
+ *   a derived artifact the host walk skips is skipped here too.
+ * - **A partial listing says so.** The listing stops at {@link maxPaths}, and
+ *   a measurement that stopped there reports `complete: false`; `bash` then
+ *   reports nothing rather than a guess.
+ * - **Every tool it needs is POSIX or busybox.** `find -prune`, `stat -c`,
+ *   `sort`, `head`, `cksum` and `grep -c` are in every Linux base image this
+ *   has been run against, GNU and busybox alike. A container that lacks one
+ *   answers with a non-zero exit, which is read as "unmeasured".
+ *
+ * @since 1.0.0
+ */
+import * as Prune from "./internal/Prune.js";
+/**
+ * The reserved output key a flow reports a measured write under.
+ *
+ * A wire contract with the harness rather than a shared type, exactly as
+ * `Probe.key` is: `@smthrs/harness` reads this key off a `Schema.Json` result
+ * and must not depend on the tool library to do it. `true` means the tree the
+ * call targeted differed after the call from before it; `false` means it was
+ * measured and held still; absent means it was not measured.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export const key = "mutated";
+/**
+ * Directory names never descended into.
+ *
+ * Every entry is a place a tool writes derived state while the run is working:
+ * version-control internals, dependency trees, and the caches Python, Node,
+ * Rust and their test runners keep beside the sources. A run that changes only
+ * these has changed nothing it will be judged on.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export const defaultPrune = [
+    ...Prune.repositoryDirectories,
+    // Build and environment directories a search still reads, since a project
+    // may keep sources under these names, but a measurement leaves out.
+    "venv",
+    "target"
+];
+/**
+ * File and directory name suffixes left out of a measurement.
+ *
+ * Compiled output is the case that matters: several SWE-bench projects build
+ * extensions in place, which drops `.so` files next to the `.py` files they
+ * came from. Those move whenever the run executes its test suite, and
+ * counting them would report every probe as an edit.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export const defaultIgnoreSuffixes = [
+    ".pyc",
+    ".pyo",
+    ".pyd",
+    ".so",
+    ".o",
+    ".a",
+    ".dylib",
+    ".class",
+    ".egg-info"
+];
+/**
+ * The largest number of files one measurement covers.
+ *
+ * The same bound the host walk uses, for the same reason: a listing that
+ * stopped here covers a prefix chosen by sort order, and a prefix holding
+ * still says nothing about the files being edited outside it.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export const maxPaths = 50_000;
+/** One name, single-quoted for a POSIX shell. Every name here is a constant without quotes in it. */
+const quoted = (name) => `'${name.replaceAll("'", `'\\''`)}'`;
+/**
+ * The POSIX shell script that measures the current directory.
+ *
+ * Prints two lines: `cksum`'s `<crc> <bytes>` over the sorted listing, then
+ * the number of listing lines. The listing is capped one past
+ * {@link maxPaths} so the count alone says whether the bound was reached.
+ * Errors from `find` and `stat` are discarded: a path that vanished mid-walk
+ * is movement the next measurement reports, and a file the shell may not
+ * stat is one it could not have measured either way.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export const script = (options = {}) => {
+    const prune = (options.prune ?? defaultPrune).map((name) => `-name ${quoted(name)}`).join(" -o ");
+    const skipped = (options.ignoreSuffixes ?? defaultIgnoreSuffixes)
+        .map((suffix) => `! -name ${quoted(`*${suffix}`)}`)
+        .join(" ");
+    return [
+        "set -f",
+        `L=$(find . -xdev \\( ${prune} \\) -prune -o -type f ${skipped} -exec stat -c '%s %Y %n' {} + 2>/dev/null | LC_ALL=C sort | head -n ${maxPaths + 1})`,
+        `printf '%s' "$L" | cksum`,
+        `printf '%s' "$L" | grep -c ''`
+    ].join("\n");
+};
+/**
+ * Reads one measurement off the script's standard output.
+ *
+ * `undefined` for anything that is not two well-formed lines: the script did
+ * not run, a tool it needs is missing, or the output was cut. An unmeasured
+ * tree is reported as unmeasured, never as unchanged.
+ *
+ * @category conversions
+ * @since 1.0.0
+ */
+export const parse = (stdout) => {
+    const lines = stdout.trim().split("\n").map((line) => line.trim());
+    if (lines.length !== 2)
+        return undefined;
+    const checksum = /^(\d+) (\d+)$/.exec(lines[0]);
+    const count = /^(\d+)$/.exec(lines[1]);
+    if (checksum === null || count === null)
+        return undefined;
+    const paths = Number(count[1]);
+    const bounded = paths > maxPaths;
+    return {
+        digest: `${checksum[1]}:${checksum[2]}`,
+        paths: bounded ? maxPaths : paths,
+        complete: !bounded
+    };
+};
+/**
+ * Whether two measurements say the tree moved, or nothing at all.
+ *
+ * `true` and `false` are answers; `undefined` is the honest reading whenever
+ * either measurement is absent or bounded, because a prefix that held still
+ * is not a tree that held still.
+ *
+ * @category conversions
+ * @since 1.0.0
+ */
+export const moved = (before, after) => before === undefined || after === undefined || !before.complete || !after.complete
+    ? undefined
+    : before.digest !== after.digest;
+//# sourceMappingURL=TreeFingerprint.js.map

package/dist/esm/TreeFingerprint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeFingerprint.js","sourceRoot":"","sources":["../../src/TreeFingerprint.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The identity of one directory tree, measured where the tree is.\n *\n * `@smthrs/agent/WorkspaceObservation` measures the host workspace around\n * every frame so the loop's mutation accounting is a fact rather than a\n * claim. A command routed into a container writes to a filesystem that walk\n * never sees: the SWE-bench rig bind-mounts the checkout into its container,\n * so a container edit lands on the host too, but a container Harbor or Pier\n * starts has no such mount, and every edit an agent made there read as an\n * idle frame. Measured 2026-09-22 on Terminal-Bench 4.0: `read_only_cap`\n * ended one run after twenty-four frames of container writes, and the claim\n * judge refused another's completion as \"work this run never recorded\".\n *\n * This module is the same measurement taken inside the container: one POSIX\n * shell script that lists every kept file under a directory with its size and\n * modification time, in sorted order, and prints one checksum of the listing.\n * `bash` runs it through the container transport before and after a\n * containerised command and reports whether the two answers differ under the\n * reserved {@link key}. The harness reads that key as a measured write, the\n * way it reads `invalidProbe` as a measured refusal.\n *\n * The same properties as the host walk, and the same stated limits:\n *\n * - **Identity, not content.** Size and mtime per file; a rewrite that\n *   restores both is invisible.\n * - **Pruning is the signal.** {@link defaultPrune} and\n *   {@link defaultIgnoreSuffixes} are the one list both measurements use, so\n *   a derived artifact the host walk skips is skipped here too.\n * - **A partial listing says so.** The listing stops at {@link maxPaths}, and\n *   a measurement that stopped there reports `complete: false`; `bash` then\n *   reports nothing rather than a guess.\n * - **Every tool it needs is POSIX or busybox.** `find -prune`, `stat -c`,\n *   `sort`, `head`, `cksum` and `grep -c` are in every Linux base image this\n *   has been run against, GNU and busybox alike. A container that lacks one\n *   answers with a non-zero exit, which is read as \"unmeasured\".\n *\n * @since 1.0.0\n */\n\nimport * as Prune from \"./internal/Prune.ts\"\n\n/**\n * The reserved output key a flow reports a measured write under.\n *\n * A wire contract with the harness rather than a shared type, exactly as\n * `Probe.key` is: `@smthrs/harness` reads this key off a `Schema.Json` result\n * and must not depend on the tool library to do it. `true` means the tree the\n * call targeted differed after the call from before it; `false` means it was\n * measured and held still; absent means it was not measured.\n *\n * @category identifiers\n * @since 1.0.0\n */\nexport const key = \"mutated\"\n\n/**\n * Directory names never descended into.\n *\n * Every entry is a place a tool writes derived state while the run is working:\n * version-control internals, dependency trees, and the caches Python, Node,\n * Rust and their test runners keep beside the sources. A run that changes only\n * these has changed nothing it will be judged on.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const defaultPrune: ReadonlyArray<string> = [\n  ...Prune.repositoryDirectories,\n  // Build and environment directories a search still reads, since a project\n  // may keep sources under these names, but a measurement leaves out.\n  \"venv\",\n  \"target\"\n]\n\n/**\n * File and directory name suffixes left out of a measurement.\n *\n * Compiled output is the case that matters: several SWE-bench projects build\n * extensions in place, which drops `.so` files next to the `.py` files they\n * came from. Those move whenever the run executes its test suite, and\n * counting them would report every probe as an edit.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const defaultIgnoreSuffixes: ReadonlyArray<string> = [\n  \".pyc\",\n  \".pyo\",\n  \".pyd\",\n  \".so\",\n  \".o\",\n  \".a\",\n  \".dylib\",\n  \".class\",\n  \".egg-info\"\n]\n\n/**\n * The largest number of files one measurement covers.\n *\n * The same bound the host walk uses, for the same reason: a listing that\n * stopped here covers a prefix chosen by sort order, and a prefix holding\n * still says nothing about the files being edited outside it.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const maxPaths = 50_000\n\n/**\n * One measurement, as {@link parse} reads it off the script's output.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Measurement {\n  /** The checksum of the whole listing; equal for two measurements of an unchanged tree. */\n  readonly digest: string\n  /** How many files the listing covered. */\n  readonly paths: number\n  /** Whether the listing covered the whole tree rather than a bounded prefix. */\n  readonly complete: boolean\n}\n\n/** One name, single-quoted for a POSIX shell. Every name here is a constant without quotes in it. */\nconst quoted = (name: string): string => `'${name.replaceAll(\"'\", `'\\\\''`)}'`\n\n/**\n * The POSIX shell script that measures the current directory.\n *\n * Prints two lines: `cksum`'s `<crc> <bytes>` over the sorted listing, then\n * the number of listing lines. The listing is capped one past\n * {@link maxPaths} so the count alone says whether the bound was reached.\n * Errors from `find` and `stat` are discarded: a path that vanished mid-walk\n * is movement the next measurement reports, and a file the shell may not\n * stat is one it could not have measured either way.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const script = (options: {\n  readonly prune?: ReadonlyArray<string> | undefined\n  readonly ignoreSuffixes?: ReadonlyArray<string> | undefined\n} = {}): string => {\n  const prune = (options.prune ?? defaultPrune).map((name) => `-name ${quoted(name)}`).join(\" -o \")\n  const skipped = (options.ignoreSuffixes ?? defaultIgnoreSuffixes)\n    .map((suffix) => `! -name ${quoted(`*${suffix}`)}`)\n    .join(\" \")\n  return [\n    \"set -f\",\n    `L=$(find . -xdev \\\\( ${prune} \\\\) -prune -o -type f ${skipped} -exec stat -c '%s %Y %n' {} + 2>/dev/null | LC_ALL=C sort | head -n ${\n      maxPaths + 1\n    })`,\n    `printf '%s' \"$L\" | cksum`,\n    `printf '%s' \"$L\" | grep -c ''`\n  ].join(\"\\n\")\n}\n\n/**\n * Reads one measurement off the script's standard output.\n *\n * `undefined` for anything that is not two well-formed lines: the script did\n * not run, a tool it needs is missing, or the output was cut. An unmeasured\n * tree is reported as unmeasured, never as unchanged.\n *\n * @category conversions\n * @since 1.0.0\n */\nexport const parse = (stdout: string): Measurement | undefined => {\n  const lines = stdout.trim().split(\"\\n\").map((line) => line.trim())\n  if (lines.length !== 2) return undefined\n  const checksum = /^(\\d+) (\\d+)$/.exec(lines[0]!)\n  const count = /^(\\d+)$/.exec(lines[1]!)\n  if (checksum === null || count === null) return undefined\n  const paths = Number(count[1])\n  const bounded = paths > maxPaths\n  return {\n    digest: `${checksum[1]}:${checksum[2]}`,\n    paths: bounded ? maxPaths : paths,\n    complete: !bounded\n  }\n}\n\n/**\n * Whether two measurements say the tree moved, or nothing at all.\n *\n * `true` and `false` are answers; `undefined` is the honest reading whenever\n * either measurement is absent or bounded, because a prefix that held still\n * is not a tree that held still.\n *\n * @category conversions\n * @since 1.0.0\n */\nexport const moved = (\n  before: Measurement | undefined,\n  after: Measurement | undefined\n): boolean | undefined =>\n  before === undefined || after === undefined || !before.complete || !after.complete\n    ? undefined\n    : before.digest !== after.digest\n"]}