@skill-harness/adapters 0.12.0 → 0.14.0

package/dist/generated/retention-v2-work-types.d.ts

@@ -0,0 +1,260 @@
+/** Opt-in work-v4 wire identities; none of these declarations grants authority. */
+export type WorkFrozen<T> = T extends ReadonlyArray<infer E> ? ReadonlyArray<WorkFrozen<E>> : T extends object ? {
+    readonly [K in keyof T]: WorkFrozen<T[K]>;
+} : T;
+export type WorkInputCode = "WORK_JSON_INVALID" | "WORK_DUPLICATE_MEMBER" | "WORK_LIMIT_EXCEEDED" | "WORK_VERSION_UNSUPPORTED" | "WORK_SCHEMA_INVALID" | "WORK_DIGEST_MISMATCH" | "WORK_CONTEXT_INVALID";
+export declare class WorkInputError extends TypeError {
+    readonly code: WorkInputCode;
+    constructor(code: WorkInputCode);
+}
+export type WorkWriteCode = "WORK_DESTINATION_INVALID" | "WORK_DESTINATION_ALIAS" | "WORK_LEDGER_WRITE_FAILED";
+export declare class WorkLedgerWriteError extends Error {
+    readonly code: WorkWriteCode;
+    constructor(code: WorkWriteCode);
+}
+export type WorkInspectionCode = "WORK_INSPECTION_PATH_INVALID" | "WORK_INSPECTION_NOT_REGULAR" | "WORK_INSPECTION_READ_FAILED";
+export interface WorkInspectionDiagnostic {
+    readonly line: null;
+    readonly code: WorkInputCode | WorkInspectionCode;
+}
+export interface WorkLedgerInspection {
+    readonly version: 4;
+    readonly status: "read" | "missing" | "error";
+    readonly exists: boolean | null;
+    readonly ingestion: WorkIngestion | null;
+    readonly projection: WorkProjection | null;
+    readonly errors: ReadonlyArray<WorkInspectionDiagnostic>;
+}
+export type RevisionKind = "scope" | "goal" | "node" | "obligation" | "artifact" | "policy";
+export type WorkEventKind = "work_revision" | "work_snapshot" | "work_occurrence" | "work_acceptance";
+export interface RevisionRef {
+    kind: RevisionKind;
+    id: string;
+    revision: number;
+    digest: string;
+}
+export interface EventRef {
+    eventId: string;
+    digest: string;
+}
+export interface Identity {
+    id: string;
+    digest: string;
+}
+export interface WorkRevision {
+    kind: RevisionKind;
+    id: string;
+    revision: number;
+    scopeId: string;
+    predecessor: RevisionRef | null;
+    contentDigest: string;
+    parent: RevisionRef | null;
+    dependencies: RevisionRef[];
+    ownerId: string;
+    permittedEffects: string[];
+    policy: RevisionRef | null;
+    digest: string;
+}
+export interface ObligationBinding {
+    intent: RevisionRef;
+    obligation: RevisionRef;
+    artifact: RevisionRef | null;
+    policy: RevisionRef;
+}
+export interface WorkSnapshot {
+    snapshotId: string;
+    scope: RevisionRef;
+    revisions: RevisionRef[];
+    bindings: ObligationBinding[];
+    digest: string;
+}
+export interface WorkOccurrencePayload {
+    scope: RevisionRef;
+    obligation: RevisionRef;
+    executionId: string;
+    parentExecutionId: string | null;
+    childId: string | null;
+    variantId: string | null;
+    artifact: RevisionRef | null;
+    provenance: "declared" | "observed";
+    state: "unknown" | "starting" | "running" | "completed" | "failed";
+    labels: {
+        sessionId: string | null;
+        branchLeafId: string | null;
+        toolCallId: string | null;
+        taskId: string | null;
+        workspaceId: string | null;
+        definitionDigest: string | null;
+        configurationDigest: string | null;
+        modelId: string | null;
+        effortId: string | null;
+    };
+}
+export interface EvidenceRef {
+    id: string;
+    digest: string;
+    event: EventRef | null;
+}
+export interface AcceptanceBinding {
+    snapshot: Identity;
+    scope: RevisionRef;
+    intent: RevisionRef;
+    obligation: RevisionRef;
+    artifact: RevisionRef;
+    artifactDigest: string;
+    policy: RevisionRef;
+    evidence: EvidenceRef[];
+}
+export interface WorkAcceptancePayload {
+    authorityId: string;
+    binding: AcceptanceBinding;
+}
+interface WorkEvent<K extends WorkEventKind, P> {
+    ledgerVersion: 4;
+    event: K;
+    eventId: string;
+    ts: string;
+    payload: P;
+    digest: string;
+}
+export type WorkRevisionEvent = WorkEvent<"work_revision", {
+    revision: WorkRevision;
+}>;
+export type WorkSnapshotEvent = WorkEvent<"work_snapshot", {
+    snapshot: WorkSnapshot;
+}>;
+export type WorkOccurrenceEvent = WorkEvent<"work_occurrence", WorkOccurrencePayload>;
+export type WorkAcceptanceEvent = WorkEvent<"work_acceptance", WorkAcceptancePayload>;
+export type WorkLedgerEvent = WorkRevisionEvent | WorkSnapshotEvent | WorkOccurrenceEvent | WorkAcceptanceEvent;
+export interface WorkDiagnostic {
+    readonly line: number | null;
+    readonly code: WorkInputCode;
+}
+export interface WorkIngestion {
+    readonly events: ReadonlyArray<WorkLedgerEvent>;
+    readonly errors: ReadonlyArray<WorkDiagnostic>;
+    readonly complete: boolean;
+}
+export type WorkResolutionCode = "INPUT_INCOMPLETE" | "NO_SELECTION" | "REFERENCE_MISSING" | "SCOPE_INVALID" | "REVISION_INVALID" | "CYCLE" | "DEPENDENCY_INVALID" | "EVENT_CONFLICT" | "ARTIFACT_UNSELECTED" | "ARTIFACT_DIGEST_MISMATCH" | "NO_CLAIM" | "SUPERSEDED_BINDING" | "AUTHORITY_MISSING" | "RECEIPT_MISSING" | "RECEIPT_MISMATCH" | "RECEIPT_CONFLICT" | "DECISION_CONFLICT" | "TRUSTED_REJECTION" | "AVAILABILITY_MISSING" | "BYTES_UNAVAILABLE" | "AVAILABILITY_CONFLICT" | "OCCURRENCE_CONFLICT" | "PARENT_MISSING" | "PARENT_CYCLE" | "OBSERVATION_CONFLICT" | "BRANCH_UNKNOWN";
+export type WorkReference = {
+    readonly type: "revision";
+    readonly ref: RevisionRef;
+} | {
+    readonly type: "event";
+    readonly ref: EventRef;
+} | {
+    readonly type: "snapshot" | "authority" | "artifact-bytes" | "evidence-bytes";
+    readonly ref: Identity;
+} | {
+    readonly type: "execution";
+    readonly id: string;
+};
+export interface WorkProblem {
+    readonly code: WorkResolutionCode;
+    readonly reference: WorkReference | null;
+    readonly affectedObligations: ReadonlyArray<RevisionRef>;
+}
+export interface WorkConflict {
+    readonly kind: "event" | "receipt";
+    readonly id: string;
+    readonly digests: ReadonlyArray<string>;
+    readonly affectedObligations: ReadonlyArray<RevisionRef>;
+}
+/** Explicit trusted-host declarations, never constructed from wire evidence by production code. */
+export interface WorkProjectionContext {
+    selectedSnapshot: {
+        snapshot: Identity;
+        event: EventRef;
+    } | null;
+    authority: {
+        snapshot: Identity;
+        decisions: Array<{
+            receiptId: string;
+            authorityId: string;
+            claim: EventRef;
+            binding: AcceptanceBinding;
+            decision: "accept" | "reject";
+        }>;
+        availability: Array<{
+            kind: "artifact" | "evidence";
+            id: string;
+            digest: string;
+            available: boolean;
+        }>;
+    } | null;
+}
+export type WorkAvailability = "available" | "unavailable" | "unknown" | "conflicted";
+export interface WorkCoverageItem {
+    readonly kind: "artifact" | "evidence";
+    readonly identity: Identity;
+    readonly state: WorkAvailability;
+}
+export interface WorkCoverage {
+    readonly state: WorkAvailability | "unselected";
+    readonly items: ReadonlyArray<WorkCoverageItem>;
+}
+export type WorkAcceptanceState = "accepted-under-supplied-authority" | "unaccepted" | "unresolved";
+export interface WorkClaimResult {
+    readonly claim: EventRef;
+    readonly obligation: RevisionRef;
+    readonly applicability: WorkAcceptanceState | "superseded";
+    readonly matchedReceiptIds: ReadonlyArray<string>;
+    readonly problems: ReadonlyArray<WorkProblem>;
+}
+export interface WorkObligationResult {
+    readonly binding: ObligationBinding;
+    readonly acceptance: WorkAcceptanceState;
+    readonly artifactCoverage: WorkCoverage;
+    readonly evidenceCoverage: WorkCoverage;
+    readonly claims: ReadonlyArray<EventRef>;
+    readonly problems: ReadonlyArray<WorkProblem>;
+}
+export interface WorkOccurrenceView {
+    readonly event: EventRef;
+    readonly payload: WorkOccurrencePayload;
+}
+export interface WorkAttemptBinding {
+    readonly scope: RevisionRef;
+    readonly obligation: RevisionRef;
+    readonly variantIds: ReadonlyArray<string>;
+    readonly artifacts: ReadonlyArray<RevisionRef>;
+}
+export interface WorkAttempt {
+    readonly executionId: string;
+    readonly bindings: ReadonlyArray<WorkAttemptBinding>;
+    readonly parentExecutionId: string | null;
+    readonly childId: string | null;
+    readonly declaredLabels: ReadonlyArray<WorkOccurrencePayload["labels"]>;
+    readonly observedLabels: ReadonlyArray<WorkOccurrencePayload["labels"]>;
+    readonly effectiveLabels: WorkOccurrencePayload["labels"];
+    readonly state: WorkOccurrencePayload["state"] | "conflicted";
+    readonly resolution: "resolved" | "unresolved";
+    readonly problems: ReadonlyArray<WorkProblem>;
+}
+export interface WorkRuntimeCounts {
+    readonly attempts: number;
+    readonly variants: number;
+    readonly observedCompletedAttempts: number;
+}
+export interface WorkRuntime {
+    readonly counts: WorkRuntimeCounts;
+    readonly occurrences: ReadonlyArray<WorkOccurrenceView>;
+    readonly attempts: ReadonlyArray<WorkAttempt>;
+}
+export interface WorkProjection {
+    readonly selectedSnapshot: Identity | null;
+    readonly authoritySnapshot: Identity | null;
+    readonly scopeState: "unselected" | "valid" | "unresolved" | "invalid";
+    readonly progress: Readonly<{
+        accepted: number;
+        total: number;
+    }> | null;
+    readonly obligations: ReadonlyArray<WorkObligationResult>;
+    readonly claims: ReadonlyArray<WorkClaimResult>;
+    readonly supersededClaims: number;
+    readonly conflicts: ReadonlyArray<WorkConflict>;
+    readonly problems: ReadonlyArray<WorkProblem>;
+    readonly errors: ReadonlyArray<WorkDiagnostic>;
+    readonly runtime: WorkRuntime | null;
+}
+export {};

package/dist/generated/retention-v2-work-types.js

@@ -0,0 +1,13 @@
+export class WorkInputError extends TypeError {
+    code;
+    constructor(code) {
+        super(code);
+        this.name = "WorkInputError";
+        this.code = code;
+    }
+}
+export class WorkLedgerWriteError extends Error {
+    code;
+    constructor(code) { super(code); this.name = "WorkLedgerWriteError"; this.code = code; }
+}
+//# sourceMappingURL=retention-v2-work-types.js.map

package/dist/generated/work-v4/execution-id.d.ts

@@ -0,0 +1,5 @@
+/** Unique identity for one governed execution occurrence. Logical child ids remain readable positions. */
+export type ExecutionId = `exec:${string}`;
+export declare function isExecutionId(value: unknown): value is ExecutionId;
+export declare function newExecutionId(): ExecutionId;
+export declare function assertExecutionId(value: unknown, field?: string): asserts value is ExecutionId;

package/dist/generated/work-v4/execution-id.js

@@ -0,0 +1,14 @@
+// GENERATED from pi-daddy 7c78769c47177b1972b09e1f5c5474ad44cd2cac by scripts/vendor-work-v4-reader.mjs. Do not hand-edit.
+import { randomUUID } from "node:crypto";
+const EXECUTION_ID_RE = /^exec:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export function isExecutionId(value) {
+    return typeof value === "string" && EXECUTION_ID_RE.test(value);
+}
+export function newExecutionId() {
+    return `exec:${randomUUID()}`;
+}
+export function assertExecutionId(value, field = "executionId") {
+    if (!isExecutionId(value))
+        throw new TypeError(`${field} must be a pi-daddy execution id`);
+}
+//# sourceMappingURL=execution-id.js.map

package/dist/generated/work-v4/json.d.ts

@@ -0,0 +1,24 @@
+import { type WorkFrozen, type WorkProblem, type WorkConflict } from "./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>;

package/dist/generated/work-v4/json.js

@@ -0,0 +1,268 @@
+// GENERATED from pi-daddy 7c78769c47177b1972b09e1f5c5474ad44cd2cac by scripts/vendor-work-v4-reader.mjs. Do not hand-edit.
+import { createHash } from "node:crypto";
+import { WorkInputError } from "./types.js";
+export const WORK_EVENT_BYTES = 64 * 1024;
+export const WORK_TEXT_BYTES = 16 * 1024 * 1024;
+export const WORK_RECORDS = 10_000;
+const MAX_DEPTH = 16;
+const MAX_ARRAY = 256;
+const invalid = () => { throw new WorkInputError("WORK_SCHEMA_INVALID"); };
+const limit = () => { throw new WorkInputError("WORK_LIMIT_EXCEEDED"); };
+function unicode(value) {
+    // RFC 8785 refuses lone UTF-16 surrogates, including ones decoded from escapes.
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            const next = value.charCodeAt(++i);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                invalid();
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff)
+            invalid();
+    }
+    return value;
+}
+/** Inspect descriptors rather than serializing: no getters/toJSON or lossy JSON coercion. */
+export function ownWorkFields(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        invalid();
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        invalid();
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (const key of Reflect.ownKeys(descriptors)) {
+        if (typeof key !== "string")
+            return invalid();
+        const descriptor = descriptors[key];
+        if (!Object.hasOwn(descriptor, "value") || !descriptor.enumerable)
+            invalid();
+        unicode(key);
+    }
+    return descriptors;
+}
+/** Detach only the approved JSON value profile, before any serialization or validation use. */
+export function copyWorkJson(value) {
+    const ancestors = new Set();
+    function copy(v, depth) {
+        if (v === null || typeof v === "boolean")
+            return v;
+        if (typeof v === "string")
+            return unicode(v);
+        if (typeof v === "number")
+            return Number.isSafeInteger(v) ? v : invalid();
+        if (typeof v !== "object")
+            return invalid();
+        if (depth > MAX_DEPTH)
+            limit();
+        if (ancestors.has(v))
+            invalid();
+        ancestors.add(v);
+        let result;
+        if (Array.isArray(v)) {
+            if (Object.getPrototypeOf(v) !== Array.prototype)
+                invalid();
+            if (v.length > MAX_ARRAY)
+                limit();
+            const fields = Object.getOwnPropertyDescriptors(v);
+            if (Reflect.ownKeys(fields).length !== v.length + 1)
+                invalid();
+            result = [];
+            for (let i = 0; i < v.length; i++) {
+                const d = fields[String(i)];
+                if (!d || !Object.hasOwn(d, "value") || !d.enumerable)
+                    invalid();
+                result.push(copy(d.value, depth + 1));
+            }
+        }
+        else {
+            const fields = ownWorkFields(v);
+            result = {};
+            for (const key of Object.keys(fields)) {
+                Object.defineProperty(result, key, { value: copy(fields[key].value, depth + 1), enumerable: true, writable: true, configurable: true });
+            }
+        }
+        ancestors.delete(v);
+        return result;
+    }
+    return copy(value, 1);
+}
+/** Exact decimal arithmetic BEFORE Number conversion, without unbounded exponent allocation. */
+function integerToken(token) {
+    const match = /^(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(token);
+    let digits = (match[2] + (match[3] ?? "")).replace(/^0+/, "");
+    if (!digits)
+        return 0;
+    let shift = BigInt(match[4] ?? "0") - BigInt((match[3] ?? "").length);
+    const trailing = /0*$/.exec(digits)[0].length;
+    digits = digits.slice(0, digits.length - trailing);
+    shift += BigInt(trailing);
+    if (shift < 0n || BigInt(digits.length) + shift > 16n)
+        invalid();
+    const exact = BigInt(digits) * (10n ** shift);
+    if (exact > BigInt(Number.MAX_SAFE_INTEGER))
+        invalid();
+    return Number(match[1] === "-" ? -exact : exact);
+}
+function checkMembers(node) {
+    if (node.type === "object") {
+        const names = new Set();
+        for (const [key, child] of node.entries) {
+            if (names.has(key))
+                throw new WorkInputError("WORK_DUPLICATE_MEMBER");
+            names.add(key);
+            checkMembers(child);
+        }
+    }
+    else if (node.type === "array")
+        node.items.forEach(checkMembers);
+}
+function materialize(node) {
+    if (node.type === "number")
+        return integerToken(node.token);
+    if (node.type === "literal")
+        return typeof node.value === "string" ? unicode(node.value) : node.value;
+    if (node.type === "array")
+        return node.items.map(materialize);
+    return Object.fromEntries(node.entries.map(([key, child]) => [unicode(key), materialize(child)]));
+}
+/** Bounded syntax tree: syntax, decoded duplicates, then exact numeric/string profile. */
+export function parseWorkJson(text) {
+    if (typeof text !== "string")
+        invalid();
+    if (Buffer.byteLength(text, "utf8") > WORK_EVENT_BYTES)
+        limit();
+    let at = 0;
+    const syntax = () => { throw new WorkInputError("WORK_JSON_INVALID"); };
+    const whitespace = () => { while (at < text.length && /[ \t\r\n]/.test(text[at]))
+        at++; };
+    function string() {
+        const start = at++;
+        while (at < text.length) {
+            const char = text[at++];
+            if (char === '"') {
+                // JSON.parse is used ONLY for one lexically delimited string token, never an object.
+                return JSON.parse(text.slice(start, at));
+            }
+            if (char.charCodeAt(0) < 0x20)
+                syntax();
+            if (char === "\\") {
+                const escape = text[at++];
+                if (escape === "u") {
+                    if (!/^[0-9a-fA-F]{4}$/.test(text.slice(at, at + 4)))
+                        syntax();
+                    at += 4;
+                }
+                else if (!escape || !'"\\/bfnrt'.includes(escape))
+                    syntax();
+            }
+        }
+        return syntax();
+    }
+    function value(depth) {
+        whitespace();
+        const char = text[at];
+        if (char === '"')
+            return { type: "literal", value: string() };
+        if (char === "{" || char === "[") {
+            if (depth > MAX_DEPTH)
+                limit();
+            at++;
+            whitespace();
+            const object = char === "{";
+            const end = object ? "}" : "]";
+            const entries = [];
+            const items = [];
+            if (text[at] !== end)
+                for (;;) {
+                    whitespace();
+                    let key = "";
+                    if (object) {
+                        if (text[at] !== '"')
+                            syntax();
+                        key = string();
+                        whitespace();
+                        if (text[at++] !== ":")
+                            syntax();
+                    }
+                    else if (items.length >= MAX_ARRAY)
+                        limit();
+                    const child = value(depth + 1);
+                    if (object)
+                        entries.push([key, child]);
+                    else
+                        items.push(child);
+                    whitespace();
+                    if (text[at] === end)
+                        break;
+                    if (text[at++] !== ",")
+                        syntax();
+                }
+            at++;
+            return object ? { type: "object", entries } : { type: "array", items };
+        }
+        for (const [token, literal] of [["null", null], ["true", true], ["false", false]]) {
+            if (text.startsWith(token, at)) {
+                at += token.length;
+                return { type: "literal", value: literal };
+            }
+        }
+        const token = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(text.slice(at));
+        if (!token)
+            return syntax();
+        at += token[0].length;
+        return { type: "number", token: token[0] };
+    }
+    const result = value(1);
+    whitespace();
+    if (at !== text.length)
+        syntax();
+    checkMembers(result);
+    return materialize(result);
+}
+function emit(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(emit).join(",")}]`;
+    // Emit keys directly: reconstructing a JS object would reorder numeric-looking keys.
+    return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${emit(value[key])}`).join(",")}}`;
+}
+/** RFC 8785 emission restricted to our validated JSON profile; not an archival-byte identity. */
+export function canonicalWorkJson(value) { return emit(copyWorkJson(value)); }
+export function workDigest(value) {
+    return createHash("sha256").update(canonicalWorkJson(value), "utf8").digest("hex");
+}
+/** @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 function workResultKey(value) { return emit(value); }
+export function sortWorkResults(values) {
+    const rows = new Map([...values].map(value => [workResultKey(value), value]));
+    return [...rows].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, value]) => value);
+}
+export function mergeWorkProblems(values) {
+    const rows = new Map();
+    for (const row of values) {
+        const id = workResultKey([row.code, row.reference]), prior = rows.get(id);
+        rows.set(id, { ...row, affectedObligations: sortWorkResults([...(prior?.affectedObligations ?? []), ...row.affectedObligations]) });
+    }
+    return sortWorkResults(rows.values());
+}
+export function mergeWorkConflicts(values) {
+    const rows = new Map();
+    for (const row of values) {
+        const id = workResultKey([row.kind, row.id]), prior = rows.get(id);
+        rows.set(id, { ...row, digests: sortWorkResults([...(prior?.digests ?? []), ...row.digests]),
+            affectedObligations: sortWorkResults([...(prior?.affectedObligations ?? []), ...row.affectedObligations]) });
+    }
+    return sortWorkResults(rows.values());
+}
+export function freezeWork(value) {
+    if (value !== null && typeof value === "object") {
+        for (const child of Object.values(value))
+            freezeWork(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+//# sourceMappingURL=json.js.map