@skill-harness/adapters 0.17.0 → 0.18.0

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

@@ -1,238 +0,0 @@
-// GENERATED from pi-daddy 7c78769c47177b1972b09e1f5c5474ad44cd2cac by scripts/vendor-work-v4-reader.mjs. Do not hand-edit.
-import { parseWorkLedgerText } from "./reader.js";
-import { canonicalWorkJson, freezeWork, workDigest, workResultKey as key, sortWorkResults as unique, mergeWorkProblems, mergeWorkConflicts } from "./json.js";
-const revisionIdentity = ({ kind, id, revision, digest }) => key(["revision", kind, id, revision, digest]);
-/** The ONLY nested identity definition. Claims deliberately have no nested quarantine identity. */
-function nestedIdentity(event) {
-    switch (event.event) {
-        case "work_revision": return revisionIdentity(event.payload.revision);
-        case "work_snapshot": return key(["snapshot", event.payload.snapshot.snapshotId, event.payload.snapshot.digest]);
-        case "work_occurrence": return key(["occurrence", event.payload]);
-        case "work_acceptance": return null;
-    }
-}
-function sourceIds(index, event) {
-    const nested = "event" in event ? nestedIdentity(event) : null;
-    return [...(index.conflictSources.events[key(event.eventId)] ? [event.eventId] : []),
-        ...(nested === null ? [] : index.conflictSources.bodies[nested] ?? [])];
-}
-/** @internal Only index-derived validated events/references. Raw alternatives remain diagnostic input. */
-export function workEventConflictSources(index, event) {
-    return unique(unique(sourceIds(index, event)).flatMap(id => index.conflictSources.events[key(id)]));
-}
-/** @internal Exact revision references need not have a clean delivery to be quarantined. */
-export function workRevisionConflictSources(index, ref) {
-    return unique((index.conflictSources.bodies[revisionIdentity(ref)] ?? []).flatMap(id => index.conflictSources.events[key(id)]));
-}
-function sorted(values) {
-    // Canonicalize individual rows, not the aggregate. A valid 10,000-record input can have
-    // more than 256 candidates/conflicts; the per-wire-array bound must not truncate replay.
-    return [...values].map(value => ({ value, key: canonicalWorkJson(value) }))
-        .sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0)
-        .map(entry => entry.value);
-}
-/**
- * @internal Strict text -> complete delivery grouping -> quarantine -> effective evidence.
- * Deliberately not re-exported by work-ledger.ts: this is not an unchecked public projector.
- * Raw serialized/archival byte hashes play no role in semantic delivery identity.
- */
-export function indexWorkLedgerText(text) {
-    const ingestion = parseWorkLedgerText(text);
-    const groups = new Map();
-    for (const event of ingestion.events) {
-        let group = groups.get(event.eventId);
-        if (!group) {
-            group = new Map();
-            groups.set(event.eventId, group);
-        }
-        if (!group.has(event.digest)) {
-            // Equal canonical digests can arrive with different property insertion orders. Normalize
-            // the validated body so even serialized index output does not choose an arrival's key order.
-            // Parse ONLY our own canonical emission, never raw input. Strict ingestion already checked
-            // duplicates, domains and digests. JCS can expand exact exponent tokens beyond the delivered
-            // text size, so applying the raw-line byte bound again here would reject valid evidence.
-            const normalized = JSON.parse(canonicalWorkJson(event));
-            group.set(event.digest, freezeWork(normalized));
-        }
-    }
-    const conflictingEvents = [];
-    const quarantined = new Map(); // Retained diagnostic view, not a second quarantine policy.
-    const bodies = new Map(), eventGroups = new Map();
-    for (const [eventId, group] of groups) {
-        if (group.size < 2)
-            continue;
-        eventGroups.set(key(eventId), sorted([...group.values()].map(event => ({ eventId, digest: event.digest }))));
-        for (const event of group.values()) {
-            conflictingEvents.push({ eventId, digest: event.digest });
-            const identity = nestedIdentity(event);
-            if (identity !== null) {
-                const ids = bodies.get(identity) ?? new Set();
-                ids.add(eventId);
-                bodies.set(identity, ids);
-            }
-            if (event.event === "work_revision") {
-                const { kind, id, revision, digest } = event.payload.revision;
-                // Ingestion verified that this digest covers the entire revision, including kind/ID/scope.
-                // Quarantine exact bodies, not every fork or successor sharing a stable entity ID.
-                quarantined.set(digest, { kind, id, revision, digest });
-            }
-        }
-    }
-    const candidates = sorted([...groups.values()].flatMap(group => [...group.values()]));
-    const byKey = (map) => [...map].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-    const conflictSources = { bodies: Object.fromEntries(byKey(bodies).map(([identity, ids]) => [identity, [...ids].sort()])),
-        events: Object.fromEntries(byKey(eventGroups)) };
-    // All existing nested identities use the same source index before any effective evidence is exposed.
-    const effectiveEvents = ingestion.complete ? candidates.filter(event => !sourceIds({ conflictSources }, event).length) : [];
-    return freezeWork({
-        ingestion, candidates, conflictingEvents: sorted(conflictingEvents), conflictSources,
-        quarantinedRevisions: sorted(quarantined.values()), effectiveEvents,
-    });
-}
-const eventRef = (event) => ({ eventId: event.eventId, digest: event.digest });
-const eventReference = (event) => ({ type: "event", ref: eventRef(event) });
-const isConflict = (p) => p.code.endsWith("CONFLICT");
-function coverage(items) {
-    const state = ["conflicted", "unavailable", "unknown"].find(s => items.some(item => item.state === s));
-    return { state: state ?? (items.length ? "available" : "unknown"), items: unique(items) };
-}
-/** @internal Global receipt identity diagnostics exist even without a resolved work selector. */
-export function indexWorkReceipts(authority) {
-    const receipts = new Map();
-    const conflicts = [];
-    for (const d of authority?.decisions ?? []) {
-        const group = receipts.get(d.receiptId) ?? new Map();
-        // Complete decision + enclosing authority snapshot; diagnostic identity, NOT authentication.
-        group.set(workDigest({ authoritySnapshot: authority.snapshot, ...d }), d);
-        receipts.set(d.receiptId, group);
-    }
-    for (const [id, group] of receipts)
-        if (group.size > 1) {
-            conflicts.push({ kind: "receipt", id, digests: unique(group.keys()), affectedObligations: [] });
-        }
-    return { receipts, conflicts: unique(conflicts) };
-}
-/** @internal Conditional binding proof, not authentication. Only the separately supplied, validated
- * host authority is a TCB input. No wire label, event, receipt-shaped payload or environment is trust. */
-export function projectWorkAcceptance(index, structure, authority, runtime) {
-    const snapshot = structure.snapshot;
-    const claims = [], obligations = [];
-    const problems = [...structure.problems];
-    const conflicts = [...structure.conflicts, ...runtime.conflicts];
-    const eventConflicts = new Set(index.conflictingEvents.map(e => e.eventId));
-    const events = new Map(index.candidates.map(e => [key(eventRef(e)), e]));
-    const receiptIndex = indexWorkReceipts(authority), { receipts } = receiptIndex;
-    conflicts.push(...receiptIndex.conflicts);
-    const decisions = [...receipts.values()].filter(g => g.size === 1).flatMap(g => [...g.values()]);
-    function available(kind, id, digest) {
-        const values = unique((authority?.availability ?? []).filter(row => row.kind === kind && row.id === id && row.digest === digest).map(row => row.available));
-        const state = values.length > 1 ? "conflicted" : values.length === 0 ? "unknown" : values[0] ? "available" : "unavailable";
-        return { kind, identity: { id, digest }, state };
-    }
-    const allClaims = index.candidates.filter((e) => e.event === "work_acceptance");
-    function sourceProblems(ref, affected) {
-        const result = [];
-        const found = events.get(key(ref));
-        for (const event of workEventConflictSources(index, found ?? ref)) {
-            result.push({ code: "EVENT_CONFLICT", reference: { type: "event", ref: event }, affectedObligations: affected });
-        }
-        if (!found)
-            result.push({ code: "REFERENCE_MISSING", reference: { type: "event", ref }, affectedObligations: affected });
-        for (const p of runtime.eventProblems.get(key(ref)) ?? [])
-            result.push({ ...p, affectedObligations: affected });
-        return mergeWorkProblems(result);
-    }
-    for (const row of structure.obligations) {
-        const binding = row.binding, affected = [binding.obligation];
-        const problem = (code, reference) => ({ code, reference, affectedObligations: affected });
-        const inventoryProblem = problem("ARTIFACT_UNSELECTED", { type: "revision", ref: binding.obligation });
-        const blockers = [...row.problems, ...(binding.artifact === null ? [inventoryProblem] : [])];
-        const selectedClaims = allClaims.filter(e => e.payload.binding.scope.id === snapshot.scope.id && e.payload.binding.obligation.id === binding.obligation.id);
-        const applicable = (claim) => {
-            const b = claim.payload.binding;
-            return key(b.snapshot) === key(structure.selectedSnapshot) && key(b.scope) === key(snapshot.scope) &&
-                key(b.intent) === key(binding.intent) && key(b.obligation) === key(binding.obligation) &&
-                key(b.artifact) === key(binding.artifact) && key(b.policy) === key(binding.policy);
-        };
-        const current = selectedClaims.filter(applicable);
-        const currentRefs = new Set(current.map(e => key(eventRef(e))));
-        for (const e of current)
-            if (eventConflicts.has(e.eventId)) {
-                blockers.push(...index.conflictingEvents.filter(ref => ref.eventId === e.eventId).map(ref => problem("EVENT_CONFLICT", { type: "event", ref })));
-            }
-        for (const [id, group] of receipts)
-            if (group.size > 1 && [...group.values()].some(d => currentRefs.has(key(d.claim)))) {
-                conflicts.push({ kind: "receipt", id, digests: unique(group.keys()), affectedObligations: affected });
-                blockers.push(problem("RECEIPT_CONFLICT", { type: "authority", ref: authority.snapshot }));
-            }
-        const artifactItems = row.artifact ? [available("artifact", row.artifact.id, row.artifact.contentDigest)] : [];
-        const artifactCoverage = binding.artifact === null ? { state: "unselected", items: [] } : coverage(artifactItems);
-        const evidenceCoverage = coverage(unique(current.flatMap(e => e.payload.binding.evidence.map(ref => available("evidence", ref.id, ref.digest)))));
-        function coverageProblems(items) {
-            return items.filter(item => item.state !== "available").map(item => problem(item.state === "conflicted" ? "AVAILABILITY_CONFLICT" : item.state === "unavailable" ? "BYTES_UNAVAILABLE" : "AVAILABILITY_MISSING", { type: item.kind === "artifact" ? "artifact-bytes" : "evidence-bytes", ref: item.identity }));
-        }
-        const rowClaims = [];
-        const trustedDecisions = new Set();
-        for (const claim of selectedClaims) {
-            if (eventConflicts.has(claim.eventId))
-                continue; // No first/last winner row, even for a favorable exact alternative.
-            if (!applicable(claim)) {
-                rowClaims.push({ claim: eventRef(claim), obligation: claim.payload.binding.obligation, applicability: "superseded",
-                    matchedReceiptIds: [], problems: [problem("SUPERSEDED_BINDING", eventReference(claim))] });
-                continue;
-            }
-            const b = claim.payload.binding;
-            const local = [];
-            const bytesMatch = row.artifact !== null && b.artifactDigest === row.artifact.contentDigest;
-            if (row.artifact && !bytesMatch)
-                local.push(problem("ARTIFACT_DIGEST_MISMATCH", { type: "artifact-bytes", ref: { id: row.artifact.id, digest: b.artifactDigest } }));
-            if (!row.artifact && binding.artifact)
-                local.push(problem("REFERENCE_MISSING", { type: "revision", ref: binding.artifact }));
-            const matching = decisions.filter(d => bytesMatch && key(d.claim) === key(eventRef(claim)) &&
-                d.authorityId === claim.payload.authorityId && key(d.binding) === key(b));
-            for (const d of matching)
-                trustedDecisions.add(d.decision);
-            if (!authority)
-                local.push(problem("AUTHORITY_MISSING", null));
-            else if (!matching.length)
-                local.push(problem(decisions.some(d => d.claim.eventId === claim.eventId) ? "RECEIPT_MISMATCH" : "RECEIPT_MISSING", eventReference(claim)));
-            const support = b.evidence.flatMap(ref => ref.event ? sourceProblems(ref.event, affected) : []);
-            const availabilityProblems = coverageProblems([...artifactItems, ...b.evidence.map(ref => available("evidence", ref.id, ref.digest))]);
-            local.push(...support, ...availabilityProblems);
-            // Only EXACT matching current trusted decisions root global support conflicts. Missing trust,
-            // wrong bytes and superseded/mismatched receipts cannot turn an unsupported sibling into a veto.
-            if (matching.length)
-                blockers.push(...support.filter(isConflict), ...availabilityProblems.filter(isConflict));
-            const rejection = matching.some(d => d.decision === "reject");
-            rowClaims.push({ claim: eventRef(claim), obligation: b.obligation,
-                applicability: rejection ? "unaccepted" : matching.some(d => d.decision === "accept") && local.length === 0 ? "accepted-under-supplied-authority" : "unresolved",
-                matchedReceiptIds: unique(matching.map(d => d.receiptId)),
-                problems: rejection ? [problem("TRUSTED_REJECTION", eventReference(claim))] : mergeWorkProblems(local),
-            });
-        }
-        if (trustedDecisions.size > 1)
-            blockers.push(problem("DECISION_CONFLICT", { type: "revision", ref: binding.obligation }));
-        const blocked = mergeWorkProblems(blockers);
-        for (const p of blocked)
-            if (p.code === "EVENT_CONFLICT" && p.reference?.type === "event") {
-                const id = p.reference.ref.eventId;
-                conflicts.push({ kind: "event", id, digests: index.conflictingEvents.filter(e => e.eventId === id).map(e => e.digest), affectedObligations: affected });
-            }
-        const finalClaims = rowClaims.map(c => blocked.length && c.applicability !== "superseded" ? { ...c, applicability: "unresolved", problems: blocked } : c);
-        const accepted = finalClaims.some(c => c.applicability === "accepted-under-supplied-authority");
-        const rejected = finalClaims.some(c => c.applicability === "unaccepted");
-        const unresolved = finalClaims.filter(c => c.applicability === "unresolved");
-        const acceptance = blocked.length ? "unresolved" : accepted ? "accepted-under-supplied-authority" : rejected ? "unaccepted" : unresolved.length ? "unresolved" : "unaccepted";
-        const obligationProblems = blocked.length ? blocked : accepted ? [] : rejected ?
-            finalClaims.filter(c => c.applicability === "unaccepted").flatMap(c => c.problems) : unresolved.length ? unresolved.flatMap(c => c.problems) :
-            [problem("NO_CLAIM", { type: "revision", ref: binding.obligation })];
-        obligations.push({ binding, acceptance, artifactCoverage, evidenceCoverage, claims: unique(finalClaims.map(c => c.claim)), problems: mergeWorkProblems(obligationProblems) });
-        claims.push(...finalClaims);
-        problems.push(...obligationProblems, ...finalClaims.flatMap(c => c.problems));
-    }
-    return { obligations: unique(obligations), claims: unique(claims), supersededClaims: claims.filter(c => c.applicability === "superseded").length,
-        conflicts: mergeWorkConflicts(conflicts), problems: mergeWorkProblems([...problems, ...runtime.problems]),
-        progress: { accepted: obligations.filter(o => o.acceptance === "accepted-under-supplied-authority").length, total: obligations.length },
-    };
-}
-//# sourceMappingURL=projection.js.map

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

@@ -1,24 +0,0 @@
-import { type WorkAcceptanceEvent, type WorkAcceptancePayload, type WorkFrozen, type WorkIngestion, type WorkOccurrenceEvent, type WorkOccurrencePayload, type WorkRevision, type WorkRevisionEvent, type WorkSnapshot, type WorkSnapshotEvent, type WorkProjectionContext, type WorkProjection } from "./types.js";
-export * from "./types.js";
-export declare function buildWorkRevisionEvent(args: {
-    eventId: string;
-    now: Date;
-    revision: Omit<WorkRevision, "digest">;
-}): WorkFrozen<WorkRevisionEvent>;
-export declare function buildWorkSnapshotEvent(args: {
-    eventId: string;
-    now: Date;
-    snapshot: Omit<WorkSnapshot, "digest">;
-}): WorkFrozen<WorkSnapshotEvent>;
-export declare function buildWorkOccurrenceEvent(args: {
-    eventId: string;
-    now: Date;
-    payload: WorkOccurrencePayload;
-}): WorkFrozen<WorkOccurrenceEvent>;
-export declare function buildWorkAcceptanceEvent(args: {
-    eventId: string;
-    now: Date;
-    payload: WorkAcceptancePayload;
-}): WorkFrozen<WorkAcceptanceEvent>;
-export declare function parseWorkLedgerText(text: string): WorkFrozen<WorkIngestion>;
-export declare function projectWorkLedger(text: string, context?: WorkFrozen<WorkProjectionContext>): WorkFrozen<WorkProjection>;

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

@@ -1,109 +0,0 @@
-// GENERATED from pi-daddy 7c78769c47177b1972b09e1f5c5474ad44cd2cac by scripts/vendor-work-v4-reader.mjs. Do not hand-edit.
-import { isDate } from "node:util/types";
-import { canonicalWorkJson, copyWorkJson, freezeWork, ownWorkFields, parseWorkJson, WORK_EVENT_BYTES, WORK_TEXT_BYTES, WORK_RECORDS, mergeWorkConflicts, } from "./json.js";
-import { validateWorkEvent, validateWorkContext } from "./validation.js";
-import { indexWorkLedgerText, indexWorkReceipts, projectWorkAcceptance } from "./projection.js";
-import { resolveWorkSnapshotText } from "./snapshot.js";
-import { foldWorkOccurrences } from "./occurrences.js";
-import { WorkInputError, } from "./types.js";
-export * from "./types.js";
-function build(args, kind, field) {
-    const fields = ownWorkFields(args);
-    const required = ["eventId", "now", field];
-    if (Object.keys(fields).length !== required.length || required.some(key => !Object.hasOwn(fields, key))) {
-        throw new WorkInputError("WORK_SCHEMA_INVALID");
-    }
-    const now = fields.now.value;
-    if (!isDate(now) || Object.getPrototypeOf(now) !== Date.prototype || Reflect.ownKeys(now).length !== 0 ||
-        !Number.isFinite(Date.prototype.getTime.call(now)))
-        throw new WorkInputError("WORK_SCHEMA_INVALID");
-    const content = copyWorkJson(fields[field].value);
-    const candidate = copyWorkJson({ ledgerVersion: 4, event: kind, eventId: fields.eventId.value,
-        ts: Date.prototype.toISOString.call(now), payload: field === "payload" ? content : { [field]: content } });
-    const event = validateWorkEvent(candidate, true);
-    if (Buffer.byteLength(canonicalWorkJson(event), "utf8") > WORK_EVENT_BYTES)
-        throw new WorkInputError("WORK_LIMIT_EXCEEDED");
-    return freezeWork(event);
-}
-export function buildWorkRevisionEvent(args) {
-    return build(args, "work_revision", "revision");
-}
-export function buildWorkSnapshotEvent(args) {
-    return build(args, "work_snapshot", "snapshot");
-}
-export function buildWorkOccurrenceEvent(args) {
-    return build(args, "work_occurrence", "payload");
-}
-export function buildWorkAcceptanceEvent(args) {
-    return build(args, "work_acceptance", "payload");
-}
-function* lines(text) {
-    let start = 0, line = 1;
-    while (start < text.length) {
-        const end = text.indexOf("\n", start);
-        yield { text: text.slice(start, end === -1 ? text.length : end), line: line++ };
-        if (end === -1)
-            return;
-        start = end + 1;
-    }
-}
-const blank = (text) => /^[ \t\r]*$/.test(text);
-export function parseWorkLedgerText(text) {
-    const wholeError = (code) => freezeWork({ events: [], errors: [{ line: null, code }], complete: false });
-    if (typeof text !== "string")
-        return wholeError("WORK_SCHEMA_INVALID");
-    if (Buffer.byteLength(text, "utf8") > WORK_TEXT_BYTES)
-        return wholeError("WORK_LIMIT_EXCEEDED");
-    let records = 0;
-    for (const row of lines(text))
-        if (!blank(row.text) && ++records > WORK_RECORDS)
-            return wholeError("WORK_LIMIT_EXCEEDED");
-    const events = [], errors = [];
-    for (const row of lines(text)) {
-        if (blank(row.text))
-            continue;
-        try {
-            events.push(validateWorkEvent(parseWorkJson(row.text)));
-        }
-        catch (error) {
-            if (!(error instanceof WorkInputError))
-                throw error;
-            errors.push({ line: row.line, code: error.code });
-        }
-    }
-    return freezeWork({ events, errors, complete: errors.length === 0 });
-}
-export function projectWorkLedger(text, context = { selectedSnapshot: null, authority: null }) {
-    const index = indexWorkLedgerText(text);
-    const errors = [...index.ingestion.errors];
-    let copied = null;
-    try {
-        const value = copyWorkJson(context);
-        validateWorkContext(value);
-        copied = JSON.parse(canonicalWorkJson(value));
-    }
-    catch (error) {
-        if (!(error instanceof WorkInputError))
-            throw error;
-        errors.push({ line: null, code: "WORK_CONTEXT_INVALID" });
-    }
-    errors.sort((a, b) => (a.line ?? Infinity) - (b.line ?? Infinity) || (a.code < b.code ? -1 : a.code > b.code ? 1 : 0));
-    const conflicts = mergeWorkConflicts([
-        ...index.conflictingEvents.map(ref => ({ kind: "event", id: ref.eventId, digests: [ref.digest], affectedObligations: [] })),
-        ...indexWorkReceipts(copied?.authority ?? null).conflicts,
-    ]);
-    const identities = { selectedSnapshot: copied?.selectedSnapshot?.snapshot ?? null, authoritySnapshot: copied?.authority?.snapshot ?? null };
-    function empty(scopeState, problems, retained = conflicts) {
-        return freezeWork({ ...identities, scopeState, progress: null, obligations: [], claims: [], supersededClaims: 0,
-            conflicts: mergeWorkConflicts([...retained, ...conflicts]), problems, errors, runtime: null });
-    }
-    if (errors.length)
-        return empty("unresolved", [{ code: "INPUT_INCOMPLETE", reference: null, affectedObligations: [] }]);
-    const structure = resolveWorkSnapshotText(text, copied.selectedSnapshot);
-    if (structure.scopeState !== "valid")
-        return empty(structure.scopeState, structure.problems, structure.conflicts);
-    const runtime = foldWorkOccurrences(index, structure.snapshot);
-    const acceptance = projectWorkAcceptance(index, structure, copied.authority, runtime);
-    return freezeWork({ ...identities, scopeState: "valid", ...acceptance, errors, runtime: runtime.runtime });
-}
-//# sourceMappingURL=reader.js.map

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

@@ -1,28 +0,0 @@
-import { type EventRef, type Identity, type ObligationBinding, type WorkConflict, type WorkDiagnostic, type WorkFrozen, type WorkProblem, type WorkRevision, type WorkSnapshot } from "./types.js";
-type Revision = WorkFrozen<WorkRevision>;
-type Problem = WorkFrozen<WorkProblem>;
-/** Internal shape of WorkProjectionContext.selectedSnapshot, not an authority context. */
-interface Selection {
-    snapshot: Identity;
-    event: EventRef;
-}
-/** Internal structural result only. Never a substitute for WorkProjection/acceptance/runtime. */
-interface SnapshotResolution {
-    readonly scopeState: "unselected" | "valid" | "unresolved" | "invalid";
-    readonly selectedSnapshot: WorkFrozen<Identity> | null;
-    readonly snapshot: WorkFrozen<WorkSnapshot> | null;
-    readonly scope: Revision | null;
-    readonly revisions: readonly Revision[];
-    readonly obligations: ReadonlyArray<{
-        readonly binding: WorkFrozen<ObligationBinding>;
-        readonly revision: Revision;
-        readonly artifact: Revision | null;
-        readonly problems: readonly Problem[];
-    }>;
-    readonly problems: readonly Problem[];
-    readonly conflicts: ReadonlyArray<WorkFrozen<WorkConflict>>;
-    readonly errors: ReadonlyArray<WorkFrozen<WorkDiagnostic>>;
-}
-/** @internal Real builder/text/index/selector path. No unchecked parsed-object projection entry. */
-export declare function resolveWorkSnapshotText(text: string, requested?: WorkFrozen<Selection> | null): SnapshotResolution;
-export {};