@skill-harness/adapters 0.12.0 → 0.14.0

package/dist/execution-projection-schema.d.ts

@@ -0,0 +1,10 @@
+/** Read-model contract only. It cannot carry an acceptance or activation grant. */
+export declare const EXECUTION_ARCHIVE_PROJECTION_SCHEMA: {
+    type: string;
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+    $schema: string;
+    $id: string;
+};
+export declare function assertExecutionProjection(value: unknown): void;

package/dist/execution-projection-schema.js

@@ -0,0 +1,30 @@
+import { Compile } from "typebox/compile";
+const text = { type: "string", minLength: 1, maxLength: 512 };
+const hash = { type: "string", pattern: "^[a-f0-9]{64}$" };
+const nullable = (schema) => ({ anyOf: [schema, { type: "null" }] });
+const list = (items) => ({ type: "array", items, maxItems: 4096, uniqueItems: true });
+const closed = (properties) => ({ type: "object", properties, required: Object.keys(properties), additionalProperties: false });
+function freeze(value) { if (value && typeof value === "object") {
+    Object.values(value).forEach(freeze);
+    Object.freeze(value);
+} return value; }
+/** Read-model contract only. It cannot carry an acceptance or activation grant. */
+export const EXECUTION_ARCHIVE_PROJECTION_SCHEMA = freeze({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://github.com/mojomanyana/skill-harness/contracts/execution-archive/v1/projection.schema.json",
+    ...closed({ version: { const: "execution-archive-projection-v1" },
+        executions: { type: "array", maxItems: 4096, items: closed({
+                executionId: text, parentExecutionIds: list(nullable(text)), retainedSessionIds: list(text), activeBranch: { const: null },
+                toolCallIds: list(nullable(text)), archiveIds: list(text), runtime: { enum: ["running", "terminal", "conflict"] },
+                outcome: nullable(closed({ code: nullable({ type: "integer", minimum: -2147483648, maximum: 2147483647 }),
+                    signal: nullable(text), timedOut: { type: "boolean" }, aborted: { type: "boolean" }, truncated: { type: "boolean" }, failed: { type: "boolean" } })),
+                sourceReferences: list(hash), issues: list(text), coverage: { const: "partial" }, acceptance: { const: "not-assessed" },
+            }) }, acceptance: { const: "not-assessed" },
+    }),
+});
+const compiled = Compile(EXECUTION_ARCHIVE_PROJECTION_SCHEMA);
+export function assertExecutionProjection(value) {
+    if (!compiled.Check(value) || Buffer.byteLength(JSON.stringify(value)) > 8 * 1024 * 1024)
+        throw new Error("invalid or oversized execution archive projection");
+}
+//# sourceMappingURL=execution-projection-schema.js.map

package/dist/execution-retention-archive.d.ts

@@ -0,0 +1,69 @@
+import { RETENTION_CONTENT_KINDS } from "./generated/retention-v2-contract.js";
+import type { ExecutionRetentionManifest } from "./generated/retention-v2-types.js";
+export type RetentionContentKind = typeof RETENTION_CONTENT_KINDS[number];
+export interface RetentionProjection {
+    version: "retention-projection-v1";
+    sourceSha256: string;
+    producerCommit: string;
+    archiveId: string;
+    identity: ExecutionRetentionManifest["identity"];
+    runtime: "running" | "terminal";
+    outcome: ExecutionRetentionManifest["outcome"];
+    content: Record<RetentionContentKind, {
+        status: "available" | "missing" | "mismatch";
+        sha256: string | null;
+        bytes: number | null;
+    }>;
+    sessionId: string | null;
+    reportedBranch: {
+        state: "unknown" | "observed";
+        leafId: string | null;
+    };
+    activeBranch: null;
+    coverage: "partial";
+    issues: string[];
+    acceptance: "not-assessed";
+}
+/** Caller already owns an exact-content policy. No paths from the producer are opened here. */
+export declare function ingestRetainedExecution(root: string, input: {
+    manifest: Uint8Array;
+    blobs: ReadonlyMap<string, Uint8Array>;
+    retention: "exact";
+    sourceId?: string;
+}): {
+    snapshotId: string;
+    projection: RetentionProjection;
+};
+/** Recompute availability from current retained bytes; a deleted blob never inherits its old available status. */
+export declare function readRetainedExecution(root: string, snapshotId: string): {
+    snapshotId: string;
+    sourceId: string;
+    manifest: ExecutionRetentionManifest;
+    projection: RetentionProjection;
+};
+/** Order-independent joins, not an acceptance engine. Logical child names and native parents are not execution keys. */
+export declare function projectRetainedExecutions(snapshots: readonly RetentionProjection[]): {
+    version: "execution-archive-projection-v1";
+    executions: {
+        executionId: string;
+        parentExecutionIds: (string | null)[];
+        retainedSessionIds: string[];
+        activeBranch: null;
+        toolCallIds: (string | null)[];
+        archiveIds: string[];
+        runtime: string;
+        outcome: {
+            code: number | null;
+            signal: string | null;
+            timedOut: boolean;
+            aborted: boolean;
+            truncated: boolean;
+            failed: boolean;
+        } | null;
+        sourceReferences: string[];
+        issues: string[];
+        coverage: "partial";
+        acceptance: "not-assessed";
+    }[];
+    acceptance: "not-assessed";
+};

package/dist/execution-retention-archive.js

@@ -0,0 +1,154 @@
+import { createHash } from "node:crypto";
+import { parseExecutionRetentionManifest, RETENTION_CONTENT_KINDS } from "./generated/retention-v2-contract.js";
+import { parseNativeSessionBytes } from "./generated/retention-v2-native.js";
+import { RETENTION_V2_COMMIT } from "./generated/retention-v2-pin.js";
+import { retainArchiveSource, readArchiveSource } from "./evidence-archive.js";
+import { assertExecutionProjection } from "./execution-projection-schema.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const SHA = /^[a-f0-9]{64}$/;
+const parseManifest = (bytes) => parseExecutionRetentionManifest(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+function project(manifest, manifestBytes, supplied) {
+    const content = {};
+    const issues = [...manifest.coverage.losses];
+    for (const kind of RETENTION_CONTENT_KINDS) {
+        const ref = manifest.content[kind], bytes = ref.path ? supplied.get(ref.path) : undefined;
+        const status = ref.status === "missing" || bytes === undefined ? "missing"
+            : bytes instanceof Uint8Array && bytes.byteLength === ref.bytes && hash(bytes) === ref.sha256 ? "available" : "mismatch";
+        content[kind] = { status, sha256: status === "available" ? ref.sha256 : null, bytes: status === "available" ? ref.bytes : null };
+        if (status !== "available")
+            issues.push(`content-${status}:${kind}`);
+    }
+    let sessionId = null;
+    if (content.session.status === "available") {
+        const native = manifest.nativeSession;
+        if (!native.source || !native.sessionPath || !native.sessionId)
+            issues.push("native-session-locator-unavailable");
+        else {
+            const parsed = parseNativeSessionBytes(supplied.get(manifest.content.session.path), {
+                source: native.source, path: native.sessionPath, expectedSessionId: native.sessionId,
+                truncated: native.status === "truncated",
+                ...(native.branchState === "observed" ? { liveLeaf: { sessionId: native.sessionId, leafId: native.branchLeafId } } : {}),
+            });
+            // This checks retained format/chain consistency, never authenticates the manifest's live observation.
+            if (parsed.observation.status !== native.status || parsed.observation.sha256 !== native.sha256
+                || parsed.observation.lastPersistedEntryId !== native.lastPersistedEntryId)
+                issues.push("native-session-inconsistent");
+            else
+                sessionId = parsed.observation.sessionId;
+        }
+    }
+    if (manifest.nativeSession.branchState === "observed")
+        issues.push("active-branch-not-independently-verified");
+    return {
+        version: "retention-projection-v1", sourceSha256: hash(manifestBytes), producerCommit: RETENTION_V2_COMMIT,
+        archiveId: manifest.archiveId, identity: manifest.identity, runtime: manifest.state, outcome: manifest.outcome,
+        content, sessionId, reportedBranch: { state: manifest.nativeSession.branchState, leafId: manifest.nativeSession.branchLeafId },
+        activeBranch: null, coverage: "partial", issues: [...new Set(issues)].sort(), acceptance: "not-assessed",
+    };
+}
+/** Caller already owns an exact-content policy. No paths from the producer are opened here. */
+export function ingestRetainedExecution(root, input) {
+    if (input.retention !== "exact")
+        throw new Error("native semantic ingestion requires explicit exact-content policy; archive redacted/reference-only data as opaque evidence");
+    const bytes = Buffer.from(input.manifest);
+    const manifest = parseManifest(bytes);
+    for (const ref of Object.values(manifest.content)) {
+        const supplied = ref.path ? input.blobs.get(ref.path) : undefined;
+        if (supplied !== undefined && (!(supplied instanceof Uint8Array) || supplied.byteLength > 1024 * 1024))
+            throw new Error("retention blob exceeds input bounds");
+    }
+    const projection = project(manifest, bytes, input.blobs);
+    const source = retainArchiveSource(root, { sourceId: input.sourceId ?? `retention-${manifest.archiveId}`, parser: { id: "pi-daddy-execution-retention", version: "2.0" }, retention: "exact", bytes });
+    const blobs = {};
+    for (const kind of RETENTION_CONTENT_KINDS) {
+        blobs[kind] = null;
+        const ref = manifest.content[kind];
+        if (!ref.path || input.blobs.get(ref.path) === undefined)
+            continue;
+        // Preserve bounded mismatched bytes as forensic input; their presence never makes them valid evidence.
+        blobs[kind] = retainArchiveSource(root, { sourceId: `${manifest.archiveId}-${kind}`, parser: { id: "opaque-bytes", version: "1" }, retention: "exact", bytes: input.blobs.get(ref.path) }).manifestId;
+    }
+    const snapshot = { version: "retention-archive-snapshot-v1", producerCommit: RETENTION_V2_COMMIT, manifestId: source.manifestId, blobs };
+    const stored = retainArchiveSource(root, { sourceId: `execution-${manifest.archiveId}`, parser: { id: "retention-archive-snapshot", version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify(snapshot)) });
+    return { snapshotId: stored.manifestId, projection };
+}
+/** Recompute availability from current retained bytes; a deleted blob never inherits its old available status. */
+export function readRetainedExecution(root, snapshotId) {
+    const stored = readArchiveSource(root, snapshotId);
+    if (stored.status !== "available" || stored.reference.retention !== "exact")
+        throw new Error("retention snapshot missing or invalid");
+    const text = stored.bytes.toString("utf8"), snapshot = JSON.parse(text);
+    if (JSON.stringify(snapshot) !== text || !snapshot || Object.keys(snapshot).sort().join() !== "blobs,manifestId,producerCommit,version"
+        || snapshot.version !== "retention-archive-snapshot-v1" || snapshot.producerCommit !== RETENTION_V2_COMMIT || !SHA.test(snapshot.manifestId)
+        || !snapshot.blobs || Object.keys(snapshot.blobs).sort().join() !== [...RETENTION_CONTENT_KINDS].sort().join()
+        || Object.values(snapshot.blobs).some(id => id !== null && (typeof id !== "string" || !SHA.test(id))))
+        throw new Error("invalid retention snapshot");
+    const source = readArchiveSource(root, snapshot.manifestId);
+    if (source.status !== "available" || source.reference.retention !== "exact")
+        throw new Error("retained producer manifest missing or invalid");
+    const manifest = parseManifest(source.bytes);
+    const supplied = new Map();
+    for (const kind of RETENTION_CONTENT_KINDS) {
+        const id = snapshot.blobs[kind], ref = manifest.content[kind];
+        if (!id || !ref.path)
+            continue;
+        const content = readArchiveSource(root, id);
+        if (content.status === "available" && content.reference.retention === "exact")
+            supplied.set(ref.path, content.bytes);
+    }
+    return { snapshotId, sourceId: source.reference.sourceId, manifest, projection: project(manifest, source.bytes, supplied) };
+}
+/** Order-independent joins, not an acceptance engine. Logical child names and native parents are not execution keys. */
+export function projectRetainedExecutions(snapshots) {
+    if (snapshots.length > 4096)
+        throw new Error("retention projection exceeds snapshot bound");
+    const unique = [...new Map(snapshots.map(p => [JSON.stringify(p), p])).values()];
+    const objectKey = (value) => JSON.stringify(Object.keys(value).sort().map(key => [key, value[key]]));
+    const groups = new Map();
+    for (const snapshot of unique) {
+        const id = snapshot.identity.executionId;
+        groups.set(id, [...(groups.get(id) ?? []), snapshot]);
+    }
+    const lineageIssue = (start) => {
+        const seen = new Set();
+        let id = start;
+        while (id !== null && groups.has(id)) {
+            if (seen.has(id))
+                return "cyclic-parentage";
+            seen.add(id);
+            const parents = [...new Set(groups.get(id).map(p => p.identity.parentExecutionId))];
+            if (parents.length !== 1)
+                return "ambiguous-parentage";
+            id = parents[0];
+        }
+        return null;
+    };
+    const executions = [...groups].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([executionId, values]) => {
+        const identities = new Set(values.map(p => objectKey(p.identity)));
+        const terminals = values.filter(p => p.runtime === "terminal");
+        const outcomes = new Set(terminals.map(p => objectKey(p.outcome)));
+        const issues = new Set(values.flatMap(p => p.issues));
+        if (identities.size > 1)
+            issues.add("execution-identity-conflict");
+        if (outcomes.size > 1)
+            issues.add("terminal-outcome-conflict");
+        const lineage = lineageIssue(executionId);
+        if (lineage)
+            issues.add(lineage);
+        const parentExecutionIds = [...new Set(values.map(p => p.identity.parentExecutionId))].sort();
+        const retainedSessionIds = [...new Set(values.map(p => p.sessionId).filter((id) => id !== null))].sort();
+        if (retainedSessionIds.length > 1)
+            issues.add("session-identity-conflict");
+        if (parentExecutionIds.some(id => id !== null && !groups.has(id)))
+            issues.add("parent-not-in-snapshot");
+        return { executionId, parentExecutionIds, retainedSessionIds, activeBranch: null, toolCallIds: [...new Set(values.map(p => p.identity.toolCallId))].sort(),
+            archiveIds: [...new Set(values.map(p => p.archiveId))].sort(),
+            runtime: identities.size > 1 || outcomes.size > 1 ? "conflict" : terminals.length ? "terminal" : "running",
+            outcome: identities.size === 1 && outcomes.size === 1 ? terminals[0].outcome : null,
+            sourceReferences: [...new Set(values.map(p => p.sourceSha256))].sort(), issues: [...issues].sort(), coverage: "partial", acceptance: "not-assessed" };
+    });
+    const projection = { version: "execution-archive-projection-v1", executions, acceptance: "not-assessed" };
+    assertExecutionProjection(projection);
+    return projection;
+}
+//# sourceMappingURL=execution-retention-archive.js.map

package/dist/generated/retention-v2-contract.d.ts

@@ -0,0 +1,72 @@
+import type { ExecutionRetentionManifest } from "./retention-v2-types.js";
+export declare const RETENTION_CONTENT_KINDS: readonly ["stdout", "stderr", "paneSnapshot", "checkReceipt", "result", "session"];
+export declare const RETENTION_SCHEMA: {
+    allOf: ({
+        if: {
+            properties: {
+                state: {
+                    const: unknown;
+                };
+                nativeSession?: undefined;
+            };
+        };
+        then: {
+            properties: {
+                outcome: {
+                    const: unknown;
+                };
+                nativeSession?: undefined;
+                native?: undefined;
+            };
+        };
+        else: {
+            properties: {
+                outcome: {
+                    type: string;
+                };
+            };
+        };
+    } | {
+        if: {
+            properties: {
+                nativeSession: {
+                    properties: {
+                        branchState: {
+                            const: unknown;
+                        };
+                    };
+                };
+                state?: undefined;
+            };
+        };
+        then: {
+            properties: {
+                nativeSession: {
+                    properties: {
+                        branchLeafId: {
+                            const: unknown;
+                        };
+                    };
+                };
+                native: {
+                    properties: {
+                        branchLeafId: {
+                            const: unknown;
+                        };
+                    };
+                };
+                outcome?: undefined;
+            };
+        };
+        else?: undefined;
+    })[];
+    type: string;
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+    $schema: string;
+    $id: string;
+};
+/** Closed, detached versioned wire builder; never authenticates the supplied observation. */
+export declare function buildExecutionRetentionManifest(value: unknown): ExecutionRetentionManifest;
+export declare function parseExecutionRetentionManifest(text: string): ExecutionRetentionManifest;

package/dist/generated/retention-v2-contract.js

@@ -0,0 +1,105 @@
+// GENERATED by scripts/vendor-execution-retention.mjs from pi-daddy 7c78769c47177b1972b09e1f5c5474ad44cd2cac. Do not hand-edit.
+import { Compile } from "typebox/compile";
+import { parseWorkJson } from "./retention-v2-json.js";
+const string = (maxLength = 512) => ({ type: "string", minLength: 1, maxLength, pattern: "^[^\\u0000-\\u001f\\u007f]+$" });
+const nullable = (schema) => ({ anyOf: [schema, { type: "null" }] });
+const literal = (value) => ({ const: value });
+const closed = (properties) => ({ type: "object", properties, required: Object.keys(properties), additionalProperties: false });
+const hash = { type: "string", pattern: "^[a-f0-9]{64}$" };
+const integer = { type: "integer", minimum: 0, maximum: Number.MAX_SAFE_INTEGER };
+const uuid = { type: "string", pattern: "^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$" };
+export const RETENTION_CONTENT_KINDS = ["stdout", "stderr", "paneSnapshot", "checkReceipt", "result", "session"];
+export const RETENTION_SCHEMA = freeze({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://pi-daddy.local/contracts/execution-retention/v2/manifest.schema.json",
+    ...closed({
+        version: literal("2.0"), archiveId: uuid,
+        identity: closed({ executionId: string(), parentExecutionId: nullable(string()), childId: string(), toolCallId: nullable(string()),
+            executor: { enum: ["process", "herdr", "check"] }, taskDigest: nullable(hash), definitionDigest: nullable(hash),
+            configurationDigest: hash, workspaceId: nullable(string()) }),
+        native: closed({ pid: nullable({ type: "integer", minimum: 1, maximum: Number.MAX_SAFE_INTEGER }), paneId: nullable(string(4096)),
+            agentName: nullable(string(4096)), tabId: nullable(string(4096)), sessionId: nullable(uuid), sessionPath: nullable(string(4096)), branchLeafId: nullable(string(128)) }),
+        nativeSession: closed({ source: { enum: [null, "herdr-id", "herdr-path", "pi-session-file", "pi-session-manager"] },
+            status: { enum: ["missing", "verified", "invalid", "changed", "truncated", "unsupported"] },
+            sessionId: nullable(uuid), sessionPath: nullable(string(4096)), parentSessionPath: nullable(string(4096)),
+            branchLeafId: nullable(string(128)), branchState: { enum: ["unknown", "observed"] }, lastPersistedEntryId: nullable(string(128)),
+            sha256: nullable(hash), reason: nullable(string()) }),
+        state: { enum: ["running", "terminal"] },
+        outcome: nullable(closed({ code: nullable({ type: "integer", minimum: -2147483648, maximum: 2147483647 }), signal: nullable(string(64)),
+            timedOut: { type: "boolean" }, aborted: { type: "boolean" }, truncated: { type: "boolean" }, failed: { type: "boolean" } })),
+        content: closed(Object.fromEntries(RETENTION_CONTENT_KINDS.map(kind => [kind, { oneOf: [
+                    closed({ status: literal("missing"), path: literal(null), sha256: literal(null), bytes: literal(null) }),
+                    closed({ status: literal("retained"), path: { type: "string", pattern: `^${kind}-[a-f0-9]{64}\\.bin$` }, sha256: hash,
+                        bytes: { ...integer, maximum: 1024 * 1024 } }),
+                ] }]))),
+        coverage: closed({ complete: literal(false), losses: { type: "array", items: string(), maxItems: 64, uniqueItems: true } }),
+        acceptance: literal("not-assessed"),
+    }),
+    allOf: [
+        { if: { properties: { state: literal("running") } }, then: { properties: { outcome: literal(null) } },
+            else: { properties: { outcome: { type: "object" } } } },
+        { if: { properties: { nativeSession: { properties: { branchState: literal("unknown") } } } },
+            then: { properties: { nativeSession: { properties: { branchLeafId: literal(null) } }, native: { properties: { branchLeafId: literal(null) } } } } },
+    ],
+});
+const validator = Compile(RETENTION_SCHEMA);
+function freeze(value) { if (value && typeof value === "object") {
+    for (const child of Object.values(value))
+        freeze(child);
+    Object.freeze(value);
+} return value; }
+/** Closed, detached versioned wire builder; never authenticates the supplied observation. */
+export function buildExecutionRetentionManifest(value) {
+    // Reject non-JSON objects/accessors instead of invoking serialization hooks while collecting evidence.
+    let nodes = 0;
+    const inspect = (x, depth) => {
+        if (++nodes > 4096 || depth > 16)
+            throw new TypeError("retention manifest exceeds bounds");
+        if (x === null || typeof x === "string" || typeof x === "boolean" || (typeof x === "number" && Number.isSafeInteger(x)))
+            return;
+        if (!x || typeof x !== "object" || (!Array.isArray(x) && Object.getPrototypeOf(x) !== Object.prototype && Object.getPrototypeOf(x) !== null))
+            throw new TypeError("retention manifest must be JSON data");
+        if (Array.isArray(x) && (Object.getPrototypeOf(x) !== Array.prototype || x.length > 256 || Reflect.ownKeys(x).length !== x.length + 1 ||
+            Array.from({ length: x.length }, (_, i) => String(i)).some(key => !Object.hasOwn(x, key))))
+            throw new TypeError("retention arrays must be dense plain JSON arrays");
+        for (const key of Reflect.ownKeys(x)) {
+            if (Array.isArray(x) && key === "length")
+                continue;
+            const d = Object.getOwnPropertyDescriptor(x, key);
+            if (typeof key !== "string" || !d.enumerable || !("value" in d))
+                throw new TypeError("retention manifest must be plain JSON data");
+            inspect(d.value, depth + 1);
+        }
+    };
+    inspect(value, 0);
+    if (!validator.Check(value))
+        throw new TypeError("invalid execution-retention 2.0 manifest");
+    const m = JSON.parse(JSON.stringify(value));
+    if (m.native.sessionId !== m.nativeSession.sessionId || m.native.sessionPath !== m.nativeSession.sessionPath || m.native.branchLeafId !== m.nativeSession.branchLeafId) {
+        throw new TypeError("native session projection mismatch");
+    }
+    for (const kind of RETENTION_CONTENT_KINDS) {
+        const ref = m.content[kind];
+        if (ref.status === "retained" && ref.path !== `${kind}-${ref.sha256}.bin`)
+            throw new TypeError("retention content identity mismatch");
+    }
+    if (m.nativeSession.branchState === "observed" && (m.nativeSession.source !== "pi-session-manager" || m.nativeSession.status !== "verified"))
+        throw new TypeError("unverified active native branch");
+    if (m.nativeSession.status === "verified" && (!m.nativeSession.sessionId || !m.nativeSession.sha256 || m.content.session.sha256 !== m.nativeSession.sha256))
+        throw new TypeError("verified native session requires retained bytes");
+    return freeze(m);
+}
+export function parseExecutionRetentionManifest(text) {
+    if (Buffer.byteLength(text) > 64 * 1024)
+        throw new TypeError("retention manifest exceeds bounds");
+    // Manifest numbers are integers; use the existing exact-token parser before lossy Number conversion.
+    let value;
+    try {
+        value = parseWorkJson(text);
+    }
+    catch {
+        throw new TypeError("invalid retention JSON");
+    }
+    return buildExecutionRetentionManifest(value);
+}
+//# sourceMappingURL=retention-v2-contract.js.map

package/dist/generated/retention-v2-json.d.ts

@@ -0,0 +1,24 @@
+import { type WorkFrozen, type WorkProblem, type WorkConflict } from "./retention-v2-work-types.js";
+export declare const WORK_EVENT_BYTES: number;
+export declare const WORK_TEXT_BYTES: number;
+export declare const WORK_RECORDS = 10000;
+export type WorkJson = null | boolean | number | string | WorkJson[] | {
+    [key: string]: WorkJson;
+};
+/** Inspect descriptors rather than serializing: no getters/toJSON or lossy JSON coercion. */
+export declare function ownWorkFields(value: unknown): Record<string, PropertyDescriptor>;
+/** Detach only the approved JSON value profile, before any serialization or validation use. */
+export declare function copyWorkJson(value: unknown): WorkJson;
+/** Bounded syntax tree: syntax, decoded duplicates, then exact numeric/string profile. */
+export declare function parseWorkJson(text: string): WorkJson;
+/** RFC 8785 emission restricted to our validated JSON profile; not an archival-byte identity. */
+export declare function canonicalWorkJson(value: unknown): string;
+export declare function workDigest(value: unknown): string;
+/** @internal ONLY validated constituents / internally constructed plain results. Output collections
+ * are not wire records: they may contain >256 claims, problems, labels, or conflict alternatives.
+ * Never use this emitter in place of copyWorkJson/strict ingestion at an input boundary. */
+export declare function workResultKey<T>(value: T): string;
+export declare function sortWorkResults<T>(values: Iterable<T>): T[];
+export declare function mergeWorkProblems(values: readonly WorkFrozen<WorkProblem>[]): WorkFrozen<WorkProblem>[];
+export declare function mergeWorkConflicts(values: readonly WorkFrozen<WorkConflict>[]): WorkFrozen<WorkConflict>[];
+export declare function freezeWork<T>(value: T): WorkFrozen<T>;