niceeval 0.12.2-canary.31 → 0.13.0

package/dist/record/attachment/runtime.cjs

@@ -1,44 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeRecordBlobRef = makeRecordBlobRef;
+exports.makeRecordBlobRef = exports.isRecordBlobRef = void 0;
 exports.makeRecordBlobSource = makeRecordBlobSource;
-exports.defineJsonRecordAttachment = defineJsonRecordAttachment;
-exports.defineBuiltinJsonRecordAttachment = defineBuiltinJsonRecordAttachment;
-exports.decodeJsonRecordAttachmentPayload = decodeJsonRecordAttachmentPayload;
-exports.encodeJsonRecordAttachmentPayload = encodeJsonRecordAttachmentPayload;
-exports.makeRecordAttachmentWrite = makeRecordAttachmentWrite;
+exports.makeFixedAttachmentWriteSpec = makeFixedAttachmentWriteSpec;
+exports.makeFixedRecordAttachmentWrite = makeFixedRecordAttachmentWrite;
 exports.validateRecordAttachmentWrite = validateRecordAttachmentWrite;
 exports.recordAttachmentWriteContents = recordAttachmentWriteContents;
-exports.makeRecordAttachmentValue = makeRecordAttachmentValue;
-exports.isRecordAttachmentValue = isRecordAttachmentValue;
-exports.recordAttachmentValueDefinition = recordAttachmentValueDefinition;
-exports.defineRecordAttachmentMigration = defineRecordAttachmentMigration;
-exports.declareRecordAttachmentMigrationUnavailable = declareRecordAttachmentMigrationUnavailable;
-exports.defineRecordAttachmentFamily = defineRecordAttachmentFamily;
-exports.resolveRecordAttachmentMigration = resolveRecordAttachmentMigration;
-exports.runRecordAttachmentMigration = runRecordAttachmentMigration;
-exports.defineRecordAttachmentRegistry = defineRecordAttachmentRegistry;
-exports.recordAttachmentRegistryFamily = recordAttachmentRegistryFamily;
-exports.isJsonRecordAttachmentDefinition = isJsonRecordAttachmentDefinition;
-exports.isRecordAttachmentFamily = isRecordAttachmentFamily;
-exports.recordAttachmentFamilyCurrentDefinition = recordAttachmentFamilyCurrentDefinition;
-exports.recordAttachmentFamilyOwner = recordAttachmentFamilyOwner;
-exports.isRecordAttachmentRegistry = isRecordAttachmentRegistry;
+exports.makeFixedRecordAttachmentValueFromDecoded = makeFixedRecordAttachmentValueFromDecoded;
 const effect_1 = require("effect");
-const core_ts_1 = require("../codec/core.cjs");
-const identifiers_ts_1 = require("../codec/identifiers.cjs");
-const identifiers_ts_2 = require("../model/identifiers.cjs");
+const attachment_ts_1 = require("../definition/attachment.cjs");
+const blob_ref_ts_1 = require("./blob-ref.cjs");
 const errors_ts_1 = require("./errors.cjs");
 const types_ts_1 = require("./types.cjs");
-const blobRefs = new WeakMap();
 const blobSources = new WeakMap();
 const blobDrafts = new WeakMap();
-const definitions = new WeakMap();
 const writes = new WeakMap();
-const migrationEdges = new WeakMap();
-const families = new WeakMap();
-const registries = new WeakMap();
-const values = new WeakMap();
+const fixedWriteSpecs = new WeakSet();
 const recordBlobHandleInvalid = Object.freeze({
     code: "record-blob-handle-invalid",
 });
@@ -49,110 +26,56 @@ function isObjectRecord(value) {
     return isObject(value);
 }
 function readOwn(value, key) {
-    if (!isObjectRecord(value)) {
-        return undefined;
-    }
-    return Object.prototype.hasOwnProperty.call(value, key) ? value[key] : undefined;
+    return isObjectRecord(value) && Object.prototype.hasOwnProperty.call(value, key)
+        ? value[key]
+        : undefined;
 }
 function freezeArray(items) {
     return Object.freeze([...items]);
 }
-function definitionRuntime(definition) {
-    return isObject(definition) ? definitions.get(definition) : undefined;
-}
-function familyRuntime(family) {
-    return isObject(family) ? families.get(family) : undefined;
-}
-function isRecordBlobRef(value) {
-    return isObject(value) && blobRefs.has(value);
-}
-function isRecordAttachmentBlobDraft(value) {
-    return isObject(value) && blobDrafts.has(value);
-}
-function payloadInvalidForDefinition() {
+function payloadInvalid(path = ["payload"]) {
     return (0, errors_ts_1.recordAttachmentPayloadInvalid)([
-        (0, errors_ts_1.recordAttachmentIssue)("record-attachment-schema-invalid", ["definition"]),
+        (0, errors_ts_1.recordAttachmentIssue)("record-attachment-schema-invalid", path),
     ]);
 }
-function closureInvalidForWrite() {
+function closureInvalid() {
     return (0, errors_ts_1.recordAttachmentClosureInvalid)([
         (0, errors_ts_1.recordAttachmentIssue)("record-attachment-closure-mismatch", ["write"]),
     ]);
 }
-function validOwner(value) {
-    return value === "run" || value === "attempt";
-}
-function decimalCompare(left, right) {
-    if (left.length !== right.length) {
-        return left.length < right.length ? -1 : 1;
-    }
-    if (left === right) {
-        return 0;
-    }
-    return left < right ? -1 : 1;
-}
-function incrementDecimal(value) {
-    const digits = value.split("");
-    let carry = 1;
-    for (let index = digits.length - 1; index >= 0; index -= 1) {
-        const digit = digits[index];
-        if (digit === undefined) {
-            break;
-        }
-        const next = Number(digit) + carry;
-        if (next === 10) {
-            digits[index] = "0";
-            carry = 1;
-        }
-        else {
-            digits[index] = String(next);
-            carry = 0;
-            break;
-        }
-    }
-    return carry === 1 ? `1${digits.join("")}` : digits.join("");
-}
-function schemaVersion(schemaId) {
-    return (0, identifiers_ts_2.parseRecordAttachmentSchemaId)(schemaId)?.version;
-}
-function makeBlobRef(builder) {
-    const ref = {
-        [types_ts_1.recordAttachmentBlobRefBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
-    };
-    blobRefs.set(ref, Object.freeze({ builder }));
-    return Object.freeze(ref);
-}
-/**
- * @internal Reader/storage integration mints hydrated refs without accepting a
- * disk key at the public API boundary.
- */
-function makeRecordBlobRef() {
-    return makeBlobRef(undefined);
+function fixedSpecInvalid() {
+    return (0, errors_ts_1.recordAttachmentDefinitionInvalid)([
+        (0, errors_ts_1.recordAttachmentIssue)("record-attachment-family-invalid", []),
+    ]);
 }
+var blob_ref_ts_2 = require("./blob-ref.cjs");
+Object.defineProperty(exports, "isRecordBlobRef", { enumerable: true, get: function () { return blob_ref_ts_2.isRecordBlobRef; } });
+Object.defineProperty(exports, "makeRecordBlobRef", { enumerable: true, get: function () { return blob_ref_ts_2.makeRecordBlobRef; } });
 /** Build a source capability from an Effect stream; raw bytes never enter this API. */
 function makeRecordBlobSource(stream) {
     const source = {
         stream,
         [types_ts_1.recordAttachmentBlobSourceBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
     };
-    blobSources.set(source, Object.freeze({
-        stream: stream,
-    }));
+    blobSources.set(source, Object.freeze({ stream: stream }));
     return Object.freeze(source);
 }
 function makeBuilder() {
-    const runtime = { drafts: [] };
+    const runtime = { owner: (0, blob_ref_ts_1.makeRecordBlobRefBuilderOwner)(), drafts: [] };
     const builder = {
         add(source) {
             const sourceRuntime = isObject(source) ? blobSources.get(source) : undefined;
-            const ref = makeBlobRef(runtime);
+            const ref = (0, blob_ref_ts_1.makeRecordBlobRef)(runtime.owner);
             const draft = {
                 ref,
                 [types_ts_1.recordAttachmentBlobDraftBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
             };
-            const untypedDraft = draft;
-            blobDrafts.set(draft, Object.freeze({ builder: runtime, ref, source: sourceRuntime }));
-            runtime.drafts.push(untypedDraft);
+            blobDrafts.set(draft, Object.freeze({
+                builder: runtime,
+                ref,
+                source: sourceRuntime,
+            }));
+            runtime.drafts.push(draft);
             return Object.freeze(draft);
         },
         [types_ts_1.recordAttachmentBlobBuilderBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
@@ -160,25 +83,17 @@ function makeBuilder() {
     return Object.freeze({ builder: Object.freeze(builder), runtime });
 }
 function isJsonArrayIndex(key) {
-    if (key === "0") {
+    if (key === "0")
         return true;
-    }
-    if (!/^[1-9][0-9]*$/.test(key)) {
+    if (!/^[1-9][0-9]*$/.test(key))
         return false;
-    }
     const index = Number(key);
     return Number.isSafeInteger(index) && index >= 0 && index < 4294967295;
 }
-/**
- * Schema validates the declared shape. This guard additionally keeps the
- * encoded boundary JSON-only: no functions, symbols, exotic prototypes,
- * native bytes, sparse arrays, or accessor properties. Package refs are the
- * intentional in-memory exception until storage assigns owner-local keys.
- */
+/** Defends the storage bridge in addition to RecordSchemaCodec canonicalization. */
 function isAttachmentJson(value, active = new WeakSet()) {
-    if (isRecordBlobRef(value)) {
+    if ((0, blob_ref_ts_1.isRecordBlobRef)(value))
         return true;
-    }
     switch (typeof value) {
         case "string":
         case "boolean":
@@ -190,51 +105,38 @@ function isAttachmentJson(value, active = new WeakSet()) {
         default:
             return false;
     }
-    if (value === null || !isObject(value)) {
+    if (value === null || !isObject(value) || active.has(value))
         return value === null;
-    }
-    if (active.has(value)) {
-        return false;
-    }
     active.add(value);
     try {
         if (Array.isArray(value)) {
-            if (Object.getPrototypeOf(value) !== Array.prototype) {
+            if (Object.getPrototypeOf(value) !== Array.prototype)
                 return false;
-            }
             for (const key of Reflect.ownKeys(value)) {
-                if (key === "length") {
+                if (key === "length")
                     continue;
-                }
-                if (typeof key !== "string" || !isJsonArrayIndex(key)) {
+                if (typeof key !== "string" || !isJsonArrayIndex(key))
                     return false;
-                }
                 const descriptor = Object.getOwnPropertyDescriptor(value, key);
-                if (descriptor === undefined || !descriptor.enumerable || !("value" in descriptor)) {
+                if (descriptor === undefined || !descriptor.enumerable || !("value" in descriptor))
                     return false;
-                }
             }
             for (let index = 0; index < value.length; index += 1) {
-                if (!Object.prototype.hasOwnProperty.call(value, index) || !isAttachmentJson(value[index], active)) {
+                if (!Object.prototype.hasOwnProperty.call(value, index) || !isAttachmentJson(value[index], active))
                     return false;
-                }
             }
             return true;
         }
-        if (Object.getPrototypeOf(value) !== Object.prototype) {
+        if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
             return false;
-        }
         for (const key of Reflect.ownKeys(value)) {
-            if (typeof key !== "string") {
+            if (typeof key !== "string")
                 return false;
-            }
             const descriptor = Object.getOwnPropertyDescriptor(value, key);
-            if (descriptor === undefined || !descriptor.enumerable || !("value" in descriptor)) {
+            if (descriptor === undefined || !descriptor.enumerable || !("value" in descriptor))
                 return false;
-            }
-            if (!isAttachmentJson(descriptor.value, active)) {
+            if (!isAttachmentJson(descriptor.value, active))
                 return false;
-            }
         }
         return true;
     }
@@ -245,184 +147,65 @@ function isAttachmentJson(value, active = new WeakSet()) {
         active.delete(value);
     }
 }
-function cloneAttachmentJson(value) {
-    if (isRecordBlobRef(value) || value === null || typeof value !== "object") {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value.map(cloneAttachmentJson);
-    }
-    const clone = {};
-    for (const [key, child] of Object.entries(value)) {
-        Object.defineProperty(clone, key, {
-            value: cloneAttachmentJson(child),
-            enumerable: true,
-            configurable: true,
-            writable: true,
-        });
-    }
-    return clone;
-}
 function deepFreezePayload(value, seen = new WeakSet()) {
-    if (!isObject(value) || isRecordBlobRef(value) || seen.has(value)) {
+    if (!isObject(value) || (0, blob_ref_ts_1.isRecordBlobRef)(value) || seen.has(value)) {
         return value;
     }
     seen.add(value);
     if (Array.isArray(value)) {
-        for (const item of value) {
+        for (const item of value)
             deepFreezePayload(item, seen);
-        }
     }
     else {
         for (const key of Reflect.ownKeys(value)) {
             const descriptor = Object.getOwnPropertyDescriptor(value, key);
-            if (descriptor !== undefined && "value" in descriptor) {
+            if (descriptor !== undefined && "value" in descriptor)
                 deepFreezePayload(descriptor.value, seen);
-            }
         }
     }
     Object.freeze(value);
     return value;
 }
-function definitionErrorForInput(input, builtIn) {
-    const rawOwner = readOwn(input, "owner");
-    const rawName = readOwn(input, "name");
-    const rawSchemaId = readOwn(input, "schemaId");
-    const rawSchema = readOwn(input, "schema");
-    const rawBlobRefs = readOwn(input, "blobRefs");
-    const nameText = typeof rawName === "string" ? rawName : "";
-    const name = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.RecordAttachmentNameSchema, core_ts_1.RecordExactParseOptions)(rawName);
-    if (effect_1.Either.isLeft(name)) {
-        return effect_1.Either.left(Object.freeze({ code: "record-attachment-name-invalid", name: nameText }));
-    }
-    const schemaIdText = typeof rawSchemaId === "string" ? rawSchemaId : "";
-    const schemaId = effect_1.Schema.decodeUnknownEither(identifiers_ts_1.RecordAttachmentSchemaIdSchema, core_ts_1.RecordExactParseOptions)(rawSchemaId);
-    if (effect_1.Either.isLeft(schemaId)) {
-        return effect_1.Either.left(Object.freeze({
-            code: "record-attachment-schema-id-invalid",
-            schemaId: schemaIdText,
-        }));
-    }
-    if (!builtIn && (0, identifiers_ts_2.isNiceEvalRecordAttachmentName)(name.right)) {
-        return effect_1.Either.left(Object.freeze({ code: "niceeval-namespace-reserved", name: nameText }));
-    }
-    if (builtIn && !(0, identifiers_ts_2.isNiceEvalRecordAttachmentName)(name.right)) {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentDefinitionInvalid)([
-            (0, errors_ts_1.recordAttachmentIssue)("record-attachment-schema-id-mismatch", ["name"]),
-        ]));
-    }
-    const schemaName = (0, identifiers_ts_2.recordAttachmentNameTextOfSchemaId)(schemaId.right);
-    const owner = validOwner(rawOwner) ? rawOwner : undefined;
-    const schema = effect_1.Schema.isSchema(rawSchema)
-        ? rawSchema
-        : undefined;
-    const blobRefsCallback = typeof rawBlobRefs === "function"
-        ? rawBlobRefs
-        : undefined;
-    const issues = [];
-    if (owner === undefined) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-owner-invalid", ["owner"]));
-    }
-    if (schemaName !== name.right) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-schema-id-mismatch", ["schemaId"]));
-    }
-    if (schema === undefined) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-schema-invalid", ["schema"]));
-    }
-    if (blobRefsCallback === undefined) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-refs-invalid", ["blobRefs"]));
-    }
-    if (issues.length > 0 ||
-        owner === undefined ||
-        schema === undefined ||
-        blobRefsCallback === undefined) {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentDefinitionInvalid)(issues));
-    }
-    return effect_1.Either.right({
-        owner,
-        name: name.right,
-        schemaId: schemaId.right,
-        schema,
-        blobRefs: blobRefsCallback,
-    });
-}
-function defineJsonRecordAttachmentWithNamespace(input, builtIn) {
-    const parsed = definitionErrorForInput(input, builtIn);
-    if (effect_1.Either.isLeft(parsed)) {
-        return effect_1.Either.left(parsed.left);
-    }
-    const definition = {
-        owner: parsed.right.owner,
-        name: parsed.right.name,
-        schemaId: parsed.right.schemaId,
-        blobRefs: input.blobRefs,
-        [types_ts_1.recordAttachmentDefinitionBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
-    };
-    definitions.set(definition, Object.freeze({
-        definition: definition,
-        owner: parsed.right.owner,
-        name: parsed.right.name,
-        schemaId: parsed.right.schemaId,
-        schema: parsed.right.schema,
-        blobRefs: parsed.right.blobRefs,
-        builtIn,
-    }));
-    return effect_1.Either.right(Object.freeze(definition));
+function encodeThroughCodec(ownerDefinition, payload) {
+    const encoded = ownerDefinition.codec.encode(payload);
+    if (effect_1.Either.isLeft(encoded))
+        return effect_1.Either.left(payloadInvalid());
+    return isAttachmentJson(encoded.right)
+        ? effect_1.Either.right(encoded.right)
+        : effect_1.Either.left(payloadInvalid());
 }
-/** Define a third-party JSON Attachment. `niceeval.*` remains package-reserved. */
-function defineJsonRecordAttachment(input) {
-    return defineJsonRecordAttachmentWithNamespace(input, false);
-}
-/** @internal Built-ins use the same validation but are the only `niceeval.*` authority. */
-function defineBuiltinJsonRecordAttachment(input) {
-    return defineJsonRecordAttachmentWithNamespace(input, true);
-}
-/** Exact decode at the JSON boundary. Registered in-memory refs are allowed only for integration hydration. */
-function decodeJsonRecordAttachmentPayload(definition, input) {
-    const runtime = definitionRuntime(definition);
-    if (runtime === undefined) {
-        return effect_1.Either.left(payloadInvalidForDefinition());
-    }
-    if (!isAttachmentJson(input)) {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentPayloadInvalid)([
-            (0, errors_ts_1.recordAttachmentIssue)("record-attachment-json-invalid", []),
-        ]));
-    }
-    const decoded = effect_1.Schema.decodeUnknownEither(runtime.schema, core_ts_1.RecordExactParseOptions)(input);
-    return effect_1.Either.isLeft(decoded)
-        ? effect_1.Either.left((0, errors_ts_1.recordAttachmentPayloadInvalid)([
-            (0, errors_ts_1.recordAttachmentIssue)("record-attachment-schema-invalid", []),
-        ]))
-        : effect_1.Either.right(decoded.right);
-}
-/** Exact encode at the JSON boundary. No Schema parse tree is leaked as public data. */
-function encodeJsonRecordAttachmentPayload(definition, payload) {
-    const runtime = definitionRuntime(definition);
-    if (runtime === undefined) {
-        return effect_1.Either.left(payloadInvalidForDefinition());
-    }
-    const encoded = effect_1.Schema.encodeUnknownEither(runtime.schema, core_ts_1.RecordExactParseOptions)(payload);
-    if (effect_1.Either.isLeft(encoded)) {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentPayloadInvalid)([
-            (0, errors_ts_1.recordAttachmentIssue)("record-attachment-schema-invalid", []),
-        ]));
-    }
-    if (!isAttachmentJson(encoded.right)) {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentPayloadInvalid)([
-            (0, errors_ts_1.recordAttachmentIssue)("record-attachment-json-invalid", []),
-        ]));
-    }
-    return effect_1.Either.right(encoded.right);
+function decodeThroughCodec(ownerDefinition, input) {
+    const decoded = ownerDefinition.codec.decode(input);
+    if (effect_1.Either.isLeft(decoded))
+        return effect_1.Either.left(payloadInvalid());
+    return effect_1.Either.right(decoded.right);
 }
-function appendIssues(destination, source, prefix = []) {
-    for (const issue of source) {
-        destination.push((0, errors_ts_1.recordAttachmentIssue)(issue.code, [...prefix, ...issue.path]));
-    }
+/**
+ * Mint the sole owner-local primitive from a static declaration value. This is
+ * deliberately not a registration API: all identity comes from the caller's
+ * exact fixed declaration and no global table is kept here.
+ */
+function makeFixedAttachmentWriteSpec(ownerDefinition) {
+    if (!(0, attachment_ts_1.isRecordAttachmentOwnerDefinition)(ownerDefinition)) {
+        return effect_1.Either.left(fixedSpecInvalid());
+    }
+    const exactOwner = ownerDefinition;
+    const spec = {
+        owner: ownerDefinition.owner,
+        family: ownerDefinition.family,
+        schemaVersion: ownerDefinition.schemaVersion,
+        encodePayload: (payload) => encodeThroughCodec(exactOwner, payload),
+        decodePayload: (inputValue) => decodeThroughCodec(exactOwner, inputValue),
+        refs: ownerDefinition.refs,
+        budget: Object.freeze({ ...ownerDefinition.budget }),
+        verify: ownerDefinition.verify,
+        [types_ts_1.fixedAttachmentWriteSpecBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
+    };
+    fixedWriteSpecs.add(spec);
+    return effect_1.Either.right(Object.freeze(spec));
 }
-function validateProjectedRefs(definition, payload, builder, issues) {
-    // `blobRefs` is a trusted extension callback. Deliberately do not catch it:
-    // a callback throw is a defect, not an Attachment data state.
-    const projected = definition.blobRefs(payload);
+function validateProjectedRefs(extract, payload, builder, issues) {
+    const projected = extract(payload);
     if (!Array.isArray(projected)) {
         issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-refs-invalid", ["blobRefs"]));
         return undefined;
@@ -430,8 +213,8 @@ function validateProjectedRefs(definition, payload, builder, issues) {
     const refs = [];
     const seen = new Set();
     for (const [index, ref] of projected.entries()) {
-        const runtime = isObject(ref) ? blobRefs.get(ref) : undefined;
-        if (runtime === undefined || (builder !== undefined && runtime.builder !== builder)) {
+        const builderOwner = (0, blob_ref_ts_1.isRecordBlobRef)(ref) ? (0, blob_ref_ts_1.getRecordBlobRefBuilderOwner)(ref) : undefined;
+        if (!(0, blob_ref_ts_1.isRecordBlobRef)(ref) || (builder !== undefined && builderOwner !== builder.owner)) {
             issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-ref-illegal", ["payload", String(index)]));
             continue;
         }
@@ -445,18 +228,21 @@ function validateProjectedRefs(definition, payload, builder, issues) {
     return refs;
 }
 function validateWriteRuntime(runtime) {
-    if (runtime.definition === undefined || runtime.builder === undefined || runtime.build === undefined) {
-        return effect_1.Either.left(closureInvalidForWrite());
+    if (runtime.fixed === undefined || runtime.builder === undefined || runtime.build === undefined) {
+        return effect_1.Either.left(closureInvalid());
     }
     const issues = [];
-    const encoded = effect_1.Schema.encodeUnknownEither(runtime.definition.schema, core_ts_1.RecordExactParseOptions)(runtime.build.payload);
+    const encoded = runtime.fixed.encodePayload(runtime.build.payload);
     if (effect_1.Either.isLeft(encoded)) {
         issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-payload-invalid", ["payload"]));
     }
     else if (!isAttachmentJson(encoded.right)) {
         issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-json-invalid", ["payload"]));
     }
-    const projected = validateProjectedRefs(runtime.definition, runtime.build.payload, runtime.builder, issues);
+    const projected = validateProjectedRefs(runtime.fixed.refs, runtime.build.payload, runtime.builder, issues);
+    if (projected !== undefined && projected.length > runtime.fixed.budget.maximumBlobs) {
+        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-budget-exceeded", ["blobs"]));
+    }
     const projectedSet = new Set(projected ?? []);
     if (!Array.isArray(runtime.build.blobs)) {
         issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-closure-mismatch", ["blobs"]));
@@ -465,9 +251,7 @@ function validateWriteRuntime(runtime) {
         const submitted = new Map();
         for (const [index, draft] of runtime.build.blobs.entries()) {
             const draftRuntime = isObject(draft) ? blobDrafts.get(draft) : undefined;
-            if (draftRuntime === undefined ||
-                draftRuntime.builder !== runtime.builder ||
-                !isRecordBlobRef(draftRuntime.ref)) {
+            if (draftRuntime === undefined || draftRuntime.builder !== runtime.builder || !(0, blob_ref_ts_1.isRecordBlobRef)(draftRuntime.ref)) {
                 issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-ref-illegal", ["blobs", String(index)]));
                 continue;
             }
@@ -477,9 +261,8 @@ function validateWriteRuntime(runtime) {
             }
             const count = (submitted.get(draftRuntime.ref) ?? 0) + 1;
             submitted.set(draftRuntime.ref, count);
-            if (count > 1) {
+            if (count > 1)
                 issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-ref-duplicate", ["blobs", String(index)]));
-            }
             if (!projectedSet.has(draftRuntime.ref)) {
                 issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-ref-extra", ["blobs", String(index)]));
             }
@@ -493,81 +276,59 @@ function validateWriteRuntime(runtime) {
         }
         for (const draft of runtime.builder.drafts) {
             const draftRuntime = blobDrafts.get(draft);
-            if (draftRuntime === undefined) {
+            if (draftRuntime === undefined)
                 throw new Error("RecordAttachment builder registry lost a draft it minted");
-            }
             if (!projectedSet.has(draftRuntime.ref) && (submitted.get(draftRuntime.ref) ?? 0) === 0) {
                 issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-ref-extra", ["builder"]));
             }
         }
     }
-    return issues.length === 0
-        ? effect_1.Either.right(undefined)
-        : effect_1.Either.left((0, errors_ts_1.recordAttachmentClosureInvalid)(issues));
+    return issues.length === 0 ? effect_1.Either.right(undefined) : effect_1.Either.left((0, errors_ts_1.recordAttachmentClosureInvalid)(issues));
 }
-function makeRecordAttachmentWriteForDefinition(definition, build) {
-    const builder = definition === undefined ? undefined : makeBuilder();
-    // Do not execute a builder for a forged family/definition. For a genuine
-    // builder, its callback is trusted and a throw must remain a defect.
+/** Build one opaque write from a genuine fixed owner primitive. */
+function makeFixedRecordAttachmentWrite(fixed, build) {
+    const builder = isObject(fixed) && fixedWriteSpecs.has(fixed) ? makeBuilder() : undefined;
     const result = builder === undefined ? undefined : build(builder.builder);
     const buildRuntime = isObjectRecord(result)
-        ? Object.freeze({
-            payload: readOwn(result, "payload"),
-            blobs: readOwn(result, "blobs"),
-        })
+        ? Object.freeze({ payload: readOwn(result, "payload"), blobs: readOwn(result, "blobs") })
         : undefined;
     const write = {
         [types_ts_1.recordAttachmentWriteBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
     };
     writes.set(write, Object.freeze({
-        definition: definition === undefined ? undefined : definitionRuntime(definition),
+        fixed: builder === undefined ? undefined : fixed,
         builder: builder?.runtime,
         build: buildRuntime,
     }));
     return Object.freeze(write);
 }
-/**
- * The only public generic writer builder. It captures its family, minted refs,
- * and sources; callers cannot provide a name, path, key, or raw bytes.
- */
-function makeRecordAttachmentWrite(family, build) {
-    const runtime = familyRuntime(family);
-    const definition = runtime?.current.definition;
-    return makeRecordAttachmentWriteForDefinition(definition, build);
-}
-/** Pure closure check used by the writer before any Stream is consumed. */
+/** Pure closure check used before any blob Stream is consumed. */
 function validateRecordAttachmentWrite(write) {
     return isObject(write)
-        ? validateWriteRuntime(writes.get(write) ?? Object.freeze({
-            definition: undefined,
-            builder: undefined,
-            build: undefined,
-        }))
-        : effect_1.Either.left(closureInvalidForWrite());
+        ? validateWriteRuntime(writes.get(write) ?? Object.freeze({ fixed: undefined, builder: undefined, build: undefined }))
+        : effect_1.Either.left(closureInvalid());
 }
 /** @internal Extract captured sources without exposing a raw write facade. */
 function recordAttachmentWriteContents(write) {
     const checked = validateRecordAttachmentWrite(write);
-    if (effect_1.Either.isLeft(checked) || !isObject(write)) {
-        return effect_1.Either.left(effect_1.Either.isLeft(checked) ? checked.left : closureInvalidForWrite());
-    }
+    if (effect_1.Either.isLeft(checked) || !isObject(write))
+        return effect_1.Either.left(effect_1.Either.isLeft(checked) ? checked.left : closureInvalid());
     const runtime = writes.get(write);
-    if (runtime?.definition === undefined || runtime.build === undefined || !Array.isArray(runtime.build.blobs)) {
-        throw new Error("RecordAttachment write passed closure validation without retained contents");
+    if (runtime?.fixed === undefined || runtime.build === undefined || !Array.isArray(runtime.build.blobs)) {
+        throw new Error("RecordAttachment write passed closure validation without retained fixed contents");
     }
     const captured = [];
     for (const draft of runtime.build.blobs) {
         const draftRuntime = isObject(draft) ? blobDrafts.get(draft) : undefined;
-        if (draftRuntime?.source === undefined) {
+        if (draftRuntime?.source === undefined)
             throw new Error("RecordAttachment write passed closure validation with an invalid source");
-        }
         captured.push(Object.freeze({
             ref: draftRuntime.ref,
             stream: draftRuntime.source.stream,
         }));
     }
     return effect_1.Either.right(Object.freeze({
-        definition: runtime.definition.definition,
+        fixed: runtime.fixed,
         payload: runtime.build.payload,
         blobs: freezeArray(captured),
     }));
@@ -575,27 +336,12 @@ function recordAttachmentWriteContents(write) {
 function isUint8Array(value) {
     return value instanceof Uint8Array;
 }
-function validateMaterializedClosure(definition, payload, blobs) {
-    const encoded = effect_1.Schema.encodeUnknownEither(definition.schema, core_ts_1.RecordExactParseOptions)(payload);
-    if (effect_1.Either.isLeft(encoded)) {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentPayloadInvalid)([
-            (0, errors_ts_1.recordAttachmentIssue)("record-attachment-schema-invalid", []),
-        ]));
-    }
-    if (!isAttachmentJson(encoded.right)) {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentPayloadInvalid)([
-            (0, errors_ts_1.recordAttachmentIssue)("record-attachment-json-invalid", []),
-        ]));
-    }
-    const normalizedEncoded = cloneAttachmentJson(encoded.right);
-    const decoded = effect_1.Schema.decodeUnknownEither(definition.schema, core_ts_1.RecordExactParseOptions)(normalizedEncoded);
-    if (effect_1.Either.isLeft(decoded)) {
-        throw new Error("RecordAttachment Schema encoded a value it cannot decode");
-    }
+function validateDecodedMaterializedClosure(fixed, payload, blobs) {
     const issues = [];
-    const projected = validateProjectedRefs(definition, decoded.right, undefined, issues);
+    const projected = validateProjectedRefs(fixed.refs, payload, undefined, issues);
     const expected = new Set(projected ?? []);
     const materialized = new Map();
+    let totalBytes = 0;
     if (!Array.isArray(blobs)) {
         issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-closure-mismatch", ["blobs"]));
     }
@@ -603,7 +349,7 @@ function validateMaterializedClosure(definition, payload, blobs) {
         for (const [index, entry] of blobs.entries()) {
             const ref = readOwn(entry, "ref");
             const bytes = readOwn(entry, "bytes");
-            if (!isRecordBlobRef(ref)) {
+            if (!(0, blob_ref_ts_1.isRecordBlobRef)(ref)) {
                 issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-ref-illegal", ["blobs", String(index), "ref"]));
                 continue;
             }
@@ -611,407 +357,71 @@ function validateMaterializedClosure(definition, payload, blobs) {
                 issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-snapshot-bytes-invalid", ["blobs", String(index), "bytes"]));
                 continue;
             }
+            if (bytes.byteLength > fixed.budget.maximumBlobBytes) {
+                issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-budget-exceeded", ["blobs", String(index), "bytes"]));
+            }
+            totalBytes += bytes.byteLength;
+            if (totalBytes > fixed.budget.maximumTotalBytes) {
+                issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-budget-exceeded", ["blobs"]));
+            }
             if (materialized.has(ref)) {
                 issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-ref-duplicate", ["blobs", String(index)]));
                 continue;
             }
-            materialized.set(ref, new Uint8Array(bytes));
-            if (!expected.has(ref)) {
+            materialized.set(ref, bytes);
+            if (!expected.has(ref))
                 issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-ref-extra", ["blobs", String(index)]));
-            }
         }
     }
-    if (projected !== undefined) {
-        for (const [index, ref] of projected.entries()) {
-            if (!materialized.has(ref)) {
-                issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-ref-missing", ["payload", String(index)]));
-            }
+    for (const [index, ref] of (projected ?? []).entries()) {
+        if (!materialized.has(ref)) {
+            issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-ref-missing", ["payload", String(index)]));
+        }
+    }
+    if (materialized.size > fixed.budget.maximumBlobs) {
+        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-blob-budget-exceeded", ["blobs"]));
+    }
+    if (issues.length === 0) {
+        try {
+            const snapshot = Object.freeze([...materialized.entries()].map(([ref, bytes]) => Object.freeze({ ref, bytes })));
+            issues.push(...fixed.verify(payload, snapshot));
+        }
+        catch {
+            issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-materialized-invalid", ["payload"]));
         }
     }
     return issues.length === 0
-        ? effect_1.Either.right(Object.freeze({
-            payload: decoded.right,
-            refs: freezeArray(projected ?? []),
-            bytes: materialized,
-        }))
+        ? effect_1.Either.right(Object.freeze({ payload, refs: freezeArray(projected ?? []), bytes: materialized }))
         : effect_1.Either.left((0, errors_ts_1.recordAttachmentClosureInvalid)(issues));
 }
 /**
- * @internal Create the self-contained value returned by an available reader
- * state. It performs no I/O and defensively copies all supplied bytes.
+ * Materialize a payload that the fixed owner's exact decoder has just accepted.
+ *
+ * The reader already performed bytes -> canonical JSON -> exact decode. Re-encoding,
+ * cloning, and decoding that same value here neither strengthens the disk trust
+ * boundary nor adds an owner check. Blob closure, budgets, owner verification, and
+ * the final immutable snapshot remain mandatory.
  */
-function makeRecordAttachmentValue(definition, payload, blobs) {
-    const runtime = definitionRuntime(definition);
-    if (runtime === undefined) {
-        return effect_1.Either.left(payloadInvalidForDefinition());
-    }
-    const checked = validateMaterializedClosure(runtime, payload, blobs);
-    if (effect_1.Either.isLeft(checked)) {
+function makeFixedRecordAttachmentValueFromDecoded(fixed, payload, blobs) {
+    if (!isObject(fixed) || !fixedWriteSpecs.has(fixed))
+        return effect_1.Either.left(payloadInvalid());
+    const checked = validateDecodedMaterializedClosure(fixed, payload, blobs);
+    if (effect_1.Either.isLeft(checked))
         return effect_1.Either.left(checked.left);
-    }
     const snapshotBytes = new Map();
-    for (const [ref, bytes] of checked.right.bytes) {
-        snapshotBytes.set(ref, bytes);
-    }
+    for (const [ref, bytes] of checked.right.bytes)
+        snapshotBytes.set(ref, new Uint8Array(bytes));
     const refs = freezeArray(checked.right.refs);
     const snapshotBlobs = Object.freeze({
         refs: () => freezeArray(refs),
         bytes: (ref) => {
             const bytes = isObject(ref) ? snapshotBytes.get(ref) : undefined;
-            return bytes === undefined
-                ? effect_1.Either.left(recordBlobHandleInvalid)
-                : effect_1.Either.right(new Uint8Array(bytes));
+            return bytes === undefined ? effect_1.Either.left(recordBlobHandleInvalid) : effect_1.Either.right(new Uint8Array(bytes));
         },
     });
-    const value = {
-        payload: deepFreezePayload(checked.right.payload),
+    return effect_1.Either.right(Object.freeze({
+        value: deepFreezePayload(checked.right.payload),
         blobs: snapshotBlobs,
-        [types_ts_1.recordAttachmentValueBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
-    };
-    values.set(value, Object.freeze({ definition: runtime, refs, bytes: snapshotBytes }));
-    return effect_1.Either.right(Object.freeze(value));
-}
-/** @internal Rejects a forged value before storage/migration integration accesses it. */
-function isRecordAttachmentValue(value) {
-    return isObject(value) && values.has(value);
-}
-/** @internal Exact runtime accessor for migration and projection integration. */
-function recordAttachmentValueDefinition(value) {
-    const runtime = isObject(value) ? values.get(value) : undefined;
-    if (runtime === undefined) {
-        return undefined;
-    }
-    return runtime.definition.definition;
-}
-function migrationPairIssues(from, to) {
-    const issues = [];
-    if (from === undefined) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", ["from"]));
-    }
-    if (to === undefined) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", ["to"]));
-    }
-    if (from === undefined || to === undefined) {
-        return issues;
-    }
-    if (from.owner !== to.owner) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", ["owner"]));
-    }
-    if (from.name !== to.name) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", ["name"]));
-    }
-    const fromVersion = schemaVersion(from.schemaId);
-    const toVersion = schemaVersion(to.schemaId);
-    if (fromVersion === undefined ||
-        toVersion === undefined ||
-        incrementDecimal(fromVersion) !== toVersion) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", ["schemaId"]));
-    }
-    return issues;
-}
-function migrationInputDefinitions(input) {
-    const fromValue = readOwn(input, "from");
-    const toValue = readOwn(input, "to");
-    return Object.freeze({
-        from: isObject(fromValue) ? definitions.get(fromValue) : undefined,
-        to: isObject(toValue) ? definitions.get(toValue) : undefined,
-    });
-}
-function migrationTarget(definition) {
-    const target = {
-        create(build) {
-            return makeRecordAttachmentWriteForDefinition(definition, build);
-        },
-    };
-    return Object.freeze(target);
-}
-/** Define one lossless adjacent edge. The converter is stored but never run here. */
-function defineRecordAttachmentMigration(input) {
-    const pair = migrationInputDefinitions(input);
-    const convert = readOwn(input, "convert");
-    const issues = migrationPairIssues(pair.from, pair.to);
-    if (typeof convert !== "function") {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", ["convert"]));
-    }
-    if (issues.length > 0 || pair.from === undefined || pair.to === undefined || typeof convert !== "function") {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentMigrationDefinitionInvalid)(issues));
-    }
-    const migration = {
-        [types_ts_1.recordAttachmentMigrationEdgeBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
-        [types_ts_1.recordAttachmentMigrationBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
-    };
-    migrationEdges.set(migration, Object.freeze({
-        edge: migration,
-        from: pair.from,
-        to: pair.to,
-        kind: "converter",
-        convert: convert,
-        reason: undefined,
-        valid: true,
     }));
-    return effect_1.Either.right(Object.freeze(migration));
-}
-/** Declare a settled, adjacent non-lossless edge. Family construction validates it. */
-function declareRecordAttachmentMigrationUnavailable(input) {
-    const pair = migrationInputDefinitions(input);
-    const rawReason = readOwn(input, "reason");
-    const reason = typeof rawReason === "string" ? rawReason : undefined;
-    const issues = migrationPairIssues(pair.from, pair.to);
-    if (reason === undefined || reason.trim().length === 0) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", ["reason"]));
-    }
-    const edge = {
-        [types_ts_1.recordAttachmentMigrationEdgeBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
-    };
-    migrationEdges.set(edge, Object.freeze({
-        edge: edge,
-        from: pair.from,
-        to: pair.to,
-        kind: "unavailable",
-        convert: undefined,
-        reason,
-        valid: issues.length === 0,
-    }));
-    return Object.freeze(edge);
-}
-function familyEdgeIssues(current, edge, path) {
-    const issues = [];
-    if (!edge.valid || edge.from === undefined || edge.to === undefined) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", path));
-        return issues;
-    }
-    if (edge.from.owner !== current.owner || edge.to.owner !== current.owner) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", [...path, "owner"]));
-    }
-    if (edge.from.name !== current.name || edge.to.name !== current.name) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", [...path, "name"]));
-    }
-    const fromVersion = schemaVersion(edge.from.schemaId);
-    const toVersion = schemaVersion(edge.to.schemaId);
-    const currentVersion = schemaVersion(current.schemaId);
-    if (fromVersion === undefined ||
-        toVersion === undefined ||
-        currentVersion === undefined ||
-        incrementDecimal(fromVersion) !== toVersion ||
-        decimalCompare(toVersion, currentVersion) > 0) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", [...path, "schemaId"]));
-    }
-    return issues;
-}
-/**
- * Define one complete family. Every historic version to the current definition
- * must be linked by exactly one adjacent edge; disconnected, duplicate, forked,
- * skipped, reverse, and future edges are all rejected before storage observes it.
- */
-function defineRecordAttachmentFamily(input) {
-    const currentValue = readOwn(input, "current");
-    const current = isObject(currentValue) ? definitions.get(currentValue) : undefined;
-    const migrationsValue = readOwn(input, "migrations");
-    const issues = [];
-    if (current === undefined) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-family-invalid", ["current"]));
-    }
-    if (!Array.isArray(migrationsValue)) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-family-invalid", ["migrations"]));
-    }
-    if (current === undefined || !Array.isArray(migrationsValue)) {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentFamilyInvalid)(issues));
-    }
-    const byFrom = new Map();
-    const bySchemaId = new Map();
-    bySchemaId.set(current.schemaId, current);
-    for (const [index, candidate] of migrationsValue.entries()) {
-        const edge = isObject(candidate) ? migrationEdges.get(candidate) : undefined;
-        const path = ["migrations", String(index)];
-        if (edge === undefined) {
-            issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", path));
-            continue;
-        }
-        appendIssues(issues, familyEdgeIssues(current, edge, path));
-        if (!edge.valid || edge.from === undefined || edge.to === undefined) {
-            continue;
-        }
-        const fromVersion = schemaVersion(edge.from.schemaId);
-        if (fromVersion === undefined) {
-            continue;
-        }
-        const prior = byFrom.get(fromVersion);
-        if (prior !== undefined) {
-            const code = prior.to?.definition === edge.to.definition
-                ? "record-attachment-migration-edge-duplicate"
-                : "record-attachment-migration-edge-fork";
-            issues.push((0, errors_ts_1.recordAttachmentIssue)(code, path));
-            continue;
-        }
-        byFrom.set(fromVersion, edge);
-        for (const definition of [edge.from, edge.to]) {
-            const priorDefinition = bySchemaId.get(definition.schemaId);
-            if (priorDefinition !== undefined && priorDefinition.definition !== definition.definition) {
-                issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-fork", path));
-            }
-            else {
-                bySchemaId.set(definition.schemaId, definition);
-            }
-        }
-    }
-    const currentVersion = schemaVersion(current.schemaId);
-    if (currentVersion === undefined) {
-        issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-family-invalid", ["current", "schemaId"]));
-    }
-    else {
-        let version = "1";
-        let traversed = 0;
-        let lastEdge;
-        while (version !== currentVersion) {
-            const edge = byFrom.get(version);
-            if (edge === undefined) {
-                issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-missing", ["migrations", version]));
-                break;
-            }
-            const next = edge.to === undefined ? undefined : schemaVersion(edge.to.schemaId);
-            if (next === undefined || decimalCompare(next, version) <= 0) {
-                issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", ["migrations", version]));
-                break;
-            }
-            traversed += 1;
-            lastEdge = edge;
-            version = next;
-        }
-        if (traversed !== byFrom.size) {
-            issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-family-invalid", ["migrations"]));
-        }
-        if (currentVersion !== "1" &&
-            (lastEdge?.to === undefined || lastEdge.to.definition !== current.definition)) {
-            issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-migration-edge-invalid", ["migrations", "current"]));
-        }
-    }
-    if (issues.length > 0) {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentFamilyInvalid)(issues));
-    }
-    const family = {
-        [types_ts_1.recordAttachmentFamilyBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
-    };
-    families.set(family, Object.freeze({ current, bySchemaId, edgesFrom: byFrom }));
-    return effect_1.Either.right(Object.freeze(family));
-}
-/** Resolve a known historical schema against a genuine current family. */
-function resolveRecordAttachmentMigration(family, sourceSchemaId) {
-    const runtime = familyRuntime(family);
-    if (runtime === undefined) {
-        return undefined;
-    }
-    if (sourceSchemaId === runtime.current.schemaId) {
-        return Object.freeze({ state: "current" });
-    }
-    const source = runtime.bySchemaId.get(sourceSchemaId);
-    if (source === undefined || source.name !== runtime.current.name) {
-        return Object.freeze({ state: "unsupported" });
-    }
-    const edges = [];
-    let schemaId = source.schemaId;
-    while (schemaId !== runtime.current.schemaId) {
-        const version = schemaVersion(schemaId);
-        const edge = version === undefined ? undefined : runtime.edgesFrom.get(version);
-        if (edge === undefined || edge.to === undefined) {
-            throw new Error("RecordAttachment family registry lost a validated migration edge");
-        }
-        if (edge.kind === "unavailable") {
-            return Object.freeze({
-                state: "migration-unavailable",
-                from: sourceSchemaId,
-                to: runtime.current.schemaId,
-                reason: edge.reason ?? "migration unavailable",
-            });
-        }
-        edges.push(edge.edge);
-        schemaId = edge.to.schemaId;
-    }
-    return Object.freeze({
-        state: "migration-required",
-        from: sourceSchemaId,
-        to: runtime.current.schemaId,
-        edges: freezeArray(edges),
-    });
-}
-/**
- * @internal Run one trusted converter at the integration boundary. `suspend`
- * turns a callback throw into an Effect defect while preserving its explicit E
- * failures and any fiber interruption without catch/recovery.
- */
-function runRecordAttachmentMigration(migration, source) {
-    return effect_1.Effect.suspend(() => {
-        const runtime = isObject(migration) ? migrationEdges.get(migration) : undefined;
-        if (runtime === undefined ||
-            !runtime.valid ||
-            runtime.kind !== "converter" ||
-            runtime.to === undefined ||
-            runtime.convert === undefined ||
-            !isRecordAttachmentValue(source)) {
-            return effect_1.Effect.die(new Error("RecordAttachment migration capability is invalid"));
-        }
-        const target = migrationTarget(runtime.to.definition);
-        return runtime.convert(source, target);
-    });
-}
-function registryKey(owner, name) {
-    return `${owner}\u0000${name}`;
-}
-/** Define a pure installed-family registry without touching storage or services. */
-function defineRecordAttachmentRegistry(input) {
-    const candidates = Array.isArray(input) ? input : readOwn(input, "families");
-    const issues = [];
-    if (!Array.isArray(candidates)) {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentRegistryInvalid)([
-            (0, errors_ts_1.recordAttachmentIssue)("record-attachment-family-invalid", ["families"]),
-        ]));
-    }
-    const registered = new Map();
-    for (const [index, candidate] of candidates.entries()) {
-        const runtime = isObject(candidate) ? families.get(candidate) : undefined;
-        if (runtime === undefined) {
-            issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-family-invalid", ["families", String(index)]));
-            continue;
-        }
-        const key = registryKey(runtime.current.owner, runtime.current.name);
-        if (registered.has(key)) {
-            issues.push((0, errors_ts_1.recordAttachmentIssue)("record-attachment-registry-family-duplicate", ["families", String(index)]));
-            continue;
-        }
-        registered.set(key, candidate);
-    }
-    if (issues.length > 0) {
-        return effect_1.Either.left((0, errors_ts_1.recordAttachmentRegistryInvalid)(issues));
-    }
-    const registry = {
-        [types_ts_1.recordAttachmentRegistryBrand]: () => (0, types_ts_1.recordAttachmentTypeWitness)(),
-    };
-    registries.set(registry, Object.freeze({ families: registered }));
-    return effect_1.Either.right(Object.freeze(registry));
-}
-/** @internal Exact lookup used by reader/migration integration. */
-function recordAttachmentRegistryFamily(registry, owner, name) {
-    const runtime = isObject(registry) ? registries.get(registry) : undefined;
-    return runtime?.families.get(registryKey(owner, name));
-}
-/** @internal Runtime guard for package-private integration boundaries. */
-function isJsonRecordAttachmentDefinition(value) {
-    return isObject(value) && definitions.has(value);
-}
-/** @internal Runtime guard for genuine family capabilities. */
-function isRecordAttachmentFamily(value) {
-    return isObject(value) && families.has(value);
-}
-/** @internal Returns the exact registered current definition, never a field copy. */
-function recordAttachmentFamilyCurrentDefinition(family) {
-    const runtime = familyRuntime(family);
-    return runtime?.current.definition;
-}
-/** @internal Reads owner only from a genuine family registry record. */
-function recordAttachmentFamilyOwner(family) {
-    return familyRuntime(family)?.current.owner;
-}
-/** @internal Runtime guard for a genuine installed registry. */
-function isRecordAttachmentRegistry(value) {
-    return isObject(value) && registries.has(value);
 }
 //# sourceMappingURL=runtime.cjs.map