niceeval 0.12.2-canary.31 → 0.13.1

package/dist/runner/source-producer.cjs

@@ -3,10 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.retainRunnerAttemptSourceCapture = retainRunnerAttemptSourceCapture;
 exports.createRunnerAttemptSourceCapture = createRunnerAttemptSourceCapture;
 exports.createRunnerSourceWritePlan = createRunnerSourceWritePlan;
+exports.createRunnerSourceNavigationWrite = createRunnerSourceNavigationWrite;
 const node_crypto_1 = require("node:crypto");
 const effect_1 = require("effect");
 const internal_ts_1 = require("../record/attachment/internal.cjs");
+const identifiers_ts_1 = require("../record/codec/identifiers.cjs");
+const core_ts_1 = require("../record/codec/core.cjs");
+const assertions_ts_1 = require("../record/family/assertions.cjs");
+const source_navigation_ts_1 = require("../record/family/source-navigation.cjs");
+const catalog_ts_1 = require("../record/family/catalog.cjs");
 const runtime_ts_1 = require("../assertions/runtime.cjs");
+const runner_producer_ts_1 = require("../o11y/record/runner-producer.cjs");
 const source_loc_ts_1 = require("../source-loc.cjs");
 const attachment_ts_1 = require("../sources/attachment.cjs");
 const codec_ts_1 = require("../sources/codec.cjs");
@@ -49,6 +56,7 @@ function sourceCaptureFrom(registry, nextSourceOrder) {
 function createRunnerAttemptSourceCapture(registry) {
     let sourceOrder = 0;
     const sends = [];
+    let omittedAtLeast = 0;
     let assertionsRuntime;
     const nextSourceOrder = () => ++sourceOrder;
     return Object.freeze({
@@ -63,19 +71,14 @@ function createRunnerAttemptSourceCapture(registry) {
             assertionsRuntime = runtime;
         },
         onTurn(input) {
-            if (input.loc === undefined || input.sourceOrder === undefined)
+            if (input.turnId === undefined) {
+                omittedAtLeast += 1;
                 return;
-            const site = Object.freeze({
-                location: cloneLocation(input.loc),
-                sourceOrder: input.sourceOrder,
-            });
+            }
             sends.push(Object.freeze({
-                site,
-                terminal: Object.freeze({
-                    label: input.label,
-                    status: input.failed ? "failed" : "completed",
-                    durationMs: input.durationMs,
-                }),
+                turnId: input.turnId,
+                sourceOrder: input.sourceOrder ?? null,
+                location: input.loc === undefined ? undefined : cloneLocation(input.loc),
             }));
         },
         markInterrupted() {
@@ -89,10 +92,8 @@ function createRunnerAttemptSourceCapture(registry) {
                 : (0, runtime_ts_1.assertionsRuntimeSourceCaptureSnapshot)(assertionsRuntime);
             return Object.freeze({
                 entries: assertions?.entries ?? Object.freeze([]),
-                sends: Object.freeze(sends.map((send) => Object.freeze({
-                    site: send.site,
-                    terminal: send.terminal,
-                }))),
+                sends: Object.freeze(sends.map((send) => Object.freeze({ ...send }))),
+                omittedAtLeast,
             });
         },
     });
@@ -101,34 +102,22 @@ function invalid(reason) {
     return Object.freeze({ code: "runner-source-producer-invalid", reason });
 }
 function canonicalPath(path) {
-    const decoded = effect_1.Schema.decodeUnknownEither(codec_ts_1.CanonicalSourcePathV1Schema, codec_ts_1.SourcesExactParseOptions)(path);
+    const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.CanonicalProjectRelativePathSchema, core_ts_1.RecordExactParseOptions)(path);
     return effect_1.Either.isRight(decoded) ? decoded.right : undefined;
 }
 function sourceSnapshot(value) {
     const path = canonicalPath(value.path);
-    if (path === undefined || !(0, codec_ts_1.isStrictUnicodeTextV1)(value.content))
+    if (path === undefined || !(0, codec_ts_1.isStrictUnicodeText)(value.content))
         return undefined;
-    return Object.freeze({ path, text: (0, codec_ts_1.canonicalizeSourceTextV1)(value.content) });
-}
-function stableFileKey(path) {
-    return path;
-}
-function packageId() {
-    return `sp_${(0, node_crypto_1.randomBytes)(10).toString("hex")}`;
+    return Object.freeze({ path, text: (0, codec_ts_1.canonicalizeSourceText)(value.content) });
 }
-function fileId() {
-    return `sf_${(0, node_crypto_1.randomBytes)(10).toString("hex")}`;
-}
-function sourceFrames(location) {
-    return Object.freeze([
-        ...(location.callers ?? []),
-        Object.freeze({
-            kind: "project",
-            file: location.file,
-            line: location.line,
-            ...(location.column === undefined ? {} : { column: location.column }),
-        }),
-    ]);
+function sourceItemId() {
+    const candidate = `src_${(0, node_crypto_1.randomBytes)(10).toString("hex")}`;
+    const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.SourceItemIdSchema, core_ts_1.RecordExactParseOptions)(candidate);
+    if (effect_1.Either.isLeft(decoded)) {
+        throw new Error("Runner generated an invalid Sources item identity");
+    }
+    return decoded.right;
 }
 function coordinateFor(text, line, column) {
     if (!Number.isSafeInteger(line) || line < 1 || column === undefined || !Number.isSafeInteger(column) || column < 1) {
@@ -144,274 +133,225 @@ function coordinateFor(text, line, column) {
     return Object.freeze({ line, column: new TextEncoder().encode(before).byteLength + 1 });
 }
 function manifestLookup(document) {
-    const packages = new Map();
     const files = new Map();
-    for (const sourcePackage of document.packages) {
-        packages.set(sourcePackage.label, sourcePackage.packageItemId);
-        for (const file of sourcePackage.files) {
-            files.set(stableFileKey(file.path), {
-                packageItemId: sourcePackage.packageItemId,
-                fileItemId: file.fileItemId,
-                sha256: file.sha256,
-                // The producer supplies the exact same canonical text separately.
-                text: "",
-            });
-        }
+    for (const item of document.items) {
+        files.set(item.path, {
+            sourceItemId: item.sourceItemId,
+            sha256: item.sha256,
+            // The producer supplies the exact same canonical text separately.
+            text: "",
+        });
     }
-    return Object.freeze({ packages, files });
+    return Object.freeze({ files });
 }
-function assertionEntryIds(write) {
-    const contents = (0, internal_ts_1.recordAttachmentWriteContents)(write);
-    return effect_1.Either.isLeft(contents)
-        ? effect_1.Either.left(invalid("assertions-closure-invalid"))
-        : effect_1.Either.right(Object.freeze(contents.right.payload.entries.map((entry) => entry.entryId)));
-}
-function sourceTrace(location, localFiles, lookup) {
-    const runtimeFrames = sourceFrames(location);
-    const projectIndexes = runtimeFrames
-        .map((frame, index) => frame.kind === "project" ? index : -1)
-        .filter((index) => index >= 0);
-    const first = projectIndexes[0];
-    const last = projectIndexes.at(-1);
-    if (first === undefined || last === undefined)
+function sourceSite(input, localFiles, lookup) {
+    const path = canonicalPath(input.location.file);
+    if (path === undefined)
         return undefined;
-    const durableFrames = [];
-    for (const frame of runtimeFrames.slice(first, last + 1)) {
-        if (frame.kind === "package") {
-            const packageItemId = lookup.packages.get(frame.package);
-            if (packageItemId === undefined)
-                return undefined;
-            durableFrames.push(Object.freeze({ target: Object.freeze({ kind: "package", packageItemId }) }));
-            continue;
-        }
-        const path = canonicalPath(frame.file);
-        if (path === undefined)
-            return undefined;
-        const local = localFiles.get(stableFileKey(path));
-        const sourceFile = lookup.files.get(stableFileKey(path));
-        if (local === undefined || sourceFile === undefined || sourceFile.text !== local)
-            return undefined;
-        const coordinate = coordinateFor(local, frame.line, frame.column);
-        if (coordinate === undefined)
-            return undefined;
-        durableFrames.push(Object.freeze({
-            target: Object.freeze({
-                kind: "file",
-                packageItemId: sourceFile.packageItemId,
-                fileItemId: sourceFile.fileItemId,
-                sha256: sourceFile.sha256,
-            }),
-            coordinate,
-        }));
-    }
-    const firstFrame = durableFrames[0];
-    const lastFrame = durableFrames.at(-1);
-    if (!isSourceFileFrame(firstFrame) || !isSourceFileFrame(lastFrame))
+    const local = localFiles.get(path);
+    const source = lookup.files.get(path);
+    if (local === undefined || source === undefined || source.text !== local)
         return undefined;
-    if (durableFrames.length === 1) {
-        const singleFrame = [firstFrame];
-        return Object.freeze({ frames: Object.freeze(singleFrame) });
-    }
-    const middle = durableFrames.slice(1, -1);
-    const traceFrames = [firstFrame, ...middle, lastFrame];
-    return Object.freeze({ frames: Object.freeze(traceFrames) });
-}
-function isSourceFileFrame(frame) {
-    return frame?.target.kind === "file";
-}
-function traceKey(trace) {
-    return JSON.stringify(trace);
-}
-function nonEmpty(values) {
-    const first = values[0];
-    if (first === undefined)
+    const coordinate = coordinateFor(local, input.location.line, input.location.column);
+    if (coordinate === undefined)
         return undefined;
-    const tuple = [first, ...values.slice(1)];
-    return Object.freeze(tuple);
+    const decoded = effect_1.Schema.decodeUnknownEither(assertions_ts_1.AssertionSourceSiteSchema, core_ts_1.RecordExactParseOptions)(Object.freeze({
+        entryId: input.entryId,
+        sourceOrder: input.sourceOrder,
+        role: input.role,
+        sourceItemId: source.sourceItemId,
+        sha256: source.sha256,
+        start: coordinate,
+        end: coordinate,
+    }));
+    return effect_1.Either.isRight(decoded) ? decoded.right : undefined;
 }
-function jointValid(sources, sites) {
-    const packages = new Set();
-    const files = new Map();
-    for (const sourcePackage of sources.packages) {
-        packages.add(sourcePackage.packageItemId);
-        for (const file of sourcePackage.files) {
-            files.set(`${sourcePackage.packageItemId}\u0000${file.fileItemId}`, file.sha256);
+function sourceSiteOrder(left, right) {
+    const byEntry = left.entryId.localeCompare(right.entryId);
+    return byEntry === 0 ? left.sourceOrder - right.sourceOrder : byEntry;
+}
+function sourceSitesForOrigin(origin, localFiles, lookup) {
+    const capture = sourceCaptureForResult(origin.result);
+    if (capture === undefined || capture.entries.length !== origin.assertionEntryIds.length) {
+        return effect_1.Either.right(Object.freeze([]));
+    }
+    const sourceSites = [];
+    const orders = new Set();
+    for (const [index, entryCapture] of capture.entries.entries()) {
+        const entryId = origin.assertionEntryIds[index];
+        if (entryId === undefined)
+            return effect_1.Either.left(invalid("source-sites-invalid"));
+        for (const occurrence of entryCapture.occurrences) {
+            if (occurrence.site === undefined)
+                continue;
+            if (orders.has(occurrence.site.sourceOrder)) {
+                return effect_1.Either.left(invalid("source-sites-invalid"));
+            }
+            orders.add(occurrence.site.sourceOrder);
+            const site = sourceSite({
+                entryId,
+                sourceOrder: occurrence.site.sourceOrder,
+                role: occurrence.role,
+                location: occurrence.site.location,
+            }, localFiles, lookup);
+            if (site !== undefined)
+                sourceSites.push(site);
         }
     }
-    const validTrace = (trace) => trace.frames.every((frame) => frame.target.kind === "package"
-        ? packages.has(frame.target.packageItemId)
-        : files.get(`${frame.target.packageItemId}\u0000${frame.target.fileItemId}`) === frame.target.sha256);
-    return sites.entries.every((entry) => entry.sites.every((site) => validTrace(site.trace)))
-        && sites.sendSites.every((site) => validTrace(site.trace));
+    sourceSites.sort(sourceSiteOrder);
+    return effect_1.Either.right(Object.freeze(sourceSites));
 }
 /**
- * Builds one Run Sources closure plus one source-sites write per fresh origin.
- * It accepts only snapshots already retained by the Attempt; it never opens a
- * current source file or any legacy graph/store/evidence surface.
+ * Builds one flat Run Sources closure plus semantic source-site joins for
+ * each fresh origin. It uses only bytes retained by the actual Attempt; it
+ * never reopens today's worktree or a legacy result/Report surface.
  */
 function createRunnerSourceWritePlan(origins) {
-    if (origins.length === 0)
-        return effect_1.Either.right(undefined);
-    const packageLabels = new Set(["project"]);
     const textsByPath = new Map();
     const localBySlot = new Map();
     for (const origin of origins) {
+        if (localBySlot.has(origin.slotId)) {
+            return effect_1.Either.left(invalid("origin-slot-duplicate"));
+        }
         const local = new Map();
         for (const artifact of origin.result.sources ?? []) {
             const snapshot = sourceSnapshot(artifact);
             if (snapshot === undefined)
                 continue;
-            const key = stableFileKey(snapshot.path);
-            if (!local.has(key))
-                local.set(key, snapshot.text);
-            if (!textsByPath.has(key))
-                textsByPath.set(key, snapshot.text);
-        }
-        const capture = sourceCaptureForResult(origin.result);
-        for (const entry of capture?.entries ?? []) {
-            for (const occurrence of entry.occurrences) {
-                for (const frame of occurrence.site === undefined ? [] : sourceFrames(occurrence.site.location)) {
-                    if (frame.kind === "package")
-                        packageLabels.add(frame.package);
-                }
-            }
-        }
-        for (const send of capture?.sends ?? []) {
-            for (const frame of send.site === undefined ? [] : sourceFrames(send.site.location)) {
-                if (frame.kind === "package")
-                    packageLabels.add(frame.package);
-            }
+            if (!local.has(snapshot.path))
+                local.set(snapshot.path, snapshot.text);
+            if (!textsByPath.has(snapshot.path))
+                textsByPath.set(snapshot.path, snapshot.text);
         }
         localBySlot.set(origin.slotId, local);
     }
-    const packageInputs = [...packageLabels]
-        .sort((left, right) => left.localeCompare(right))
-        .map((label) => ({
-        packageItemId: packageId(),
-        label,
-        files: label === "project"
-            ? [...textsByPath.entries()]
-                .sort(([left], [right]) => left.localeCompare(right))
-                .map(([path, text]) => ({ fileItemId: fileId(), path, text }))
-            : [],
-    }));
-    const sourcesWrite = (0, attachment_ts_1.createSourcesAttachmentWriteV1)({ packages: packageInputs });
+    const sourcesWrite = (0, attachment_ts_1.createSourcesAttachmentWrite)({
+        items: Object.freeze([...textsByPath.entries()]
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([path, text]) => Object.freeze({ sourceItemId: sourceItemId(), path, text }))),
+    });
     if (effect_1.Either.isLeft(sourcesWrite))
         return effect_1.Either.left(invalid("sources-write-invalid"));
     const sourceContents = (0, internal_ts_1.recordAttachmentWriteContents)(sourcesWrite.right);
     if (effect_1.Either.isLeft(sourceContents))
         return effect_1.Either.left(invalid("sources-closure-invalid"));
     const lookup = manifestLookup(sourceContents.right.payload);
-    // Retain the exact persisted canonical bytes beside the immutable manifest
-    // refs. This is producer-only validation state, never an extra Record value.
+    // Retain canonical bytes only in this producer's transient lookup. They let
+    // source sites prove a semantic join, not gain a blob capability.
     for (const [path, text] of textsByPath) {
-        const file = lookup.files.get(path);
-        if (file !== undefined) {
-            lookup.files.set(path, Object.freeze({ ...file, text }));
+        const item = lookup.files.get(path);
+        if (item !== undefined) {
+            lookup.files.set(path, Object.freeze({ ...item, text }));
         }
     }
-    const attemptWrites = new Map();
+    const sourceSitesBySlot = new Map();
     for (const origin of origins) {
-        const entryIds = assertionEntryIds(origin.assertions);
-        if (effect_1.Either.isLeft(entryIds))
-            return effect_1.Either.left(entryIds.left);
-        const capture = sourceCaptureForResult(origin.result);
-        const localFiles = localBySlot.get(origin.slotId) ?? new Map();
-        const entries = [];
-        if (capture !== undefined && capture.entries.length === entryIds.right.length) {
-            for (const [index, entryCapture] of capture.entries.entries()) {
-                const entryId = entryIds.right[index];
-                if (entryId === undefined)
-                    continue;
-                const byTrace = new Map();
-                for (const occurrence of entryCapture.occurrences) {
-                    if (occurrence.site === undefined)
-                        continue;
-                    if (occurrence.role === "stop" && occurrence.outcome === undefined)
-                        continue;
-                    const trace = sourceTrace(occurrence.site.location, localFiles, lookup);
-                    if (trace === undefined)
-                        continue;
-                    let next;
-                    if (occurrence.role === "stop") {
-                        const { outcome } = occurrence;
-                        if (outcome === undefined)
-                            continue;
-                        next = Object.freeze({
-                            sourceOrder: occurrence.site.sourceOrder,
-                            role: "stop",
-                            outcome,
-                        });
-                    }
-                    else {
-                        next = Object.freeze({ sourceOrder: occurrence.site.sourceOrder, role: occurrence.role });
-                    }
-                    const key = traceKey(trace);
-                    const site = byTrace.get(key) ?? { trace, occurrences: [] };
-                    site.occurrences.push(next);
-                    byTrace.set(key, site);
-                }
-                const sites = [];
-                for (const site of [...byTrace.values()].sort((left, right) => {
-                    const [leftFirst] = left.occurrences;
-                    const [rightFirst] = right.occurrences;
-                    return (leftFirst?.sourceOrder ?? 0) - (rightFirst?.sourceOrder ?? 0);
-                })) {
-                    const occurrences = nonEmpty(site.occurrences);
-                    if (occurrences !== undefined) {
-                        sites.push(Object.freeze({ trace: site.trace, occurrences }));
-                    }
-                }
-                const entrySites = nonEmpty(sites);
-                if (entrySites !== undefined) {
-                    entries.push(Object.freeze({ entryId, sites: entrySites }));
-                }
-            }
-        }
-        const byTrace = new Map();
-        for (const send of capture?.sends ?? []) {
-            const trace = sourceTrace(send.site.location, localFiles, lookup);
-            if (trace === undefined)
-                continue;
-            const key = traceKey(trace);
-            const site = byTrace.get(key) ?? { trace, occurrences: [] };
-            site.occurrences.push(Object.freeze({
-                sourceOrder: send.site.sourceOrder,
-                label: send.terminal.label,
-                status: send.terminal.status,
-                durationMs: send.terminal.durationMs,
-            }));
-            byTrace.set(key, site);
-        }
-        const sendSites = [];
-        for (const site of [...byTrace.values()].sort((left, right) => {
-            const [leftFirst] = left.occurrences;
-            const [rightFirst] = right.occurrences;
-            return (leftFirst?.sourceOrder ?? 0) - (rightFirst?.sourceOrder ?? 0);
-        })) {
-            const occurrences = nonEmpty(site.occurrences);
-            if (occurrences !== undefined) {
-                sendSites.push(Object.freeze({ trace: site.trace, occurrences }));
-            }
-        }
-        const document = Object.freeze({
-            entries: Object.freeze(entries),
-            sendSites: Object.freeze(sendSites),
-        });
-        if (!jointValid(sourceContents.right.payload, document)) {
-            return effect_1.Either.left(invalid("source-sites-join-invalid"));
-        }
-        const write = (0, attachment_ts_1.createAssertionSourceSitesAttachmentWriteV1)(document);
-        if (effect_1.Either.isLeft(write))
-            return effect_1.Either.left(invalid("source-sites-write-invalid"));
-        const contents = (0, internal_ts_1.recordAttachmentWriteContents)(write.right);
-        if (effect_1.Either.isLeft(contents))
-            return effect_1.Either.left(invalid("source-sites-closure-invalid"));
-        attemptWrites.set(origin.slotId, write.right);
+        const local = localBySlot.get(origin.slotId);
+        if (local === undefined)
+            return effect_1.Either.left(invalid("origin-slot-duplicate"));
+        const sites = sourceSitesForOrigin(origin, local, lookup);
+        if (effect_1.Either.isLeft(sites))
+            return effect_1.Either.left(sites.left);
+        sourceSitesBySlot.set(origin.slotId, sites.right);
     }
     return effect_1.Either.right(Object.freeze({
         runWrite: sourcesWrite.right,
-        attemptWrites: new Map(attemptWrites),
+        sources: sourceContents.right.payload,
+        sourceSitesBySlot: new Map(sourceSitesBySlot),
     }));
 }
+function localSourceTexts(result) {
+    const files = new Map();
+    for (const artifact of result.sources ?? []) {
+        const snapshot = sourceSnapshot(artifact);
+        if (snapshot !== undefined && !files.has(snapshot.path))
+            files.set(snapshot.path, snapshot.text);
+    }
+    return files;
+}
+function sourceNavigationFrame(input) {
+    if (input.capture.location === undefined) {
+        return Object.freeze({ state: "unmapped", reason: "location-not-captured" });
+    }
+    const path = canonicalPath(input.capture.location.file);
+    if (path === undefined) {
+        return Object.freeze({ state: "unmapped", reason: "position-unrepresentable" });
+    }
+    const text = input.local.get(path);
+    const item = input.sources.items.find((candidate) => candidate.path === path);
+    if (text === undefined || item === undefined) {
+        return Object.freeze({ state: "unmapped", reason: "source-snapshot-not-recorded" });
+    }
+    const position = coordinateFor(text, input.capture.location.line, input.capture.location.column);
+    if (position === undefined) {
+        return Object.freeze({ state: "unmapped", reason: "position-unrepresentable" });
+    }
+    return Object.freeze({
+        state: "mapped",
+        sourceItemId: item.sourceItemId,
+        sha256: item.sha256,
+        start: position,
+        end: position,
+    });
+}
+/**
+ * Assembles the Attempt-owned no-blob navigation payload only after the
+ * same-seal Observability writer has fixed physical turn IDs and timing IDs.
+ */
+function createRunnerSourceNavigationWrite(input) {
+    const capture = sourceCaptureForResult(input.result);
+    const timingByTurn = (0, runner_producer_ts_1.runnerAttemptConversationTimingForResult)(input.result);
+    if (capture === undefined || timingByTurn === undefined) {
+        return effect_1.Either.left(invalid("source-navigation-invalid"));
+    }
+    const turns = [...input.observability.conversation.turns]
+        .sort((left, right) => left.sequence - right.sequence);
+    if (turns.length !== capture.sends.length) {
+        return effect_1.Either.left(invalid("source-navigation-invalid"));
+    }
+    const local = localSourceTexts(input.result);
+    const rows = [];
+    let missingTiming = 0;
+    for (const [index, turn] of turns.entries()) {
+        const captured = capture.sends[index];
+        if (captured === undefined || captured.turnId !== turn.turnId) {
+            return effect_1.Either.left(invalid("source-navigation-invalid"));
+        }
+        const intervalId = timingByTurn.get(captured.turnId);
+        if (intervalId === undefined)
+            missingTiming += 1;
+        rows.push(Object.freeze({
+            turnId: captured.turnId,
+            sourceOrder: captured.sourceOrder,
+            source: sourceNavigationFrame({ capture: captured, local, sources: input.sources }),
+            timing: intervalId === undefined
+                ? Object.freeze({ state: "unavailable", reason: "timing-not-recorded" })
+                : Object.freeze({ state: "linked", intervalId }),
+        }));
+    }
+    const limitations = [];
+    if (capture.omittedAtLeast > 0) {
+        limitations.push(Object.freeze({
+            code: "collection-cap-reached",
+            target: "navigation-row",
+            omittedAtLeast: capture.omittedAtLeast,
+        }));
+    }
+    if (missingTiming > 0) {
+        limitations.push(Object.freeze({
+            code: "capture-unrecoverable",
+            target: "timing-link",
+            omittedAtLeast: missingTiming,
+        }));
+    }
+    limitations.sort((left, right) => `${left.code}\u0000${left.target}\u0000${left.omittedAtLeast}`.localeCompare(`${right.code}\u0000${right.target}\u0000${right.omittedAtLeast}`));
+    const payload = Object.freeze({
+        collection: limitations.length === 0
+            ? Object.freeze({ state: "complete", limitations: Object.freeze([]) })
+            : Object.freeze({ state: "partial", limitations: Object.freeze([...limitations]) }),
+        rows: Object.freeze(rows),
+    });
+    const write = (0, source_navigation_ts_1.createSourceNavigationAttachmentWrite)(payload, catalog_ts_1.sourceNavigationRecordFamily.write);
+    return effect_1.Either.isLeft(write) ? effect_1.Either.left(invalid("source-navigation-invalid")) : effect_1.Either.right(write.right);
+}
 //# sourceMappingURL=source-producer.cjs.map