niceeval 0.12.2-canary.31 → 0.13.0

package/dist/assertions/record/diff.cjs

@@ -1,149 +1,560 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.agentWorkspaceDiffProjector = exports.agentWorkspaceDiffAttachmentFamilyV1 = exports.agentWorkspaceDiffAttachmentDefinitionV1 = exports.AgentWorkspaceDiffDocumentV1Schema = exports.AGENT_WORKSPACE_DIFF_ATTACHMENT_NAME_V1 = void 0;
-exports.assertAgentWorkspaceDiffRecordableV1 = assertAgentWorkspaceDiffRecordableV1;
-exports.createAgentWorkspaceDiffAttachmentWriteV1 = createAgentWorkspaceDiffAttachmentWriteV1;
+exports.createFileChangesCapture = createFileChangesCapture;
+exports.createEmptyFileChangesCapture = createEmptyFileChangesCapture;
+exports.createFileChangesCaptureAttachmentWrite = createFileChangesCaptureAttachmentWrite;
+exports.assertFileChangesCaptureRecordable = assertFileChangesCaptureRecordable;
+exports.createAgentWorkspaceDiffAttachmentWrite = createAgentWorkspaceDiffAttachmentWrite;
+exports.projectFileChangesAttachment = projectFileChangesAttachment;
+const node_crypto_1 = require("node:crypto");
 const effect_1 = require("effect");
-const diff_ts_1 = require("../diff.cjs");
-const workspace_diff_ts_1 = require("../workspace-diff.cjs");
-const diff_model_ts_1 = require("./diff-model.cjs");
 const index_ts_1 = require("../../record/attachment/index.cjs");
 const internal_ts_1 = require("../../record/attachment/internal.cjs");
-const projector_ts_1 = require("../../projection/projector.cjs");
-const limits_ts_1 = require("../../record/writer/limits.cjs");
-const attachment_payload_ts_1 = require("../../record/writer/attachment-payload.cjs");
-exports.AGENT_WORKSPACE_DIFF_ATTACHMENT_NAME_V1 = "niceeval.diff";
-const PositiveIntegerV1Schema = effect_1.Schema.Number.pipe(effect_1.Schema.int(), effect_1.Schema.positive());
-const DiffEndpointV1Schema = effect_1.Schema.Union(effect_1.Schema.Struct({ state: effect_1.Schema.Literal("absent") }), effect_1.Schema.Struct({ state: effect_1.Schema.Literal("text"), text: effect_1.Schema.String }), effect_1.Schema.Struct({
-    state: effect_1.Schema.Literal("elided"),
-    reason: effect_1.Schema.Literal("binary", "oversized-text"),
-    bytes: effect_1.Schema.optional(effect_1.Schema.Number.pipe(effect_1.Schema.int(), effect_1.Schema.nonNegative())),
-}));
-const DiffHunksV1Schema = effect_1.Schema.Struct({
-    added: effect_1.Schema.Array(effect_1.Schema.String),
-    removed: effect_1.Schema.Array(effect_1.Schema.String),
-});
-const DiffWindowChangeV1Schema = effect_1.Schema.Struct({
-    path: effect_1.Schema.String.pipe(effect_1.Schema.filter(diff_ts_1.isCanonicalWorkspaceRelativePath, {
-        identifier: "AgentWorkspaceDiffPath",
-        description: "a canonical non-empty workspace-relative path",
-    })),
-    status: effect_1.Schema.Literal("added", "modified", "deleted"),
-    before: DiffEndpointV1Schema,
-    after: DiffEndpointV1Schema,
-    hunks: DiffHunksV1Schema,
-});
-const DiffWindowV1Schema = effect_1.Schema.Struct({
-    identity: effect_1.Schema.Struct({
-        session: effect_1.Schema.optional(PositiveIntegerV1Schema),
-        turn: PositiveIntegerV1Schema,
-    }),
-    changes: effect_1.Schema.Array(DiffWindowChangeV1Schema),
-});
-const DiffPolicyV1Schema = effect_1.Schema.Struct({
-    defaultPolicy: effect_1.Schema.Literal("niceeval.sandbox-ledger/default-excludes/v1"),
-    include: effect_1.Schema.Array(effect_1.Schema.String),
-    ignore: effect_1.Schema.Array(effect_1.Schema.String),
+const core_ts_1 = require("../../record/codec/core.cjs");
+const catalog_ts_1 = require("../../record/family/catalog.cjs");
+const file_changes_ts_1 = require("../../record/family/file-changes.cjs");
+const workspace_diff_ts_1 = require("../workspace-diff.cjs");
+const encoder = new TextEncoder();
+const blobBudgetProjection = Object.freeze({
+    "$niceeval.record.blob-ref": true,
 });
-function documentHasUniqueWindowsAndPaths(document) {
-    const windows = new Set();
-    for (const window of document.windows) {
-        const key = `${window.identity.session ?? "primary"}\u0000${window.identity.turn}`;
-        if (windows.has(key))
-            return false;
-        windows.add(key);
-        const paths = new Set();
-        for (const change of window.changes) {
-            if (!(0, diff_ts_1.isCanonicalWorkspaceRelativePath)(change.path)
-                || !(0, workspace_diff_ts_1.agentWorkspaceDiffChangeIsCoherent)(change)
-                || paths.has(change.path))
-                return false;
-            paths.add(change.path);
+const captureSchemaBlobRef = (0, internal_ts_1.makeRecordBlobRef)();
+function compareAscii(left, right) {
+    return left === right ? 0 : left < right ? -1 : 1;
+}
+function freezeArray(values) {
+    return Object.freeze([...values]);
+}
+function nextChangeId() {
+    return `fc_${(0, node_crypto_1.randomUUID)().replaceAll("-", "")}`;
+}
+function sha256(bytes) {
+    return (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+}
+function canonicalStrings(values) {
+    return freezeArray([...new Set(values)].sort(compareAscii));
+}
+function captureAttribution(policy) {
+    return Object.freeze({
+        kind: "agent-send-window-endpoints",
+        policy: Object.freeze({
+            defaultPolicy: policy.defaultPolicy,
+            include: canonicalStrings(policy.include),
+            ignore: canonicalStrings(policy.ignore),
+        }),
+    });
+}
+function limitationKeyWithoutCount(limitation) {
+    return [limitation.code, limitation.target, limitation.atWindowId ?? ""].join("\u0000");
+}
+/** Merge count-bearing limitations while keeping exact failures deterministically unique. */
+function canonicalLimitations(values) {
+    const exact = new Map();
+    const caps = new Map();
+    let unsupported = 0;
+    for (const limitation of values) {
+        switch (limitation.code) {
+            case "capture-failed":
+            case "capture-interrupted": {
+                exact.set((0, file_changes_ts_1.fileChangesCollectionLimitationKey)(limitation), limitation);
+                break;
+            }
+            case "collection-cap-reached": {
+                const key = limitationKeyWithoutCount(limitation);
+                const prior = caps.get(key);
+                caps.set(key, Object.freeze({
+                    ...limitation,
+                    omittedAtLeast: (prior?.omittedAtLeast ?? 0) + limitation.omittedAtLeast,
+                }));
+                break;
+            }
+            case "unsupported-input":
+                unsupported += limitation.omittedAtLeast;
+                break;
+        }
+    }
+    if (unsupported > 0) {
+        exact.set("unsupported-input\u0000endpoint-metadata", Object.freeze({
+            code: "unsupported-input",
+            target: "endpoint-metadata",
+            omittedAtLeast: unsupported,
+        }));
+    }
+    const merged = [...exact.values(), ...caps.values()];
+    return freezeArray(merged.sort((left, right) => compareAscii((0, file_changes_ts_1.fileChangesCollectionLimitationKey)(left), (0, file_changes_ts_1.fileChangesCollectionLimitationKey)(right))));
+}
+function collectionState(limitations) {
+    const canonical = canonicalLimitations(limitations);
+    return canonical.length === 0
+        ? Object.freeze({ state: "complete", limitations: Object.freeze([]) })
+        : Object.freeze({ state: "partial", limitations: canonical });
+}
+function capLimitation(target, omittedAtLeast, atWindowId) {
+    return Object.freeze({
+        code: "collection-cap-reached",
+        target,
+        omittedAtLeast,
+        atWindowId,
+    });
+}
+function unsupportedInputLimitation(omittedAtLeast) {
+    return Object.freeze({
+        code: "unsupported-input",
+        target: "endpoint-metadata",
+        omittedAtLeast,
+    });
+}
+function endpointIsPresent(endpoint) {
+    return endpoint.state !== "absent";
+}
+function sourceChangeIsCoherent(change) {
+    const beforePresent = endpointIsPresent(change.before);
+    const afterPresent = endpointIsPresent(change.after);
+    switch (change.status) {
+        case "added":
+            return !beforePresent && afterPresent;
+        case "modified":
+            return beforePresent && afterPresent;
+        case "deleted":
+            return beforePresent && !afterPresent;
+    }
+}
+function endpointForCapture(endpoint) {
+    switch (endpoint.state) {
+        case "absent":
+            return Object.freeze({ endpoint: Object.freeze({ state: "absent" }), unsupportedEndpointCount: 0 });
+        case "text": {
+            if (typeof endpoint.text !== "string") {
+                return Object.freeze({
+                    endpoint: Object.freeze({
+                        state: "present",
+                        revision: Object.freeze({ kind: "unavailable", reason: "unsupported-input" }),
+                    }),
+                    unsupportedEndpointCount: 1,
+                });
+            }
+            const content = encoder.encode(endpoint.text);
+            if (content.byteLength > file_changes_ts_1.FileChangesLimits.maximumTextRevisionBytes) {
+                return Object.freeze({
+                    endpoint: Object.freeze({
+                        state: "present",
+                        revision: Object.freeze({
+                            kind: "elided",
+                            reason: "oversized-text",
+                            byteLength: content.byteLength,
+                        }),
+                    }),
+                    unsupportedEndpointCount: 0,
+                });
+            }
+            return Object.freeze({
+                endpoint: Object.freeze({
+                    state: "present",
+                    revision: Object.freeze({
+                        kind: "text",
+                        sha256: sha256(content),
+                        byteLength: content.byteLength,
+                        content: Object.freeze({ state: "available", text: endpoint.text }),
+                    }),
+                }),
+                unsupportedEndpointCount: 0,
+            });
+        }
+        case "elided": {
+            const byteLength = endpoint.bytes;
+            if ((endpoint.reason !== "binary" && endpoint.reason !== "oversized-text")
+                || !Number.isSafeInteger(byteLength)
+                || byteLength === undefined
+                || byteLength < 0) {
+                return Object.freeze({
+                    endpoint: Object.freeze({
+                        state: "present",
+                        revision: Object.freeze({ kind: "unavailable", reason: "unsupported-input" }),
+                    }),
+                    unsupportedEndpointCount: 1,
+                });
+            }
+            return Object.freeze({
+                endpoint: Object.freeze({
+                    state: "present",
+                    revision: Object.freeze({
+                        kind: "elided",
+                        reason: endpoint.reason,
+                        byteLength,
+                    }),
+                }),
+                unsupportedEndpointCount: 0,
+            });
+        }
+    }
+}
+function prepareChange(change) {
+    if (!sourceChangeIsCoherent(change)) {
+        throw new Error("File Changes collector received an incoherent send-window endpoint transition");
+    }
+    const before = endpointForCapture(change.before);
+    const after = endpointForCapture(change.after);
+    const kind = change.status === "added"
+        ? "created"
+        : change.status === "deleted"
+            ? "deleted"
+            : "modified";
+    return Object.freeze({
+        path: change.path,
+        kind,
+        before: before.endpoint,
+        after: after.endpoint,
+        unsupportedEndpointCount: before.unsupportedEndpointCount + after.unsupportedEndpointCount,
+    });
+}
+function captureWindowId(window) {
+    const identity = window.identity;
+    if (!Number.isSafeInteger(identity.turn)
+        || identity.turn <= 0
+        || (identity.session !== undefined && (!Number.isSafeInteger(identity.session) || identity.session <= 0))) {
+        throw new Error("File Changes collector received an invalid send-window identity");
+    }
+    return (0, workspace_diff_ts_1.agentSendWindowId)(identity);
+}
+function structuralCapture(source) {
+    const limitations = [];
+    const retainedWindowCount = Math.min(source.windows.length, file_changes_ts_1.FileChangesLimits.maximumWindows);
+    if (source.windows.length > retainedWindowCount) {
+        const firstOmitted = source.windows[retainedWindowCount];
+        limitations.push(capLimitation("window", source.windows.length - retainedWindowCount, firstOmitted === undefined ? null : captureWindowId(firstOmitted)));
+    }
+    const windowIds = new Set();
+    const preparedWindows = [];
+    for (let index = 0; index < retainedWindowCount; index += 1) {
+        const sourceWindow = source.windows[index];
+        const windowId = captureWindowId(sourceWindow);
+        if (windowIds.has(windowId)) {
+            throw new Error("File Changes collector received duplicate send-window ids");
+        }
+        windowIds.add(windowId);
+        const changes = [...sourceWindow.changes]
+            .sort((left, right) => compareAscii(left.path, right.path));
+        for (let changeIndex = 1; changeIndex < changes.length; changeIndex += 1) {
+            if (changes[changeIndex - 1].path === changes[changeIndex].path) {
+                throw new Error(`File Changes collector received duplicate path ${JSON.stringify(changes[changeIndex].path)} in ${windowId}`);
+            }
+        }
+        const prepared = changes.map(prepareChange);
+        if (prepared.length > file_changes_ts_1.FileChangesLimits.maximumChangesPerWindow) {
+            limitations.push(capLimitation("change", prepared.length - file_changes_ts_1.FileChangesLimits.maximumChangesPerWindow, windowId));
         }
+        preparedWindows.push(Object.freeze({
+            windowId,
+            sequence: index + 1,
+            changes: freezeArray(prepared.slice(0, file_changes_ts_1.FileChangesLimits.maximumChangesPerWindow)),
+        }));
     }
-    return true;
-}
-exports.AgentWorkspaceDiffDocumentV1Schema = effect_1.Schema.Struct({
-    attribution: effect_1.Schema.Literal(diff_model_ts_1.AGENT_WORKSPACE_DIFF_ATTRIBUTION_V1),
-    policy: DiffPolicyV1Schema,
-    windows: effect_1.Schema.Array(DiffWindowV1Schema),
-}).pipe(effect_1.Schema.filter(documentHasUniqueWindowsAndPaths, {
-    identifier: "AgentWorkspaceDiffDocument",
-    description: "unique agent send windows with one valid endpoint delta per path",
-}));
-function requireDefinition(result, message) {
-    if (effect_1.Either.isLeft(result))
-        throw new Error(message);
-    return result.right;
-}
-/** Attempt-owned, exact, agent-attributed send-window endpoint document. */
-exports.agentWorkspaceDiffAttachmentDefinitionV1 = requireDefinition((0, internal_ts_1.defineBuiltinJsonRecordAttachment)({
-    owner: "attempt",
-    name: exports.AGENT_WORKSPACE_DIFF_ATTACHMENT_NAME_V1,
-    schemaId: "niceeval.diff/v1",
-    schema: exports.AgentWorkspaceDiffDocumentV1Schema,
-    blobRefs: () => Object.freeze([]),
-}), "Agent workspace diff v1 RecordAttachment definition must be valid");
-/** v1 has no invented future migration edge; adjacent edges appear only with a real next schema. */
-exports.agentWorkspaceDiffAttachmentFamilyV1 = requireDefinition((0, index_ts_1.defineRecordAttachmentFamily)({
-    current: exports.agentWorkspaceDiffAttachmentDefinitionV1,
-    migrations: [],
-}), "Agent workspace diff v1 RecordAttachment family must be valid");
-const noDiffBlobDraftsV1 = Object.freeze([]);
-/**
- * The generic writer enforces this limit only after a draft has started to
- * write. Diff is a post-run producer, so reject an oversized canonical
- * payload before it becomes available to Assertions or reaches that writer.
- */
-function assertDiffPayloadFitsRecordJsonLimit(document) {
-    const payload = (0, index_ts_1.encodeJsonRecordAttachmentPayload)(exports.agentWorkspaceDiffAttachmentDefinitionV1, document);
-    if (effect_1.Either.isLeft(payload)) {
-        throw new Error("Agent workspace diff v1 payload could not be canonically encoded");
-    }
-    // v1 declares no blobs, so the writer will allocate the same empty key map.
-    // Run the actual storage conversion and serializer here: this is the exact
-    // final `payload.json` byte sequence rather than an estimate of the source
-    // document's size.
-    const storedPayload = (0, attachment_payload_ts_1.encodeAttachmentPayloadForStorage)({
-        payload: payload.right,
-        blobKeys: new Map(),
+    let remainingChanges = file_changes_ts_1.FileChangesLimits.maximumRetainedChanges;
+    const capturedWindows = preparedWindows.map((window) => {
+        const retained = Math.min(window.changes.length, remainingChanges);
+        if (retained < window.changes.length) {
+            limitations.push(capLimitation("change", window.changes.length - retained, window.windowId));
+        }
+        remainingChanges -= retained;
+        return Object.freeze({
+            windowId: window.windowId,
+            sequence: window.sequence,
+            changes: freezeArray(window.changes.slice(0, retained).map((change) => Object.freeze({
+                ...change,
+                changeId: nextChangeId(),
+            }))),
+        });
+    });
+    return Object.freeze({ windows: freezeArray(capturedWindows), limitations: freezeArray(limitations) });
+}
+function unsupportedLimitationsFor(windows) {
+    const unsupported = windows.reduce((total, window) => total + window.changes.reduce((windowTotal, change) => windowTotal + change.unsupportedEndpointCount, 0), 0);
+    return unsupported === 0 ? Object.freeze([]) : Object.freeze([unsupportedInputLimitation(unsupported)]);
+}
+function omitTextContent(endpoint) {
+    if (endpoint.state !== "present"
+        || endpoint.revision.kind !== "text"
+        || endpoint.revision.content.state !== "available") {
+        return endpoint;
+    }
+    return Object.freeze({
+        state: "present",
+        revision: Object.freeze({
+            ...endpoint.revision,
+            content: Object.freeze({ state: "omitted", reason: "collection-cap" }),
+        }),
+    });
+}
+function withBlobCaps(windows) {
+    let blobCount = 0;
+    let totalBytes = 0;
+    const limitations = [];
+    const consume = (endpoint, windowId) => {
+        if (endpoint.state !== "present"
+            || endpoint.revision.kind !== "text"
+            || endpoint.revision.content.state !== "available") {
+            return endpoint;
+        }
+        if (endpoint.revision.byteLength > file_changes_ts_1.FileChangesLimits.maximumBlobBytes) {
+            throw new Error("File Changes producer retained a text revision beyond its blob limit");
+        }
+        if (blobCount >= file_changes_ts_1.FileChangesLimits.maximumBlobs) {
+            limitations.push(capLimitation("content-blob", 1, windowId));
+            return omitTextContent(endpoint);
+        }
+        if (totalBytes + endpoint.revision.byteLength > file_changes_ts_1.FileChangesLimits.maximumTotalBlobBytes) {
+            limitations.push(capLimitation("content-byte", 1, windowId));
+            return omitTextContent(endpoint);
+        }
+        blobCount += 1;
+        totalBytes += endpoint.revision.byteLength;
+        return endpoint;
+    };
+    const capped = windows.map((window) => Object.freeze({
+        ...window,
+        changes: freezeArray(window.changes.map((change) => Object.freeze({
+            ...change,
+            before: consume(change.before, window.windowId),
+            after: consume(change.after, window.windowId),
+        }))),
+    }));
+    return Object.freeze({ windows: freezeArray(capped), limitations: freezeArray(limitations) });
+}
+function previewEndpoint(endpoint) {
+    if (endpoint.state === "absent")
+        return Object.freeze({ state: "absent" });
+    const revision = endpoint.revision;
+    switch (revision.kind) {
+        case "text":
+            return Object.freeze({
+                state: "present",
+                revision: Object.freeze({
+                    kind: "text",
+                    sha256: revision.sha256,
+                    byteLength: revision.byteLength,
+                    content: revision.content.state === "available"
+                        ? Object.freeze({ state: "available", ref: blobBudgetProjection })
+                        : Object.freeze({ state: "omitted", reason: "collection-cap" }),
+                }),
+            });
+        case "elided":
+            return Object.freeze({
+                state: "present",
+                revision: Object.freeze({
+                    kind: "elided",
+                    reason: revision.reason,
+                    byteLength: revision.byteLength,
+                }),
+            });
+        case "unavailable":
+            return Object.freeze({
+                state: "present",
+                revision: Object.freeze({ kind: "unavailable", reason: revision.reason }),
+            });
+    }
+}
+function previewPayload(capture) {
+    return Object.freeze({
+        "attribution-data": capture.attribution,
+        "collection-data": capture.collection,
+        "windows-data": freezeArray(capture.windows.map((window) => Object.freeze({
+            windowId: window.windowId,
+            sequence: window.sequence,
+            changes: freezeArray(window.changes.map((change) => Object.freeze({
+                changeId: change.changeId,
+                path: change.path,
+                kind: change.kind,
+                before: previewEndpoint(change.before),
+                after: previewEndpoint(change.after),
+            }))),
+        }))),
+    });
+}
+function jsonByteLength(capture) {
+    const text = JSON.stringify(previewPayload(capture));
+    if (text === undefined)
+        throw new Error("File Changes producer could not serialize its JSON budget projection");
+    return encoder.encode(text).byteLength;
+}
+function trimLastChange(windows) {
+    for (let windowIndex = windows.length - 1; windowIndex >= 0; windowIndex -= 1) {
+        const window = windows[windowIndex];
+        if (window.changes.length === 0)
+            continue;
+        const next = [...windows];
+        next[windowIndex] = Object.freeze({
+            ...window,
+            changes: freezeArray(window.changes.slice(0, -1)),
+        });
+        return Object.freeze({ windows: freezeArray(next), atWindowId: window.windowId });
+    }
+    return undefined;
+}
+function captureFrom(source, callerLimitations) {
+    if (source.attribution !== "agent-send-window-endpoints") {
+        throw new Error("File Changes capture received an unsupported workspace attribution");
+    }
+    const attribution = captureAttribution(source.policy);
+    const structural = structuralCapture(source);
+    let windows = structural.windows;
+    let jsonOmitted = 0;
+    let jsonAtWindowId = null;
+    for (;;) {
+        const blobCapped = withBlobCaps(windows);
+        const limitations = [
+            ...callerLimitations,
+            ...structural.limitations,
+            ...unsupportedLimitationsFor(windows),
+            ...blobCapped.limitations,
+            ...(jsonOmitted === 0 ? [] : [capLimitation("json-byte", jsonOmitted, jsonAtWindowId)]),
+        ];
+        const capture = Object.freeze({
+            attribution,
+            collection: collectionState(limitations),
+            windows: blobCapped.windows,
+        });
+        if (jsonByteLength(capture) <= file_changes_ts_1.FileChangesLimits.maximumPayloadJsonBytes) {
+            assertFileChangesCaptureSchema(capture);
+            return capture;
+        }
+        const trimmed = trimLastChange(windows);
+        if (trimmed === undefined) {
+            throw new Error("File Changes producer cannot fit its structural payload within the JSON budget");
+        }
+        windows = trimmed.windows;
+        jsonOmitted += 1;
+        // Trimming walks backward, so the final removed entry is the first omitted prefix entry.
+        jsonAtWindowId = trimmed.atWindowId;
+    }
+}
+/** Freeze a normal or partial collector result before any Record preflight/write. */
+function createFileChangesCapture(input) {
+    return captureFrom(input.document, input.limitations ?? Object.freeze([]));
+}
+/** A started collector may have no safe export prefix but must still publish an honest partial capture. */
+function createEmptyFileChangesCapture(input) {
+    return captureFrom(Object.freeze({
+        attribution: "agent-send-window-endpoints",
+        policy: input.policy,
+        windows: Object.freeze([]),
+    }), input.limitations);
+}
+function durableEndpoint(endpoint, availableContent) {
+    if (endpoint.state === "absent")
+        return Object.freeze({ state: "absent" });
+    const revision = endpoint.revision;
+    switch (revision.kind) {
+        case "text":
+            return Object.freeze({
+                state: "present",
+                revision: Object.freeze({
+                    kind: "text",
+                    sha256: revision.sha256,
+                    byteLength: revision.byteLength,
+                    content: revision.content.state === "available"
+                        ? availableContent(revision)
+                        : Object.freeze({ state: "omitted", reason: "collection-cap" }),
+                }),
+            });
+        case "elided":
+            return Object.freeze({
+                state: "present",
+                revision: Object.freeze({
+                    kind: "elided",
+                    reason: revision.reason,
+                    byteLength: revision.byteLength,
+                }),
+            });
+        case "unavailable":
+            return Object.freeze({
+                state: "present",
+                revision: Object.freeze({ kind: "unavailable", reason: revision.reason }),
+            });
+    }
+}
+function assertFileChangesCaptureSchema(capture) {
+    const preview = Object.freeze({
+        attribution: capture.attribution,
+        collection: capture.collection,
+        windows: freezeArray(capture.windows.map((window) => Object.freeze({
+            windowId: window.windowId,
+            sequence: window.sequence,
+            changes: freezeArray(window.changes.map((change) => Object.freeze({
+                changeId: change.changeId,
+                path: change.path,
+                kind: change.kind,
+                before: durableEndpoint(change.before, () => Object.freeze({
+                    state: "available",
+                    ref: captureSchemaBlobRef,
+                })),
+                after: durableEndpoint(change.after, () => Object.freeze({
+                    state: "available",
+                    ref: captureSchemaBlobRef,
+                })),
+            }))),
+        }))),
+    });
+    const decoded = effect_1.Schema.validateEither(file_changes_ts_1.FileChangesAttachmentSchema, core_ts_1.RecordExactParseOptions)(preview);
+    if (effect_1.Either.isLeft(decoded)) {
+        throw new Error("File Changes producer generated an invalid fixed-family capture");
+    }
+}
+/** Convert a frozen capture to a fresh Record write without minting another change id. */
+function createFileChangesCaptureAttachmentWrite(capture) {
+    const write = (0, index_ts_1.makeFixedRecordAttachmentWrite)(catalog_ts_1.fileChangesRecordFamily.write, (blobs) => {
+        const drafts = [];
+        const availableContent = (revision) => {
+            const content = encoder.encode(revision.content.state === "available" ? revision.content.text : "");
+            if (revision.content.state !== "available"
+                || content.byteLength !== revision.byteLength
+                || sha256(content) !== revision.sha256) {
+                throw new Error("File Changes producer lost frozen text revision integrity");
+            }
+            const draft = blobs.add((0, index_ts_1.makeRecordBlobSource)(effect_1.Stream.succeed(content)));
+            drafts.push(draft);
+            return Object.freeze({ state: "available", ref: draft.ref });
+        };
+        const payload = Object.freeze({
+            attribution: capture.attribution,
+            collection: capture.collection,
+            windows: freezeArray(capture.windows.map((window) => Object.freeze({
+                windowId: window.windowId,
+                sequence: window.sequence,
+                changes: freezeArray(window.changes.map((change) => Object.freeze({
+                    changeId: change.changeId,
+                    path: change.path,
+                    kind: change.kind,
+                    before: durableEndpoint(change.before, availableContent),
+                    after: durableEndpoint(change.after, availableContent),
+                }))),
+            }))),
+        });
+        const decoded = effect_1.Schema.validateEither(file_changes_ts_1.FileChangesAttachmentSchema, core_ts_1.RecordExactParseOptions)(payload);
+        if (effect_1.Either.isLeft(decoded)) {
+            throw new Error("File Changes producer generated an invalid fixed-family payload");
+        }
+        return Object.freeze({ payload: decoded.right, blobs: freezeArray(drafts) });
     });
-    if (effect_1.Either.isLeft(storedPayload)) {
-        throw new Error("Agent workspace diff v1 payload could not be stored");
-    }
-    const bytes = (0, attachment_payload_ts_1.encodeRecordAttachmentJsonBytes)(storedPayload.right).byteLength;
-    if (bytes > limits_ts_1.RECORD_JSON_MAXIMUM_BYTES) {
-        throw new Error(`Agent workspace diff v1 payload is ${bytes} bytes; Record JSON limit is ${limits_ts_1.RECORD_JSON_MAXIMUM_BYTES} bytes`);
-    }
-}
-/**
- * Checks the exact v1 Record representation while the Runner can still treat
- * an oversized supplemental diff as unavailable. Waiting until Evaluation
- * publication would turn one optional evidence failure into a fatal Run-wide
- * write error after every Attempt has already settled.
- */
-function assertAgentWorkspaceDiffRecordableV1(value) {
-    assertDiffPayloadFitsRecordJsonLimit((0, diff_model_ts_1.encodeAgentWorkspaceDiffDocumentV1)(value));
-}
-/**
- * Captures the exact frozen semantic object held by post-run evaluators. The
- * no-blob v1 representation is intentionally small enough for normal ledger
- * exports; a future adjacent schema may move endpoint text into this owner's
- * own blobs without changing Assertions' reference shape.
- */
-function createAgentWorkspaceDiffAttachmentWriteV1(value) {
-    const document = (0, diff_model_ts_1.encodeAgentWorkspaceDiffDocumentV1)(value);
-    assertDiffPayloadFitsRecordJsonLimit(document);
-    const write = (0, index_ts_1.makeRecordAttachmentWrite)(exports.agentWorkspaceDiffAttachmentFamilyV1, () => Object.freeze({ payload: document, blobs: noDiffBlobDraftsV1 }));
     const closure = (0, index_ts_1.validateRecordAttachmentWrite)(write);
     if (effect_1.Either.isLeft(closure)) {
-        throw new Error("Agent workspace diff v1 RecordAttachment write was invalid");
+        throw new Error("File Changes producer generated an invalid owner-local closure");
     }
     return write;
 }
-/** A neutral typed projector available to scripts and any Report, with no privileged consumer. */
-exports.agentWorkspaceDiffProjector = (0, projector_ts_1.defineRecordAttachmentProjector)({
-    attachment: exports.agentWorkspaceDiffAttachmentFamilyV1,
-    project: (value) => (0, diff_model_ts_1.decodeAgentWorkspaceDiffDocumentV1)(value.payload),
-});
+/** Preflight validates the same frozen ids and closure shape that the Attempt writer will publish. */
+function assertFileChangesCaptureRecordable(capture) {
+    createFileChangesCaptureAttachmentWrite(capture);
+}
+/** Internal assertion-seal bridge; Runner itself retains the frozen capture, never this convenience path. */
+function createAgentWorkspaceDiffAttachmentWrite(document) {
+    return createFileChangesCaptureAttachmentWrite(createFileChangesCapture({ document }));
+}
+/** Pure projection for consumers already holding a decoded durable payload. */
+function projectFileChangesAttachment(payload) {
+    return Object.freeze({
+        attribution: payload.attribution,
+        collection: payload.collection,
+        windows: freezeArray(payload.windows),
+    });
+}
 //# sourceMappingURL=diff.cjs.map