project-tiny-context-harness 0.8.12 → 0.8.16

package/dist/lib/long-task-execution-observation.js

@@ -0,0 +1,332 @@
+import { chmod, copyFile, mkdir, mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createJsonPointerExactBudget } from "./long-task-json-pointer-observation.js";
+import { matchesRepoPattern } from "./long-task-paths.js";
+import { StaticObservationFreezeError, createObservationInputFreezeBudget, freezeObservationInputFile, freezeStaticObservationCarrier, } from "./long-task-static-observation-freeze.js";
+const PROCESS_INPUT_FREEZE_LIMITS = Object.freeze({
+    max_artifacts: 4_096,
+    max_file_bytes: 268_435_456,
+    max_total_artifact_bytes: 536_870_912,
+});
+function createProcessInputFreezeBudget() {
+    return createObservationInputFreezeBudget({
+        max_artifacts: PROCESS_INPUT_FREEZE_LIMITS.max_artifacts,
+        max_total_artifact_bytes: PROCESS_INPUT_FREEZE_LIMITS.max_total_artifact_bytes,
+    });
+}
+/**
+ * Freezes every selected Raw Execution group's observation inputs before the
+ * caller is allowed to start any runner. Keeping this as one owner prevents a
+ * prior execution from priming a later group's supposedly pre-run carrier.
+ */
+export async function prepareExecutionObservationUniverse(input) {
+    const prepared = [];
+    const processInputBudget = createProcessInputFreezeBudget();
+    for (const checks of input.groups)
+        prepared.push(await prepareExecutionObservationGroupWithBudget({
+            checks,
+            snapshot_root: input.snapshot_root,
+            workspace_manifest: input.workspace_manifest,
+            protected_authority_paths: input.protected_authority_paths,
+            process_input_budget: processInputBudget,
+        }));
+    return prepared;
+}
+export async function prepareExecutionObservationGroup(input) {
+    return prepareExecutionObservationGroupWithBudget({
+        ...input,
+        process_input_budget: createProcessInputFreezeBudget(),
+    });
+}
+async function prepareExecutionObservationGroupWithBudget(input) {
+    if (!input.checks.length)
+        throw new Error("execution_observation_check_group_required");
+    const rawIdentity = input.checks[0].raw_execution_identity;
+    if (input.checks.some((check) => check.raw_execution_identity !== rawIdentity))
+        throw new Error("execution_observation_raw_identity_mismatch");
+    const states = authorityCarrierStates(input.checks, input.workspace_manifest);
+    const groups = observationCarrierGroups(states);
+    const exactBudget = createJsonPointerExactBudget();
+    const processInputBudget = input.process_input_budget;
+    const processExecution = states.some((state) => state.authority.authority === "package_process_json_exact");
+    const executionRoot = processExecution
+        ? await mkdtemp(path.join(os.tmpdir(), "ty-context-process-snapshot-"))
+        : input.snapshot_root;
+    if (processExecution)
+        await mkdir(path.resolve(executionRoot, input.checks[0].runner.resolved_cwd), { recursive: true });
+    for (const group of groups) {
+        if ((input.protected_authority_paths ?? []).some((pattern) => matchesRepoPattern(group.artifact_path, pattern))) {
+            for (const state of group.authority_states)
+                recordAuthorityFailure(state, "observation_expected_authority_forbidden");
+            continue;
+        }
+        try {
+            const includesStaticAuthority = group.authority_states.some((state) => state.authority.authority === "package_static_json_exact");
+            const includesProcessAuthority = group.authority_states.some((state) => state.authority.authority === "package_process_json_exact");
+            let sourceIdentity = null;
+            if (processExecution) {
+                const sourceFrozen = await freezeObservationInputFile({
+                    snapshot_root: input.snapshot_root,
+                    workspace_manifest: input.workspace_manifest,
+                    artifact_path: group.artifact_path,
+                    max_file_bytes: PROCESS_INPUT_FREEZE_LIMITS.max_file_bytes,
+                    budget: processInputBudget,
+                });
+                try {
+                    const target = path.resolve(executionRoot, ...group.artifact_path.split("/"));
+                    await mkdir(path.dirname(target), { recursive: true });
+                    await copyFile(path.resolve(input.snapshot_root, ...group.artifact_path.split("/")), target);
+                    const verifiedSource = await sourceFrozen.verifyPostRun();
+                    sourceIdentity = verifiedSource.pre_run_identity;
+                    await chmod(target, sourceIdentity.mode & 0o777);
+                }
+                finally {
+                    sourceFrozen.dispose();
+                }
+            }
+            group.frozen = includesStaticAuthority
+                ? await freezeStaticObservationCarrier({
+                    snapshot_root: executionRoot,
+                    workspace_manifest: input.workspace_manifest,
+                    artifact_path: group.artifact_path,
+                    budget: exactBudget,
+                    input_freeze_budget: includesProcessAuthority
+                        ? processInputBudget
+                        : undefined,
+                })
+                : await freezeObservationInputFile({
+                    snapshot_root: executionRoot,
+                    workspace_manifest: input.workspace_manifest,
+                    artifact_path: group.artifact_path,
+                    max_file_bytes: PROCESS_INPUT_FREEZE_LIMITS.max_file_bytes,
+                    budget: processInputBudget,
+                });
+            if (sourceIdentity &&
+                (group.frozen.pre_run_identity.content_sha256 !==
+                    sourceIdentity.content_sha256 ||
+                    group.frozen.pre_run_identity.size !== sourceIdentity.size))
+                throw new Error("process_observation_input_snapshot_copy_mismatch");
+        }
+        catch (error) {
+            const reason = observationFailureReason(error);
+            for (const state of group.authority_states)
+                recordAuthorityFailure(state, reason);
+        }
+    }
+    const processAuthorities = states
+        .filter((state) => state.authority.authority === "package_process_json_exact")
+        .map((state) => state.authority);
+    const processRuntimeClosureIdentities = [
+        ...new Set(input.checks
+            .filter((check) => (check.observation_authorities ?? []).some((authority) => authority.authority === "package_process_json_exact"))
+            .map((check) => check.process_runtime_closure?.closure_identity ?? null)),
+    ];
+    if (processExecution &&
+        (processRuntimeClosureIdentities.length !== 1 ||
+            processRuntimeClosureIdentities[0] === null))
+        throw new Error("process_runtime_closure_identity_mismatch");
+    let disposed = false;
+    const dispose = async () => {
+        if (disposed)
+            return;
+        disposed = true;
+        for (const group of groups)
+            group.frozen?.dispose();
+        if (processExecution)
+            await rm(executionRoot, { recursive: true, force: true });
+    };
+    return {
+        execution_root: executionRoot,
+        runner_context: {
+            snapshot_sha256: input.workspace_manifest.snapshot_sha256,
+            observation_authorities: processAuthorities,
+            ...(processExecution
+                ? {
+                    process_runtime_closure_identity: processRuntimeClosureIdentities[0],
+                }
+                : {}),
+        },
+        finalize: async (raw) => {
+            try {
+                const verified = new Map();
+                for (const group of groups) {
+                    if (!group.frozen)
+                        continue;
+                    try {
+                        verified.set(group.artifact_path, await group.frozen.verifyPostRun());
+                    }
+                    catch (error) {
+                        const reason = observationFailureReason(error);
+                        for (const state of group.authority_states)
+                            recordAuthorityFailure(state, reason);
+                    }
+                }
+                return {
+                    ...raw,
+                    package_observations: finalizePackageObservations(states, verified, raw.package_observations ?? [], exactBudget),
+                };
+            }
+            finally {
+                await dispose();
+            }
+        },
+        dispose,
+    };
+}
+function authorityCarrierStates(checks, manifest) {
+    const states = [];
+    for (const check of checks)
+        for (const authority of check.observation_authorities ?? []) {
+            if (authority.authority !== "package_static_json_exact" &&
+                authority.authority !== "package_process_json_exact")
+                continue;
+            const state = {
+                check,
+                authority: authority,
+                artifact_paths: [],
+                reason: null,
+            };
+            const carrierPatterns = authority.carrier_refs.flatMap((carrier) => carrier.carrier_paths);
+            addPatternClosure(state, manifest, carrierPatterns);
+            if (authority.authority === "package_process_json_exact") {
+                const closure = check.process_runtime_closure;
+                if (!closure)
+                    recordAuthorityFailure(state, "process_runtime_closure_identity_mismatch");
+                else
+                    state.artifact_paths.push(...closure.allowed_runtime_files);
+            }
+            state.artifact_paths = [...new Set(state.artifact_paths)].sort();
+            if (authority.authority === "package_static_json_exact" &&
+                state.artifact_paths.length !== 1)
+                recordAuthorityFailure(state, "static_observation_manifest_invalid");
+            states.push(state);
+        }
+    return states;
+}
+function addPatternClosure(state, manifest, patterns) {
+    for (const pattern of new Set(patterns)) {
+        let matches;
+        try {
+            matches = manifest.files
+                .filter((file) => matchesRepoPattern(file.path, pattern))
+                .map((file) => file.path);
+        }
+        catch {
+            recordAuthorityFailure(state, "static_observation_manifest_invalid");
+            continue;
+        }
+        if (!matches.length) {
+            recordAuthorityFailure(state, "static_observation_not_in_pre_run_snapshot");
+            continue;
+        }
+        state.artifact_paths.push(...matches);
+    }
+}
+function observationCarrierGroups(states) {
+    const groups = new Map();
+    for (const state of states)
+        for (const artifactPath of state.artifact_paths) {
+            const existing = groups.get(artifactPath);
+            if (existing)
+                existing.authority_states.push(state);
+            else
+                groups.set(artifactPath, {
+                    artifact_path: artifactPath,
+                    authority_states: [state],
+                    frozen: null,
+                });
+        }
+    return [...groups.values()].sort((left, right) => left.artifact_path.localeCompare(right.artifact_path));
+}
+function finalizePackageObservations(states, verified, submitted, budget) {
+    const processStates = states.filter((state) => state.authority.authority === "package_process_json_exact");
+    const observations = submitted.filter((candidate) => {
+        const matching = processStates.filter((state) => packageObservationMatchesAuthority(candidate, state.authority));
+        return !matching.some((state) => state.reason !== null);
+    });
+    for (const state of processStates)
+        if (state.reason)
+            observations.push(failedObservation(state.authority, state.reason));
+    for (const state of states.filter((candidate) => candidate.authority.authority === "package_static_json_exact")) {
+        if (state.reason) {
+            observations.push(failedObservation(state.authority, state.reason));
+            continue;
+        }
+        const carrier = verified.get(state.artifact_paths[0]);
+        if (!carrier || !isVerifiedStaticObservationCarrier(carrier)) {
+            observations.push(failedObservation(state.authority, "static_observation_not_in_pre_run_snapshot"));
+            continue;
+        }
+        try {
+            const extracted = carrier.extractJsonPointerExactValue({
+                locator: {
+                    kind: "json_pointer",
+                    value: state.authority.locator_policy.value,
+                },
+                sensitivity: "plain",
+                budget,
+            });
+            observations.push({
+                authority: "package_static_json_exact",
+                observation_identity: state.authority.observation_identity,
+                assertion_ref: state.authority.assertion_ref,
+                obligation_ref: state.authority.obligation_ref,
+                method: state.authority.method,
+                raw_value: extracted.raw_value,
+                observation: extracted.observation,
+                reason: null,
+            });
+        }
+        catch (error) {
+            observations.push(failedObservation(state.authority, observationFailureReason(error)));
+        }
+    }
+    return observations;
+}
+function isVerifiedStaticObservationCarrier(value) {
+    return "extractJsonPointerExactValue" in value;
+}
+function packageObservationMatchesAuthority(observation, authority) {
+    return (observation.authority === authority.authority &&
+        observation.observation_identity === authority.observation_identity &&
+        observation.assertion_ref === authority.assertion_ref &&
+        observation.obligation_ref === authority.obligation_ref &&
+        observation.method === authority.method);
+}
+function failedObservation(authority, reason) {
+    return {
+        authority: authority.authority,
+        observation_identity: authority.observation_identity,
+        assertion_ref: authority.assertion_ref,
+        obligation_ref: authority.obligation_ref,
+        method: authority.method,
+        raw_value: undefined,
+        observation: null,
+        reason,
+    };
+}
+function recordAuthorityFailure(state, reason) {
+    if (state.reason)
+        return;
+    state.reason =
+        state.authority.authority === "package_process_json_exact"
+            ? processInputFailureReason(reason)
+            : reason;
+}
+function processInputFailureReason(reason) {
+    if (reason === "observation_expected_authority_forbidden")
+        return reason;
+    if (reason === "process_runtime_closure_identity_mismatch")
+        return reason;
+    if (reason.startsWith("process_observation_input_"))
+        return reason;
+    if (reason.startsWith("static_observation_"))
+        return `process_observation_input_${reason.slice("static_observation_".length)}`;
+    return "process_observation_input_freeze_invalid";
+}
+function observationFailureReason(error) {
+    if (error instanceof StaticObservationFreezeError)
+        return error.code;
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/long-task-explain-acceptance-link.d.ts

@@ -21,12 +21,16 @@ export declare function explainAcceptanceLinks(contract: DeliveryContractV2, cov
         binding_ref: string;
         owning_outcome_key: string;
         expected_assertion_failures: string[];
+        preserved_assertions: string[];
+        allowed_fanout_assertions: string[];
     }[] | {
         key: string;
         claims: string[];
         binding_key: string;
         owning_outcome_key: string | null;
         expected_assertion_failures: string[];
+        preserved_assertions: string[];
+        allowed_fanout_assertions: string[];
     }[];
 } | {
     type: string;

package/dist/lib/long-task-explain-acceptance-link.js

@@ -81,6 +81,8 @@ function acceptanceCounterfactuals(contract, scope, outcomeKey, checkKey, assert
             binding_ref: control.binding_ref,
             owning_outcome_key: control.binding_ref.split(".")[0],
             expected_assertion_failures: control.expected_assertion_failures,
+            preserved_assertions: control.preserved_assertions,
+            allowed_fanout_assertions: control.allowed_fanout_assertions,
         }));
     const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
     return (outcome?.acceptance.counterfactual_controls ?? [])
@@ -92,5 +94,7 @@ function acceptanceCounterfactuals(contract, scope, outcomeKey, checkKey, assert
         binding_key: control.binding_key,
         owning_outcome_key: outcomeKey,
         expected_assertion_failures: control.expected_assertion_failures,
+        preserved_assertions: control.preserved_assertions,
+        allowed_fanout_assertions: control.allowed_fanout_assertions,
     }));
 }

package/dist/lib/long-task-explain-claim-links.d.ts

@@ -39,6 +39,8 @@ export declare function explainGlobalClaimLinks(contract: DeliveryContractV2, co
         owner_paths: string[];
         carrier_paths: string[];
         expected_assertion_failures: string[];
+        preserved_assertions: string[];
+        allowed_fanout_assertions: string[];
         mutation: import("./long-task-counterfactual-types.js").CounterfactualMutationV2;
     }[];
 }[];

package/dist/lib/long-task-explain-claim-links.js

@@ -58,6 +58,8 @@ export function explainGlobalClaimLinks(contract, coverage, disposition) {
                     owner_paths: outcome?.product.owner.path_globs ?? [],
                     carrier_paths: binding?.carrier_paths ?? [],
                     expected_assertion_failures: control.expected_assertion_failures,
+                    preserved_assertions: control.preserved_assertions,
+                    allowed_fanout_assertions: control.allowed_fanout_assertions,
                     mutation: control.mutation,
                 };
             }),

package/dist/lib/long-task-explain-source-links.d.ts

@@ -21,12 +21,16 @@ export declare function explainSourceLinks(contract: DeliveryContractV2, coverag
         binding_ref: string;
         owning_outcome_key: string;
         expected_assertion_failures: string[];
+        preserved_assertions: string[];
+        allowed_fanout_assertions: string[];
     }[] | {
         key: string;
         claims: string[];
         binding_key: string;
         owning_outcome_key: string | null;
         expected_assertion_failures: string[];
+        preserved_assertions: string[];
+        allowed_fanout_assertions: string[];
     }[];
     canonical_target: import("./long-task-source-target-index.js").CanonicalSourceTarget | null;
 } | {
@@ -75,6 +79,8 @@ export declare function explainSourceLinks(contract: DeliveryContractV2, coverag
         owner_paths: string[];
         carrier_paths: string[];
         expected_assertion_failures: string[];
+        preserved_assertions: string[];
+        allowed_fanout_assertions: string[];
         mutation: import("./long-task-counterfactual-types.js").CounterfactualMutationV2;
     }[];
     canonical_target: import("./long-task-source-target-index.js").CanonicalSourceTarget | null;

package/dist/lib/long-task-final-v2.js

@@ -1,4 +1,5 @@
 import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
+import { outcomeResultExternallyBlocked } from "./long-task-claims.js";
 import { captureFinalGateProtectedInputIdentity, finalGateIntegrityFindings, } from "./long-task-final-integrity.js";
 import { assertMatchingActiveBinding, loadActiveLongTaskAuthority, writeFinalReceipt, } from "./long-task-state.js";
 import { assertVerifierAuthorityCurrent, deliveryCompileFreshness, } from "./long-task-freshness.js";
@@ -47,7 +48,7 @@ export async function runDeliveryFinalGate(workdirInput) {
             workspace_identity_before: before.identity,
             protected_inputs_before: protectedInputsBefore,
         })));
-        const outcomeResults = projectOutcomes(compiled.outcomes.map((outcome) => outcome.key), run.check_results, run.findings);
+        const outcomeResults = projectOutcomes(compiled, run.check_results, run.findings);
         const globalChecks = run.check_results.filter((check) => check.outcome_key === null);
         const globalHardFailure = globalChecks.some((check) => check.status !== "passed" && check.status !== "blocked_external");
         const globalBlocked = globalChecks.some((check) => check.status === "blocked_external");
@@ -131,13 +132,15 @@ function projectStages(compiled, outcomes) {
     }
     return result;
 }
-function projectOutcomes(outcomeKeys, checks, findings) {
-    return Object.fromEntries(outcomeKeys.map((outcomeKey) => {
+function projectOutcomes(compiled, checks, findings) {
+    return Object.fromEntries(compiled.outcomes.map((outcome) => {
+        const outcomeKey = outcome.key;
         const owned = checks.filter((check) => check.outcome_key === outcomeKey);
         const ownFindings = findings.filter((finding) => finding.outcome_key === outcomeKey || finding.outcome_key === null);
         const status = owned.some((check) => check.status !== "passed" && check.status !== "blocked_external") || ownFindings.some((finding) => finding.code !== "blocked_external")
             ? "failed"
-            : owned.some((check) => check.status === "blocked_external")
+            : outcomeResultExternallyBlocked(compiled, outcomeKey) ||
+                owned.some((check) => check.status === "blocked_external")
                 ? "blocked_external"
                 : "passed";
         return [outcomeKey, status];

package/dist/lib/long-task-git.d.ts

@@ -0,0 +1,26 @@
+export declare class GitCommandError extends Error {
+    readonly exitCode: number | null;
+    readonly signal: NodeJS.Signals | null;
+    readonly stdoutBytes: number;
+    readonly stderrBytes: number;
+    constructor(exitCode: number | null, signal: NodeJS.Signals | null, argv: string[], stdout: Buffer, stderr: Buffer);
+}
+export declare function repositoryRoot(start: string): Promise<string>;
+export declare function gitCommonDir(root: string): Promise<string>;
+export declare function currentGitState(root: string): Promise<{
+    head: string;
+    tree: string;
+    dirty: string[];
+}>;
+export declare function currentGitTree(root: string): Promise<string>;
+export declare function gitPath(root: string, pathSpec: string): Promise<string>;
+export declare function gitConfigGet(root: string, name: string): Promise<string | null>;
+export declare function gitEffectiveConfigGet(root: string, name: string): Promise<string | null>;
+export declare function gitConfigSet(root: string, name: string, value: string): Promise<void>;
+export declare function gitConfigUnset(root: string, name: string): Promise<void>;
+export declare function repoRelative(rootInput: string, fileInput: string): string;
+export declare function gitOutput(root: string, argv: string[]): Promise<string>;
+export declare function gitVoid(root: string, argv: string[]): Promise<void>;
+export declare function gitBuffer(root: string, argv: string[]): Promise<Buffer>;
+export declare function gitBufferInput(root: string, argv: string[], input?: Buffer): Promise<Buffer>;
+export declare function splitGitZero(value: Buffer): string[];

package/dist/lib/long-task-git.js

@@ -0,0 +1,130 @@
+import { spawn } from "node:child_process";
+import { stat } from "node:fs/promises";
+import path from "node:path";
+export class GitCommandError extends Error {
+    exitCode;
+    signal;
+    stdoutBytes;
+    stderrBytes;
+    constructor(exitCode, signal, argv, stdout, stderr) {
+        const stderrText = stderr.toString("utf8").trim();
+        super(`git_exit:${exitCode ?? "null"}:${argv.join(" ")}:signal=${signal ?? "none"}:stdout_bytes=${stdout.length}:stderr=${stderrText}`);
+        this.name = "GitCommandError";
+        this.exitCode = exitCode;
+        this.signal = signal;
+        this.stdoutBytes = stdout.length;
+        this.stderrBytes = stderr.length;
+    }
+}
+export async function repositoryRoot(start) {
+    const resolved = path.resolve(start);
+    const gitEntry = await stat(path.join(resolved, ".git")).catch(() => null);
+    if (gitEntry?.isDirectory() || gitEntry?.isFile())
+        return resolved;
+    return path.resolve(await gitOutput(resolved, ["rev-parse", "--show-toplevel"]));
+}
+export async function gitCommonDir(root) {
+    return path.resolve(await gitOutput(root, [
+        "rev-parse",
+        "--path-format=absolute",
+        "--git-common-dir",
+    ]));
+}
+export async function currentGitState(root) {
+    const [head, tree, raw] = await Promise.all([
+        gitOutput(root, ["rev-parse", "HEAD"]),
+        gitOutput(root, ["rev-parse", "HEAD^{tree}"]),
+        gitOutput(root, ["status", "--short", "--untracked-files=all"]),
+    ]);
+    return {
+        head,
+        tree,
+        dirty: raw ? raw.split(/\r?\n/u).filter(Boolean) : [],
+    };
+}
+export async function currentGitTree(root) {
+    return gitOutput(root, ["rev-parse", "HEAD^{tree}"]);
+}
+export async function gitPath(root, pathSpec) {
+    return path.resolve(await gitOutput(root, [
+        "rev-parse",
+        "--path-format=absolute",
+        "--git-path",
+        pathSpec,
+    ]));
+}
+export async function gitConfigGet(root, name) {
+    try {
+        return await gitOutput(root, ["config", "--local", "--get", name]);
+    }
+    catch (error) {
+        if (error instanceof GitCommandError && error.exitCode === 1)
+            return null;
+        throw error;
+    }
+}
+export async function gitEffectiveConfigGet(root, name) {
+    try {
+        return await gitOutput(root, ["config", "--get", name]);
+    }
+    catch (error) {
+        if (error instanceof GitCommandError && error.exitCode === 1)
+            return null;
+        throw error;
+    }
+}
+export async function gitConfigSet(root, name, value) {
+    await gitVoid(root, ["config", "--local", name, value]);
+}
+export async function gitConfigUnset(root, name) {
+    try {
+        await gitVoid(root, ["config", "--local", "--unset-all", name]);
+    }
+    catch (error) {
+        if (!(error instanceof GitCommandError) || error.exitCode !== 5)
+            throw error;
+    }
+}
+export function repoRelative(rootInput, fileInput) {
+    const value = path
+        .relative(path.resolve(rootInput), path.resolve(fileInput))
+        .replace(/\\/gu, "/");
+    if (value.startsWith("../") || path.isAbsolute(value))
+        throw new Error(`path_outside_repository:${fileInput}`);
+    return value;
+}
+export async function gitOutput(root, argv) {
+    return (await gitBuffer(root, argv)).toString("utf8").trim();
+}
+export async function gitVoid(root, argv) {
+    await gitBuffer(root, argv);
+}
+export async function gitBuffer(root, argv) {
+    return gitBufferInput(root, argv);
+}
+export async function gitBufferInput(root, argv, input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("git", argv, {
+            cwd: root,
+            shell: false,
+            windowsHide: true,
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", reject);
+        child.stdin.end(input);
+        child.on("close", (code, signal) => {
+            const stdoutBytes = Buffer.concat(stdout);
+            const stderrBytes = Buffer.concat(stderr);
+            if (code === 0)
+                resolve(stdoutBytes);
+            else
+                reject(new GitCommandError(code, signal, argv, stdoutBytes, stderrBytes));
+        });
+    });
+}
+export function splitGitZero(value) {
+    return value.toString("utf8").split("\0").filter(Boolean);
+}

package/dist/lib/long-task-json-pointer-observation.d.ts

@@ -0,0 +1,59 @@
+export declare const JSON_POINTER_EXACT_CAPABILITY = "json-pointer-exact-v1";
+export declare const JSON_POINTER_EXACT_ORACLE_IDENTITY = "ty-context-json-pointer-exact";
+export declare const JSON_POINTER_EXACT_ORACLE_VERSION = "1.0.0";
+export declare const JSON_POINTER_EXACT_METHODS: readonly ["exact_value", "content", "component_state"];
+export declare const JSON_POINTER_EXACT_LIMITS: Readonly<{
+    max_file_bytes: 1048576;
+    max_depth: 64;
+    max_pointer_bytes: 4096;
+    max_pointer_segments: 128;
+    max_canonical_value_bytes: 262144;
+    max_artifacts_per_check: 256;
+    max_total_artifact_bytes: 16777216;
+}>;
+export declare const JSON_POINTER_EXACT_SPEC_SHA256: string;
+export interface JsonPointerExactBudget {
+    readonly seen_artifact_paths: Set<string>;
+    total_artifact_bytes: number;
+}
+export interface JsonPointerExactLocator {
+    kind: string;
+    value: string;
+}
+export interface JsonPointerExactObservation {
+    capability: typeof JSON_POINTER_EXACT_CAPABILITY;
+    artifact_path: string;
+    artifact_sha256: string;
+    locator: {
+        kind: "json_pointer";
+        value: string;
+    };
+    value_sha256: string;
+    canonical_value_bytes: number;
+    sensitivity: "plain";
+}
+export declare function createJsonPointerExactBudget(): JsonPointerExactBudget;
+export declare function isJsonPointerExactOracle(oracle: {
+    trust?: string;
+    identity?: string;
+    version?: string;
+    sha256?: string | null;
+}): boolean;
+export declare function extractJsonPointerExactObservationFromBytes(input: {
+    artifact_path: string;
+    bytes: Uint8Array;
+    locator: JsonPointerExactLocator;
+    sensitivity: string;
+    budget?: JsonPointerExactBudget;
+}): JsonPointerExactObservation;
+export declare function validateJsonPointerExactLocator(locator: JsonPointerExactLocator): {
+    kind: "json_pointer";
+    value: string;
+};
+export declare function normalizeObservationArtifactPath(value: string): string;
+export declare function invalidObservation(code: string): Error;
+export declare function observationErrorMessage(error: unknown): string;
+export declare function resolveJsonPointer(root: unknown, pointer: string): unknown;
+export declare function parseJsonWithoutDuplicateKeys(content: string): unknown;
+export declare function decodeUtf8Json(bytes: Uint8Array): string;
+export declare function assertJsonTree(value: unknown, depth: number): void;