niceeval 0.12.2-canary.31 → 0.13.0

package/dist/record/reader/runtime.cjs

@@ -1,61 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RECORD_DURABLE_BLOB_REF_KEY = exports.RECORD_READER_MAXIMUM_ATTACHMENT_TOTAL_BYTES = exports.RECORD_READER_MAXIMUM_ATTACHMENT_BLOB_BYTES = exports.RECORD_READER_MAXIMUM_ATTACHMENT_BLOB_ENTRIES = exports.RECORD_READER_MAXIMUM_CORE_DOCUMENT_BYTES = exports.RECORD_READER_MAXIMUM_CORE_DIRECTORY_ENTRIES = exports.RECORD_READER_MAXIMUM_RUN_ENTRIES = void 0;
-exports.openRecordReader = openRecordReader;
+exports.RECORD_DURABLE_BLOB_REF_KEY = exports.RECORD_READER_MAXIMUM_ATTACHMENT_DOCUMENT_BYTES = exports.RECORD_READER_MAXIMUM_ATTACHMENT_TOTAL_BYTES = exports.RECORD_READER_MAXIMUM_ATTACHMENT_BLOB_BYTES = exports.RECORD_READER_MAXIMUM_ATTACHMENT_BLOB_ENTRIES = void 0;
+exports.readFixedRecordAttachment = readFixedRecordAttachment;
 const effect_1 = require("effect");
-const index_ts_1 = require("../attachment/index.cjs");
 const internal_ts_1 = require("../attachment/internal.cjs");
 const core_ts_1 = require("../codec/core.cjs");
-const identifiers_ts_1 = require("../codec/identifiers.cjs");
 const record_errors_ts_1 = require("../errors/record-errors.cjs");
-const identifiers_ts_2 = require("../model/identifiers.cjs");
-const errors_ts_1 = require("../platform/errors.cjs");
 const services_ts_1 = require("../platform/services.cjs");
-const errors_ts_2 = require("./errors.cjs");
-const identity_ts_1 = require("./identity.cjs");
-const format_ts_1 = require("./format.cjs");
-const internal_ts_2 = require("./internal.cjs");
-const types_ts_1 = require("./types.cjs");
-/** A root entry is deliberately small, while Core and Attachment documents get their own caps. */
-exports.RECORD_READER_MAXIMUM_RUN_ENTRIES = 100000;
-exports.RECORD_READER_MAXIMUM_CORE_DIRECTORY_ENTRIES = 100000;
-exports.RECORD_READER_MAXIMUM_CORE_DOCUMENT_BYTES = 1024 * 1024;
+const identifiers_ts_1 = require("../model/identifiers.cjs");
+/** Fixed readers materialize a family only when its explicit method is called. */
 exports.RECORD_READER_MAXIMUM_ATTACHMENT_BLOB_ENTRIES = 100000;
 exports.RECORD_READER_MAXIMUM_ATTACHMENT_BLOB_BYTES = 64 * 1024 * 1024;
 exports.RECORD_READER_MAXIMUM_ATTACHMENT_TOTAL_BYTES = 128 * 1024 * 1024;
+exports.RECORD_READER_MAXIMUM_ATTACHMENT_DOCUMENT_BYTES = 16 * 1024 * 1024;
 /** The storage-side ref codec reserves this exact one-property JSON object. */
 exports.RECORD_DURABLE_BLOB_REF_KEY = "$niceeval.record.blob";
-const missingDocument = Object.freeze({ state: "missing" });
-const invalidDocument = Object.freeze({ state: "invalid" });
-const missingDirectory = Object.freeze({ state: "missing" });
-const invalidDirectory = Object.freeze({ state: "invalid" });
-const missingCore = Object.freeze({ state: "missing" });
-function missingRead() {
-    return Object.freeze({ state: "missing" });
-}
-function readerClosed() {
-    return new errors_ts_2.RecordReaderClosed({ code: "record-reader-closed" });
-}
-function handleInvalid() {
-    return new errors_ts_2.RecordHandleInvalid({ code: "record-handle-invalid" });
-}
-function migrationInterrupted() {
-    return new errors_ts_2.RecordMigrationInterruptedState({
-        code: "record-migration-interrupted",
-    });
-}
-function loadedCoreInvalid(issues) {
-    const nonEmpty = (0, record_errors_ts_1.nonEmptyRecordIssues)(issues);
-    if (nonEmpty === undefined) {
-        throw new Error("Loaded Record core invalid state requires at least one issue");
-    }
-    return Object.freeze({ state: "core-invalid", issues: nonEmpty });
-}
-function schemaIssue(path) {
-    return (0, record_errors_ts_1.recordIssue)("record-schema-invalid", path);
+function attachmentInvalid(path) {
+    const issues = (0, record_errors_ts_1.nonEmptyRecordIssues)([(0, record_errors_ts_1.recordIssue)("record-schema-invalid", path)]);
+    if (issues === undefined)
+        throw new Error("Attachment invalid state requires one issue");
+    return Object.freeze({ state: "invalid", issues });
 }
-function codecIssues(issues, prefix) {
-    return issues.map((issue) => (0, record_errors_ts_1.recordIssue)(issue.code, [...prefix, ...issue.path]));
+function attachmentPath(root, location, family, ...segments) {
+    return location.owner === "run"
+        ? (0, services_ts_1.recordPortablePath)(root, "runs", location.runId, "attachments", family, ...segments)
+        : (0, services_ts_1.recordPortablePath)(root, "runs", location.runId, "attempts", location.attemptId, "attachments", family, ...segments);
 }
 function parseJson(bytes) {
     try {
@@ -65,272 +34,32 @@ function parseJson(bytes) {
         });
     }
     catch {
-        return invalidDocument;
+        return Object.freeze({ state: "invalid" });
     }
 }
-/**
- * Durable malformed files become data-state input. I/O, permission, forged
- * portable paths, and invalid resource requests deliberately remain typed E.
- */
-function readJsonDocument(fileSystem, path, maximumBytes) {
-    return fileSystem.readFile({ file: path, maximumBytes }).pipe(effect_1.Effect.map((bytes) => {
-        if (bytes === undefined) {
-            return missingDocument;
-        }
-        return bytes.byteLength > maximumBytes ? invalidDocument : parseJson(bytes);
-    }), effect_1.Effect.catchTag("RecordPathTypeInvalid", () => effect_1.Effect.succeed(invalidDocument)), effect_1.Effect.catchTag("RecordResourceLimitExceeded", () => effect_1.Effect.succeed(invalidDocument)));
-}
-function validDirectoryEntry(value) {
-    if (typeof value !== "object" || value === null) {
-        return false;
-    }
-    const entry = value;
-    return (typeof entry.name === "string" &&
-        (entry.kind === "file" || entry.kind === "directory" || entry.kind === "other"));
-}
-function sortedEntries(entries) {
-    return Object.freeze([...entries]
-        .map((entry) => Object.freeze({ name: entry.name, kind: entry.kind }))
-        .sort((left, right) => (0, identifiers_ts_2.compareCanonicalIdentity)(left.name, right.name)));
+function readJson(fileSystem, file) {
+    return fileSystem.readFile({ file, maximumBytes: exports.RECORD_READER_MAXIMUM_ATTACHMENT_DOCUMENT_BYTES }).pipe(effect_1.Effect.map((bytes) => bytes === undefined ? Object.freeze({ state: "missing" }) : parseJson(bytes)), effect_1.Effect.catchTag("RecordPathTypeInvalid", () => effect_1.Effect.succeed(Object.freeze({ state: "invalid" }))));
 }
-/** A missing optional Core directory is empty; a non-directory is corrupt. */
-function readDirectory(fileSystem, directory, maximumEntries) {
-    return fileSystem.pathKind(directory).pipe(effect_1.Effect.flatMap((kind) => {
-        if (kind === "missing") {
-            return effect_1.Effect.succeed(missingDirectory);
-        }
-        if (kind !== "directory") {
-            return effect_1.Effect.succeed(invalidDirectory);
-        }
-        return fileSystem.listDirectory({ directory, maximumEntries }).pipe(effect_1.Effect.map((entries) => {
-            if (!Array.isArray(entries) || !entries.every(validDirectoryEntry)) {
-                return invalidDirectory;
-            }
-            return Object.freeze({
-                state: "available",
-                entries: sortedEntries(entries),
-            });
-        }));
-    }), effect_1.Effect.catchTag("RecordPathTypeInvalid", () => effect_1.Effect.succeed(invalidDirectory)));
-}
-function decodeRunId(value) {
-    const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.RunIdSchema)(value);
-    return effect_1.Either.isRight(decoded) ? decoded.right : undefined;
-}
-function decodeSlotId(value) {
-    const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.SlotIdSchema)(value);
-    return effect_1.Either.isRight(decoded) ? decoded.right : undefined;
-}
-function decodeAttemptId(value) {
-    const decoded = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.AttemptIdSchema)(value);
-    return effect_1.Either.isRight(decoded) ? decoded.right : undefined;
-}
-function slotIdFromMemberFileName(name) {
-    if (!name.endsWith(".json")) {
+function stableEntries(entries) {
+    if (!entries.every((entry) => entry.kind === "file" && (0, identifiers_ts_1.isPortableSegment)(entry.name)))
         return undefined;
-    }
-    const slotText = name.slice(0, -".json".length);
-    return decodeSlotId(slotText);
-}
-function runPath(root, runId, ...segments) {
-    return (0, services_ts_1.recordPortablePath)(root, "runs", runId, ...segments);
-}
-function readMember(fileSystem, root, runId, entry) {
-    const slotId = entry.kind === "file" ? slotIdFromMemberFileName(entry.name) : undefined;
-    if (slotId === undefined) {
-        return effect_1.Effect.succeed(undefined);
-    }
-    return effect_1.Effect.map(readJsonDocument(fileSystem, runPath(root, runId, "members", entry.name), exports.RECORD_READER_MAXIMUM_CORE_DOCUMENT_BYTES), (document) => {
-        if (document.state !== "available") {
-            return undefined;
-        }
-        const decoded = (0, core_ts_1.decodeMemberDocumentV1)(document.value);
-        return effect_1.Either.isRight(decoded) && decoded.right.slotId === slotId
-            ? Object.freeze({ document: decoded.right })
-            : undefined;
-    });
-}
-function readAttempt(fileSystem, root, runId, entry) {
-    const attemptId = entry.kind === "directory" ? decodeAttemptId(entry.name) : undefined;
-    if (attemptId === undefined) {
-        return effect_1.Effect.succeed(undefined);
-    }
-    return effect_1.Effect.map(readJsonDocument(fileSystem, runPath(root, runId, "attempts", attemptId, "attempt.json"), exports.RECORD_READER_MAXIMUM_CORE_DOCUMENT_BYTES), (document) => {
-        if (document.state !== "available") {
-            return undefined;
-        }
-        const decoded = (0, core_ts_1.decodeAttemptDocumentV1)(document.value);
-        return effect_1.Either.isRight(decoded) &&
-            decoded.right.attemptId === attemptId &&
-            decoded.right.originRunId === runId
-            ? Object.freeze({ attemptId, document: decoded.right })
-            : undefined;
-    });
-}
-function readExactReferencedAttempt(fileSystem, root, candidates, ref) {
-    if (!candidates.has(ref.originRunId)) {
-        return effect_1.Effect.succeed(false);
-    }
-    return effect_1.Effect.map(readJsonDocument(fileSystem, runPath(root, ref.originRunId, "attempts", ref.attemptId, "attempt.json"), exports.RECORD_READER_MAXIMUM_CORE_DOCUMENT_BYTES), (document) => {
-        if (document.state !== "available") {
-            return false;
-        }
-        const decoded = (0, core_ts_1.decodeAttemptDocumentV1)(document.value);
-        return effect_1.Either.isRight(decoded) &&
-            decoded.right.attemptId === ref.attemptId &&
-            decoded.right.originRunId === ref.originRunId;
-    });
+    const sorted = [...entries].sort((left, right) => left.name.localeCompare(right.name));
+    return new Set(sorted.map((entry) => entry.name)).size === sorted.length ? Object.freeze(sorted) : undefined;
 }
-function localCoreIssues(runId, run, members, attempts) {
-    const issues = [];
-    const expected = new Set(run.expectedSlots);
-    const seenSlots = new Set();
-    const attemptsById = new Map();
-    const originMemberCounts = new Map();
-    const foreignRefs = new Map();
-    for (const [index, attempt] of attempts.entries()) {
-        if (attemptsById.has(attempt.attemptId)) {
-            issues.push((0, record_errors_ts_1.recordIssue)("record-attempt-duplicate", ["attempts", String(index)]));
-            continue;
-        }
-        attemptsById.set(attempt.attemptId, attempt.document);
-        if (attempt.document.originRunId !== runId) {
-            issues.push((0, record_errors_ts_1.recordIssue)("record-attempt-owner-invalid", ["attempts", String(index), "originRunId"]));
-        }
-    }
-    for (const [index, member] of members.entries()) {
-        const path = ["members", String(index)];
-        if (!expected.has(member.document.slotId)) {
-            issues.push((0, record_errors_ts_1.recordIssue)("record-member-slot-unexpected", [...path, "slotId"]));
-        }
-        if (seenSlots.has(member.document.slotId)) {
-            issues.push((0, record_errors_ts_1.recordIssue)("record-member-slot-duplicate", [...path, "slotId"]));
-        }
-        seenSlots.add(member.document.slotId);
-        if (member.document.attempt.originRunId === runId) {
-            const attempted = attemptsById.get(member.document.attempt.attemptId);
-            if (attempted === undefined) {
-                issues.push((0, record_errors_ts_1.recordIssue)("record-attempt-reference-missing", [...path, "attempt"]));
-                continue;
-            }
-            originMemberCounts.set(member.document.attempt.attemptId, (originMemberCounts.get(member.document.attempt.attemptId) ?? 0) + 1);
-            continue;
-        }
-        const key = `${member.document.attempt.originRunId}\u0000${member.document.attempt.attemptId}`;
-        foreignRefs.set(key, member.document.attempt);
-    }
-    for (const [attemptId] of attemptsById) {
-        const count = originMemberCounts.get(attemptId) ?? 0;
-        if (count === 0) {
-            issues.push((0, record_errors_ts_1.recordIssue)("record-origin-member-missing", ["attempts", attemptId]));
-        }
-        else if (count > 1) {
-            issues.push((0, record_errors_ts_1.recordIssue)("record-origin-member-duplicate", ["attempts", attemptId]));
-        }
-    }
-    return Object.freeze({
-        issues: Object.freeze(issues),
-        foreignRefs: Object.freeze([...foreignRefs.values()]),
-    });
-}
-function readRunCore(fileSystem, root, candidates, runId) {
-    return effect_1.Effect.gen(function* () {
-        const runDocument = yield* readJsonDocument(fileSystem, runPath(root, runId, "run.json"), exports.RECORD_READER_MAXIMUM_CORE_DOCUMENT_BYTES);
-        if (runDocument.state !== "available") {
-            return loadedCoreInvalid([schemaIssue(["run.json"])]);
-        }
-        const decodedRun = (0, core_ts_1.decodeRunDocumentV1)(runDocument.value);
-        if (effect_1.Either.isLeft(decodedRun) || decodedRun.right.runId !== runId) {
-            return loadedCoreInvalid(effect_1.Either.isLeft(decodedRun)
-                ? codecIssues(decodedRun.left.issues, ["run.json"])
-                : [schemaIssue(["run.json", "runId"])]);
-        }
-        const membersDirectory = yield* readDirectory(fileSystem, runPath(root, runId, "members"), exports.RECORD_READER_MAXIMUM_CORE_DIRECTORY_ENTRIES);
-        const attemptsDirectory = yield* readDirectory(fileSystem, runPath(root, runId, "attempts"), exports.RECORD_READER_MAXIMUM_CORE_DIRECTORY_ENTRIES);
-        if (membersDirectory.state === "invalid" || attemptsDirectory.state === "invalid") {
-            return loadedCoreInvalid([schemaIssue(["runs", runId])]);
-        }
-        const members = membersDirectory.state === "available"
-            ? yield* effect_1.Effect.forEach(membersDirectory.entries, (entry) => readMember(fileSystem, root, runId, entry))
-            : [];
-        if (members.some((member) => member === undefined)) {
-            return loadedCoreInvalid([schemaIssue(["members"])]);
-        }
-        const attempts = attemptsDirectory.state === "available"
-            ? yield* effect_1.Effect.forEach(attemptsDirectory.entries, (entry) => readAttempt(fileSystem, root, runId, entry))
-            : [];
-        if (attempts.some((attempt) => attempt === undefined)) {
-            return loadedCoreInvalid([schemaIssue(["attempts"])]);
-        }
-        const validMembers = members;
-        const validAttempts = attempts;
-        const local = localCoreIssues(runId, decodedRun.right, validMembers, validAttempts);
-        const foreignExistence = yield* effect_1.Effect.forEach(local.foreignRefs, (ref) => readExactReferencedAttempt(fileSystem, root, candidates, ref));
-        const issues = [...local.issues];
-        for (const [index, exists] of foreignExistence.entries()) {
-            if (!exists) {
-                issues.push((0, record_errors_ts_1.recordIssue)("record-attempt-reference-missing", ["members", String(index), "attempt"]));
-            }
-        }
-        if (issues.length > 0) {
-            return loadedCoreInvalid(issues);
-        }
-        const byAttemptId = new Map();
-        for (const attempt of validAttempts) {
-            byAttemptId.set(attempt.attemptId, attempt.document);
-        }
-        const bySlotId = new Map();
-        for (const member of validMembers) {
-            bySlotId.set(member.document.slotId, member.document);
-        }
-        return Object.freeze({
-            state: "available",
-            value: Object.freeze({
-                run: decodedRun.right,
-                members: bySlotId,
-                attempts: byAttemptId,
-            }),
-        });
-    });
-}
-function attachmentInvalid(path) {
-    return Object.freeze({
-        state: "invalid",
-        issues: (0, record_errors_ts_1.nonEmptyRecordIssues)([schemaIssue(path)]),
-    });
-}
-function attachmentDirectoryPath(root, location, name, ...segments) {
-    return location.owner === "run"
-        ? (0, services_ts_1.recordPortablePath)(root, "runs", location.runId, "attachments", name, ...segments)
-        : (0, services_ts_1.recordPortablePath)(root, "runs", location.runId, "attempts", location.attemptId, "attachments", name, ...segments);
-}
-function readBlobDirectory(fileSystem, directory) {
+function readBlobDirectory(fileSystem, directory, maximumEntries) {
     return fileSystem.pathKind(directory).pipe(effect_1.Effect.flatMap((kind) => {
-        if (kind === "missing") {
+        if (kind === "missing")
             return effect_1.Effect.succeed(Object.freeze({ state: "missing" }));
-        }
-        if (kind !== "directory") {
+        if (kind !== "directory")
             return effect_1.Effect.succeed(Object.freeze({ state: "invalid" }));
-        }
         return fileSystem.listDirectory({
             directory,
-            maximumEntries: exports.RECORD_READER_MAXIMUM_ATTACHMENT_BLOB_ENTRIES,
+            maximumEntries: Math.min(exports.RECORD_READER_MAXIMUM_ATTACHMENT_BLOB_ENTRIES, maximumEntries),
         }).pipe(effect_1.Effect.map((entries) => {
-            if (!Array.isArray(entries) ||
-                !entries.every((entry) => validDirectoryEntry(entry) &&
-                    entry.kind === "file" &&
-                    (0, identifiers_ts_2.isPortableSegment)(entry.name))) {
-                return Object.freeze({ state: "invalid" });
-            }
-            const sorted = sortedEntries(entries);
-            const names = new Set();
-            for (const entry of sorted) {
-                if (names.has(entry.name)) {
-                    return Object.freeze({ state: "invalid" });
-                }
-                names.add(entry.name);
-            }
-            return Object.freeze({ state: "available", entries: sorted });
+            const stable = stableEntries(entries);
+            return stable === undefined
+                ? Object.freeze({ state: "invalid" })
+                : Object.freeze({ state: "available", entries: stable });
         }));
     }), effect_1.Effect.catchTag("RecordPathTypeInvalid", () => effect_1.Effect.succeed(Object.freeze({ state: "invalid" }))));
 }
@@ -338,41 +67,28 @@ function hydrateDurablePayload(input) {
     const refsByKey = new Map();
     let invalid = false;
     const hydrate = (value) => {
-        if (value === null || typeof value !== "object") {
+        if (value === null || typeof value !== "object")
             return value;
-        }
-        if (Array.isArray(value)) {
+        if (Array.isArray(value))
             return value.map(hydrate);
-        }
         const source = value;
         const keys = Object.keys(source);
         if (keys.length === 1 && keys[0] === exports.RECORD_DURABLE_BLOB_REF_KEY) {
-            if (typeof source[exports.RECORD_DURABLE_BLOB_REF_KEY] !== "string") {
-                invalid = true;
-                return source;
-            }
             const key = source[exports.RECORD_DURABLE_BLOB_REF_KEY];
-            if (!(0, identifiers_ts_2.isPortableSegment)(key)) {
+            if (typeof key !== "string" || !(0, identifiers_ts_1.isPortableSegment)(key)) {
                 invalid = true;
                 return source;
             }
-            const existing = refsByKey.get(key);
-            if (existing !== undefined) {
-                return existing;
-            }
+            const prior = refsByKey.get(key);
+            if (prior !== undefined)
+                return prior;
             const ref = (0, internal_ts_1.makeRecordBlobRef)();
             refsByKey.set(key, ref);
             return ref;
         }
-        const clone = {};
-        for (const key of keys) {
-            Object.defineProperty(clone, key, {
-                value: hydrate(source[key]),
-                enumerable: true,
-                configurable: true,
-                writable: true,
-            });
-        }
+        const clone = Object.create(null);
+        for (const key of keys)
+            clone[key] = hydrate(source[key]);
         return clone;
     };
     try {
@@ -382,347 +98,107 @@ function hydrateDurablePayload(input) {
         return Object.freeze({ value: input, refsByKey, invalid: true });
     }
 }
-function readAttachmentBlob(fileSystem, file) {
+function readBlob(fileSystem, file, maximumBytes) {
     return fileSystem.readFile({
         file,
-        maximumBytes: exports.RECORD_READER_MAXIMUM_ATTACHMENT_BLOB_BYTES,
-    }).pipe(effect_1.Effect.catchTag("RecordPathTypeInvalid", () => effect_1.Effect.succeed(undefined)));
+        maximumBytes: Math.min(exports.RECORD_READER_MAXIMUM_ATTACHMENT_BLOB_BYTES, maximumBytes),
+    }).pipe(effect_1.Effect.catchTag("RecordPathTypeInvalid", () => effect_1.Effect.succeed(undefined)), effect_1.Effect.catchTag("RecordResourceLimitExceeded", () => effect_1.Effect.succeed(undefined)));
 }
-function attachmentBytesExceeded(path, observedAtLeast) {
-    return new errors_ts_1.RecordResourceLimitExceeded({
-        code: "record-resource-limit-exceeded",
-        resource: "file-bytes",
-        maximum: exports.RECORD_READER_MAXIMUM_ATTACHMENT_TOTAL_BYTES,
-        observedAtLeast,
-        path,
-    });
+function hasReachableAdjacentMigration(descriptor, fromSchemaVersion) {
+    if (fromSchemaVersion >= descriptor.schemaVersion)
+        return false;
+    let version = fromSchemaVersion;
+    while (version < descriptor.schemaVersion) {
+        const step = descriptor.adjacentMigrationLinks.find((link) => link.fromSchemaVersion === version && link.toSchemaVersion === version + 1);
+        if (step === undefined)
+            return false;
+        version = step.toSchemaVersion;
+    }
+    return true;
 }
-function readAttachment(input) {
+/**
+ * Reads precisely one known static family. Unknown sibling directories are
+ * intentionally neither enumerated nor decoded, so future independent
+ * families remain preserved and ignored by the normal graph.
+ */
+function readFixedRecordAttachment(input) {
     return effect_1.Effect.gen(function* () {
-        const directory = attachmentDirectoryPath(input.root, input.location, input.definition.name);
-        const directoryKind = yield* input.fileSystem.pathKind(directory);
-        if (directoryKind === "missing") {
+        const directory = attachmentPath(input.root, input.location, input.descriptor.family);
+        const kind = yield* input.fileSystem.pathKind(directory);
+        if (kind === "missing")
             return Object.freeze({ state: "unavailable" });
-        }
-        if (directoryKind !== "directory") {
+        if (kind !== "directory")
             return attachmentInvalid(["attachment"]);
-        }
-        const envelopeDocument = yield* readJsonDocument(input.fileSystem, attachmentDirectoryPath(input.root, input.location, input.definition.name, "attachment.json"), exports.RECORD_READER_MAXIMUM_CORE_DOCUMENT_BYTES);
-        if (envelopeDocument.state !== "available") {
+        const envelopeDocument = yield* readJson(input.fileSystem, attachmentPath(input.root, input.location, input.descriptor.family, "attachment.json"));
+        if (envelopeDocument.state !== "available")
             return attachmentInvalid(["attachment.json"]);
-        }
-        const envelope = (0, core_ts_1.decodeRecordAttachmentEnvelopeV1)(envelopeDocument.value);
-        if (effect_1.Either.isLeft(envelope) || envelope.right.name !== input.definition.name) {
+        const envelope = (0, core_ts_1.decodeRecordAttachmentEnvelope)(envelopeDocument.value);
+        if (effect_1.Either.isLeft(envelope))
             return attachmentInvalid(["attachment.json"]);
-        }
-        const payloadDocument = yield* readJsonDocument(input.fileSystem, attachmentDirectoryPath(input.root, input.location, input.definition.name, "payload.json"), exports.RECORD_READER_MAXIMUM_CORE_DOCUMENT_BYTES);
-        if (payloadDocument.state !== "available") {
-            return attachmentInvalid(["payload.json"]);
-        }
-        const blobDirectory = yield* readBlobDirectory(input.fileSystem, attachmentDirectoryPath(input.root, input.location, input.definition.name, "blobs"));
-        if (blobDirectory.state === "invalid") {
-            return attachmentInvalid(["blobs"]);
-        }
-        // The owner-local ref codec is independent of the typed family version, so
-        // a broken closure is still invalid before an old-version migration state.
-        const hydrated = hydrateDurablePayload(payloadDocument.value);
-        if (hydrated.invalid) {
-            return attachmentInvalid(["payload.json"]);
-        }
-        const entries = blobDirectory.state === "available" ? blobDirectory.entries : [];
-        const entriesByKey = new Map(entries.map((entry) => [entry.name, entry]));
-        if (entriesByKey.size !== hydrated.refsByKey.size ||
-            [...hydrated.refsByKey.keys()].some((key) => !entriesByKey.has(key))) {
-            return attachmentInvalid(["blobs"]);
-        }
-        const migration = (0, internal_ts_1.resolveRecordAttachmentMigration)(input.family, envelope.right.schemaId);
-        if (migration === undefined) {
-            return attachmentInvalid(["attachment.json", "schemaId"]);
-        }
-        if (migration.state === "unsupported") {
-            return Object.freeze({ state: "unsupported", schemaId: envelope.right.schemaId });
-        }
-        if (migration.state === "migration-required") {
+        // We reached a directory for one known fixed family. Its envelope must
+        // declare that same family; treating a swapped envelope as an unknown
+        // sibling would let a corrupted known directory masquerade as tolerated
+        // future data.
+        if (envelope.right.family !== input.descriptor.family) {
+            return attachmentInvalid(["attachment.json", "family"]);
+        }
+        if (envelope.right.schemaVersion < input.descriptor.schemaVersion &&
+            hasReachableAdjacentMigration(input.descriptor, envelope.right.schemaVersion)) {
             return Object.freeze({
                 state: "migration-required",
-                from: migration.from,
-                to: migration.to,
+                family: input.descriptor.family,
+                fromSchemaVersion: envelope.right.schemaVersion,
+                toSchemaVersion: input.descriptor.schemaVersion,
                 command: "niceeval migrate",
             });
         }
-        if (migration.state === "migration-unavailable") {
+        if (envelope.right.schemaVersion !== input.descriptor.schemaVersion) {
+            // A well-formed envelope for a known family can still carry a version
+            // this reader cannot interpret. Only a reachable older version asks for
+            // migration; all other non-current versions remain local unsupported
+            // data, rather than being misclassified as corrupt bytes.
             return Object.freeze({
-                state: "migration-unavailable",
-                from: migration.from,
-                to: migration.to,
-                reason: migration.reason,
+                state: "unsupported",
+                family: input.descriptor.family,
+                schemaVersion: envelope.right.schemaVersion,
             });
         }
-        const payload = (0, index_ts_1.decodeJsonRecordAttachmentPayload)(input.definition, hydrated.value);
-        if (effect_1.Either.isLeft(payload)) {
+        const payloadDocument = yield* readJson(input.fileSystem, attachmentPath(input.root, input.location, input.descriptor.family, "payload.json"));
+        if (payloadDocument.state !== "available")
+            return attachmentInvalid(["payload.json"]);
+        const blobs = yield* readBlobDirectory(input.fileSystem, attachmentPath(input.root, input.location, input.descriptor.family, "blobs"), input.descriptor.write.budget.maximumBlobs);
+        if (blobs.state === "invalid")
+            return attachmentInvalid(["blobs"]);
+        const hydrated = hydrateDurablePayload(payloadDocument.value);
+        if (hydrated.invalid)
             return attachmentInvalid(["payload.json"]);
+        const entries = blobs.state === "available" ? blobs.entries : [];
+        if (entries.length > input.descriptor.write.budget.maximumBlobs) {
+            return attachmentInvalid(["blobs"]);
         }
+        const entriesByKey = new Map(entries.map((entry) => [entry.name, entry]));
+        if (entriesByKey.size !== hydrated.refsByKey.size || [...hydrated.refsByKey.keys()].some((key) => !entriesByKey.has(key))) {
+            return attachmentInvalid(["blobs"]);
+        }
+        const payload = input.descriptor.write.decodePayload(hydrated.value);
+        if (effect_1.Either.isLeft(payload))
+            return attachmentInvalid(["payload.json"]);
         let totalBytes = 0;
         const materialized = [];
         for (const [key, ref] of hydrated.refsByKey) {
-            const bytes = yield* readAttachmentBlob(input.fileSystem, attachmentDirectoryPath(input.root, input.location, input.definition.name, "blobs", key));
-            if (bytes === undefined) {
+            const bytes = yield* readBlob(input.fileSystem, attachmentPath(input.root, input.location, input.descriptor.family, "blobs", key), input.descriptor.write.budget.maximumBlobBytes);
+            if (bytes === undefined)
                 return attachmentInvalid(["blobs", key]);
-            }
             totalBytes += bytes.byteLength;
-            if (totalBytes > exports.RECORD_READER_MAXIMUM_ATTACHMENT_TOTAL_BYTES) {
-                return yield* effect_1.Effect.fail(attachmentBytesExceeded(`blobs/${key}`, totalBytes));
+            if (totalBytes > input.descriptor.write.budget.maximumTotalBytes) {
+                return attachmentInvalid(["blobs", key]);
             }
             materialized.push(Object.freeze({ ref, bytes }));
         }
-        const value = (0, internal_ts_1.makeRecordAttachmentValue)(input.definition, payload.right, materialized);
-        return effect_1.Either.isLeft(value)
-            ? attachmentInvalid(["payload.json"])
-            : Object.freeze({ state: "available", value: value.right });
-    });
-}
-function discoverRuns(fileSystem, root) {
-    return effect_1.Effect.gen(function* () {
-        const directory = yield* readDirectory(fileSystem, (0, services_ts_1.recordPortablePath)(root, "runs"), exports.RECORD_READER_MAXIMUM_RUN_ENTRIES);
-        if (directory.state === "missing") {
-            return Object.freeze({ candidates: Object.freeze([]), warnings: Object.freeze([]) });
-        }
-        if (directory.state === "invalid") {
-            return yield* effect_1.Effect.fail(new errors_ts_1.RecordPathTypeInvalid({
-                code: "record-path-type-invalid",
-                path: "runs",
-                expected: "directory",
-                actual: "other",
-            }));
-        }
-        const candidateIds = new Set();
-        const incompleteIds = new Set();
-        for (const entry of directory.entries) {
-            const runId = entry.kind === "directory" ? decodeRunId(entry.name) : undefined;
-            if (runId === undefined) {
-                continue;
-            }
-            const marker = yield* fileSystem.pathKind(runPath(root, runId, "complete"));
-            if (marker === "file") {
-                candidateIds.add(runId);
-            }
-            else {
-                incompleteIds.add(runId);
-            }
-        }
-        const candidates = Object.freeze([...candidateIds].sort(identifiers_ts_2.compareCanonicalIdentity));
-        const warnings = Object.freeze([...incompleteIds]
-            .sort(identifiers_ts_2.compareCanonicalIdentity)
-            .map((runId) => Object.freeze({
-            code: "incomplete-run",
-            runId,
-            cleanupCommand: "niceeval clean",
-        })));
-        return Object.freeze({ candidates, warnings });
-    });
-}
-function mapRunRead(state, create) {
-    switch (state.state) {
-        case "available":
-            return Object.freeze({ state: "available", value: create(state.value) });
-        case "missing":
-            return missingRead();
-        case "core-invalid":
-            return Object.freeze({ state: "core-invalid", issues: state.issues });
-    }
-}
-function mapAttemptRead(state, attemptId, create) {
-    switch (state.state) {
-        case "available": {
-            const attempt = state.value.attempts.get(attemptId);
-            return attempt === undefined
-                ? missingRead()
-                : Object.freeze({ state: "available", value: create(attempt) });
-        }
-        case "missing":
-            return missingRead();
-        case "core-invalid":
-            return Object.freeze({ state: "core-invalid", issues: state.issues });
-    }
-}
-function mapMemberRead(state, slotId) {
-    switch (state.state) {
-        case "available": {
-            const member = state.value.members.get(slotId);
-            return member === undefined
-                ? missingRead()
-                : Object.freeze({ state: "available", value: member });
-        }
-        case "missing":
-            return missingRead();
-        case "core-invalid":
-            return Object.freeze({ state: "core-invalid", issues: state.issues });
-    }
-}
-/**
- * Open the current Record major under the shared maintenance lock. Discovery
- * keeps only the bounded candidate RunId index; Core work is deferred to the
- * individual `run`, `attempt`, or `runs` operation.
- */
-function openRecordReader(input) {
-    return effect_1.Effect.gen(function* () {
-        const fileSystem = yield* services_ts_1.RecordFileSystem;
-        const maintenance = yield* services_ts_1.RecordMaintenanceLock;
-        yield* maintenance.acquireShared(input.root);
-        if (yield* fileSystem.migrationSentinelPresent(input.root)) {
-            return yield* effect_1.Effect.fail(migrationInterrupted());
-        }
-        yield* (0, format_ts_1.readCurrentRecordFormat)(fileSystem, input.root);
-        const discovered = yield* discoverRuns(fileSystem, input.root);
-        const candidates = new Set(discovered.candidates);
-        const lifecycle = (0, identity_ts_1.makeReaderLifecycle)({ closed: readerClosed });
-        yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(lifecycle.close));
-        const runHandles = (0, identity_ts_1.makeExactHandleRegistry)(lifecycle, { invalid: handleInvalid });
-        const viewHandles = (0, identity_ts_1.makeExactHandleRegistry)(lifecycle, { invalid: handleInvalid });
-        const attemptHandles = (0, identity_ts_1.makeExactHandleRegistry)(lifecycle, { invalid: handleInvalid });
-        const coreByRun = new Map();
-        const frozenRuns = new Map();
-        const frozenAttempts = new Map();
-        const assertLive = () => {
-            const live = lifecycle.assertLive();
-            return effect_1.Either.isLeft(live) ? effect_1.Effect.fail(live.left) : effect_1.Effect.void;
-        };
-        const assertView = (view) => effect_1.Effect.suspend(() => {
-            const resolved = viewHandles.resolve(view);
-            return effect_1.Either.isLeft(resolved) ? effect_1.Effect.fail(resolved.left) : effect_1.Effect.void;
-        });
-        const loadRun = (runId) => effect_1.Effect.suspend(() => {
-            if (!candidates.has(runId)) {
-                return effect_1.Effect.succeed(missingCore);
-            }
-            const cached = coreByRun.get(runId);
-            if (cached !== undefined) {
-                return effect_1.Effect.succeed(cached);
-            }
-            return readRunCore(fileSystem, input.root, candidates, runId).pipe(effect_1.Effect.tap((state) => effect_1.Effect.sync(() => {
-                coreByRun.set(runId, state);
-            })));
-        });
-        const freezeRun = (core) => {
-            const existing = frozenRuns.get(core.run.runId);
-            if (existing !== undefined) {
-                return existing;
-            }
-            const run = Object.freeze({
-                runId: core.run.runId,
-                startedAt: core.run.startedAt,
-                completedAt: core.run.completedAt,
-                expectedSlots: Object.freeze([...core.run.expectedSlots]),
-                [types_ts_1.frozenRecordRunBrand]: () => undefined,
-            });
-            frozenRuns.set(core.run.runId, run);
-            return runHandles.register(run, Object.freeze({ runId: core.run.runId }));
-        };
-        const freezeAttempt = (attempt) => {
-            const key = `${attempt.originRunId}\u0000${attempt.attemptId}`;
-            const existing = frozenAttempts.get(key);
-            if (existing !== undefined) {
-                return existing;
-            }
-            const frozen = Object.freeze({
-                attemptId: attempt.attemptId,
-                originRunId: attempt.originRunId,
-                [types_ts_1.frozenRecordAttemptBrand]: () => undefined,
-            });
-            frozenAttempts.set(key, frozen);
-            return attemptHandles.register(frozen, Object.freeze({
-                ref: Object.freeze({ originRunId: attempt.originRunId, attemptId: attempt.attemptId }),
-            }));
-        };
-        const readRun = (runId) => effect_1.Effect.suspend(() => effect_1.Effect.zipRight(assertLive(), effect_1.Effect.map(loadRun(runId), (state) => mapRunRead(state, freezeRun))));
-        const readFrozenAttempt = (ref) => {
-            const operation = effect_1.Effect.suspend(() => {
-                const originRunId = decodeRunId(ref?.originRunId);
-                const attemptId = decodeAttemptId(ref?.attemptId);
-                if (originRunId === undefined || attemptId === undefined) {
-                    return effect_1.Effect.zipRight(assertLive(), effect_1.Effect.succeed(missingRead()));
-                }
-                return effect_1.Effect.zipRight(assertLive(), effect_1.Effect.map(loadRun(originRunId), (state) => mapAttemptRead(state, attemptId, freezeAttempt)));
-            });
-            return operation;
-        };
-        const readFrozenMember = (owner, slotId) => effect_1.Effect.suspend(() => {
-            const resolved = runHandles.resolve(owner);
-            if (effect_1.Either.isLeft(resolved)) {
-                return effect_1.Effect.fail(resolved.left);
-            }
-            return effect_1.Effect.zipRight(assertLive(), effect_1.Effect.map(loadRun(resolved.right.runId), (state) => mapMemberRead(state, slotId)));
-        });
-        const readRunAttachmentForOwner = (owner, family) => effect_1.Effect.suspend(() => {
-            const resolved = runHandles.resolve(owner);
-            if (effect_1.Either.isLeft(resolved)) {
-                return effect_1.Effect.fail(resolved.left);
-            }
-            const definition = (0, internal_ts_1.recordAttachmentFamilyCurrentDefinition)(family);
-            if ((0, internal_ts_1.recordAttachmentFamilyOwner)(family) !== "run" || definition === undefined) {
-                return effect_1.Effect.fail(handleInvalid());
-            }
-            return readAttachment({
-                fileSystem,
-                root: input.root,
-                location: Object.freeze({ owner: "run", runId: resolved.right.runId }),
-                family,
-                definition,
-            });
-        });
-        const readAttemptAttachmentForOwner = (owner, family) => effect_1.Effect.suspend(() => {
-            const resolved = attemptHandles.resolve(owner);
-            if (effect_1.Either.isLeft(resolved)) {
-                return effect_1.Effect.fail(resolved.left);
-            }
-            const definition = (0, internal_ts_1.recordAttachmentFamilyCurrentDefinition)(family);
-            if ((0, internal_ts_1.recordAttachmentFamilyOwner)(family) !== "attempt" || definition === undefined) {
-                return effect_1.Effect.fail(handleInvalid());
-            }
-            return readAttachment({
-                fileSystem,
-                root: input.root,
-                location: Object.freeze({
-                    owner: "attempt",
-                    runId: resolved.right.ref.originRunId,
-                    attemptId: resolved.right.ref.attemptId,
-                }),
-                family,
-                definition,
-            });
-        });
-        const runs = effect_1.Stream.unwrap(effect_1.Effect.suspend(() => assertLive().pipe(effect_1.Effect.map(() => effect_1.Stream.fromIterable(discovered.candidates).pipe(effect_1.Stream.mapEffect(readRun))))));
-        const reader = Object.freeze({
-            warnings: discovered.warnings,
-            get runs() {
-                return effect_1.Stream.unwrap(assertView(this).pipe(effect_1.Effect.map(() => runs)));
-            },
-            run(runId) {
-                return effect_1.Effect.zipRight(assertView(this), readRun(runId));
-            },
-            attempt(ref) {
-                return effect_1.Effect.zipRight(assertView(this), readFrozenAttempt(ref));
-            },
-            readRunAttachment(owner, family) {
-                return effect_1.Effect.zipRight(assertView(this), readRunAttachmentForOwner(owner, family));
-            },
-            readAttemptAttachment(owner, family) {
-                return effect_1.Effect.zipRight(assertView(this), readAttemptAttachmentForOwner(owner, family));
-            },
-            [types_ts_1.frozenRecordViewBrand]: () => undefined,
-        });
-        viewHandles.register(reader, undefined);
-        const frozenPort = {
-            assertOpen: (view) => assertView(view),
-            candidates: (view) => effect_1.Stream.unwrap(assertView(view).pipe(effect_1.Effect.map(() => runs))),
-            run: (view, runId) => effect_1.Effect.zipRight(assertView(view), readRun(runId)),
-            member: (view, owner, slotId) => effect_1.Effect.zipRight(assertView(view), readFrozenMember(owner, slotId)),
-            attempt: (view, ref) => effect_1.Effect.zipRight(assertView(view), readFrozenAttempt(ref)),
-            readRunAttachment: (view, owner, family) => effect_1.Effect.zipRight(assertView(view), readRunAttachmentForOwner(owner, family)),
-            readAttemptAttachment: (view, owner, family) => effect_1.Effect.zipRight(assertView(view), readAttemptAttachmentForOwner(owner, family)),
-        };
-        (0, internal_ts_2.registerFrozenRecordReaderPort)(reader, frozenPort);
-        return reader;
+        const materializedValue = (0, internal_ts_1.makeFixedRecordAttachmentValueFromDecoded)(input.descriptor.write, payload.right, materialized);
+        if (effect_1.Either.isLeft(materializedValue))
+            return attachmentInvalid(["payload.json"]);
+        return Object.freeze({ state: "available", ...materializedValue.right });
     });
 }
 //# sourceMappingURL=runtime.cjs.map