niceeval 0.13.2 → 0.13.3

package/dist/record/host/runtime.cjs

@@ -117,8 +117,8 @@ function sameRoot(left, right) {
         leftPaths.portableRoot === rightPaths.portableRoot;
 }
 function currentFormatInspection(fileSystem, root) {
-    return (0, format_ts_1.readRecordFormatForMaintenance)(fileSystem, root).pipe(effect_1.Effect.flatMap((format) => effect_1.Effect.map(planAttachmentMigration({ fileSystem, root }), (attachments) => ({
-        state: format.sourceSchemaVersion === identifiers_ts_1.RECORD_SCHEMA_VERSION && attachments.targets.length === 0
+    return (0, format_ts_1.readRecordFormatForMaintenance)(fileSystem, root).pipe(effect_1.Effect.flatMap(() => effect_1.Effect.map(planAttachmentMigration({ fileSystem, root }), (attachments) => ({
+        state: attachments.targets.length === 0
             ? "already-current"
             : "migration-required",
         format: identifiers_ts_1.RECORD_FORMAT,
@@ -359,49 +359,25 @@ function scanSelection(runtime, fileSystem, request) {
         const wanted = request?.runIds === undefined
             ? undefined
             : new Set(request.runIds);
-        const entries = orderedEntries(yield* fileSystem.listDirectory({
-            directory: recordPath(runtime.root, "runs"),
-            maximumEntries: MAXIMUM_RUN_ENTRIES,
-        }));
         const snapshot = yield* readSealedCoreSnapshot(runtime, fileSystem);
-        const found = new Set();
         const warnings = [];
         const problems = [];
         const documents = [];
-        for (const entry of entries) {
-            if (entry.kind !== "directory")
-                continue;
-            const runId = decodeRunId(entry.name);
-            if (runId === undefined)
-                continue;
-            found.add(runId);
-            const sealed = yield* isSealedRun(fileSystem, runtime.root, runId);
-            if (!sealed) {
-                warnings.push(Object.freeze({
-                    code: "incomplete-run",
-                    runId,
-                    cleanupCommand: "niceeval clean",
-                }));
-                if (wanted?.has(runId)) {
-                    problems.push(Object.freeze({ code: "incomplete-run", runId }));
-                }
-                continue;
-            }
-            if (wanted !== undefined && !wanted.has(runId))
-                continue;
-            const core = snapshot.state === "available" ? snapshot.byRunId.get(runId) : undefined;
-            if (core === undefined) {
+        if (snapshot.state === "core-invalid") {
+            for (const runId of wanted ?? []) {
                 problems.push(Object.freeze({ code: "record-core-invalid", runId }));
             }
-            else {
-                documents.push(core.run);
-            }
         }
-        if (wanted !== undefined) {
+        else if (wanted === undefined) {
+            documents.push(...[...snapshot.byRunId.values()].map((core) => core.run));
+        }
+        else {
             for (const runId of wanted) {
-                if (!found.has(runId)) {
+                const core = snapshot.byRunId.get(runId);
+                if (core === undefined)
                     problems.push(Object.freeze({ code: "selection-run-missing", runId }));
-                }
+                else
+                    documents.push(core.run);
             }
         }
         const orderedDocuments = documents.sort((left, right) => (0, identifiers_ts_1.compareCanonicalIdentity)(left.runId, right.runId));
@@ -752,7 +728,6 @@ function mintRecordDocument(entropy) {
             ? effect_1.Effect.fail(coreInvalid())
             : effect_1.Effect.succeed(Object.freeze({
                 format: format.right,
-                schemaVersion: identifiers_ts_1.RECORD_SCHEMA_VERSION,
                 recordId: id.right,
             }));
     });
@@ -803,8 +778,6 @@ function openCurrentRead(input) {
             return yield* effect_1.Effect.fail(migrationInterrupted());
         }
         const current = yield* (0, format_ts_1.readCurrentRecordFormat)(fileSystem, input.root);
-        yield* ensureOrdinaryCurrentAttachments({ fileSystem, root: input.root });
-        yield* coordination.verifyRecordIdentity({ root: input.root, recordId: current.document.recordId });
         const lifecycle = { closed: false };
         const runtime = {
             root: input.root,
@@ -817,6 +790,15 @@ function openCurrentRead(input) {
             attemptsByKey: new Map(),
             sealedCoreSnapshot: undefined,
         };
+        const snapshot = yield* readSealedCoreSnapshot(runtime, fileSystem);
+        if (snapshot.state === "core-invalid")
+            return yield* effect_1.Effect.fail(bootstrapInvalid());
+        yield* ensureOrdinaryCurrentAttachments({
+            fileSystem,
+            root: input.root,
+            runIds: new Set(snapshot.byRunId.keys()),
+        });
+        yield* coordination.verifyRecordIdentity({ root: input.root, recordId: current.document.recordId });
         yield* effect_1.Effect.addFinalizer(() => effect_1.Effect.sync(() => { lifecycle.closed = true; }));
         return makeReadSession(runtime, fileSystem);
     });
@@ -1703,16 +1685,10 @@ function migrationDescriptor(descriptor) {
     return descriptor;
 }
 const runMigrationDescriptors = Object.freeze([
-    migrationDescriptor(catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.run),
-    migrationDescriptor(catalog_ts_1.NiceEvalRecordFamilyCatalog.sources),
-    migrationDescriptor(catalog_ts_1.NiceEvalRecordFamilyCatalog.artifacts.run),
+    ...catalog_ts_1.NiceEvalRecordFamilyDescriptorsByOwner.run.map(migrationDescriptor),
 ]);
 const attemptMigrationDescriptors = Object.freeze([
-    migrationDescriptor(catalog_ts_1.NiceEvalRecordFamilyCatalog.assertions),
-    migrationDescriptor(catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.attempt),
-    migrationDescriptor(catalog_ts_1.NiceEvalRecordFamilyCatalog.fileChanges),
-    migrationDescriptor(catalog_ts_1.NiceEvalRecordFamilyCatalog.sourceNavigation),
-    migrationDescriptor(catalog_ts_1.NiceEvalRecordFamilyCatalog.artifacts.attempt),
+    ...catalog_ts_1.NiceEvalRecordFamilyDescriptorsByOwner.attempt.map(migrationDescriptor),
 ]);
 function validateAttachmentDirectoryInventory(input) {
     return effect_1.Effect.gen(function* () {
@@ -1738,7 +1714,7 @@ function validateAttachmentDirectoryInventory(input) {
         }
     });
 }
-function validateCurrentFamilyInventory(fileSystem, root) {
+function validateCurrentFamilyInventory(fileSystem, root, runIds) {
     const runFamilies = new Set(runMigrationDescriptors.map((descriptor) => descriptor.family));
     const attemptFamilies = new Set(attemptMigrationDescriptors.map((descriptor) => descriptor.family));
     return effect_1.Effect.gen(function* () {
@@ -1752,6 +1728,8 @@ function validateCurrentFamilyInventory(fileSystem, root) {
             const runId = decodeRunId(entry.name);
             if (runId === undefined || !(yield* isSealedRun(fileSystem, root, runId)))
                 continue;
+            if (runIds !== undefined && !runIds.has(runId))
+                continue;
             yield* validateAttachmentDirectoryInventory({
                 fileSystem,
                 directory: (0, services_ts_1.recordPortablePath)(root, "runs", runId, "attachments"),
@@ -1798,7 +1776,7 @@ function migrationReaderLocation(location) {
  * never enumerates an attachment directory, so unknown families cannot enter
  * the migration graph or be rewritten as a side effect.
  */
-function knownMigrationAttachments(fileSystem, root) {
+function knownMigrationAttachments(fileSystem, root, runIds) {
     return effect_1.Effect.gen(function* () {
         const locations = [];
         const runs = yield* fileSystem.listDirectory({
@@ -1811,6 +1789,8 @@ function knownMigrationAttachments(fileSystem, root) {
             const runId = decodeRunId(entry.name);
             if (runId === undefined)
                 continue;
+            if (runIds !== undefined && !runIds.has(runId))
+                continue;
             // Draft directories are not Runs and belong exclusively to `niceeval
             // clean`; maintenance must preserve every byte beneath them.
             if (!(yield* isSealedRun(fileSystem, root, runId)))
@@ -1871,17 +1851,78 @@ function migrationFailureCode(error) {
     const code = Reflect.get(error, "code");
     return typeof code === "string" ? code : "record-command-failed";
 }
-function migrationTarget(location) {
+function normalizedMigrationRetention(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const retention = value;
+    const retainedFacts = retention.retainedFacts;
+    const droppedFacts = retention.droppedFacts;
+    const rerunRecommendation = retention.rerunRecommendation;
+    if (!Array.isArray(retainedFacts) || retainedFacts.some((fact) => typeof fact !== "string" || fact.length === 0) ||
+        !Array.isArray(droppedFacts) || droppedFacts.some((fact) => typeof fact !== "string" || fact.length === 0) ||
+        (rerunRecommendation !== null &&
+            (typeof rerunRecommendation !== "string" || rerunRecommendation.length === 0)))
+        return undefined;
+    return Object.freeze({
+        retainedFacts: Object.freeze([...retainedFacts]),
+        droppedFacts: Object.freeze([...droppedFacts]),
+        rerunRecommendation,
+    });
+}
+function migrationTarget(location, fromSchemaVersion, toSchemaVersion, retention) {
     return Object.freeze({
         family: location.descriptor.family,
         owner: location.owner,
         runId: location.runId,
         ...(location.attemptId === undefined ? {} : { attemptId: location.attemptId }),
-        fromSchemaVersion: 1,
-        toSchemaVersion: location.descriptor.schemaVersion,
+        fromSchemaVersion,
+        toSchemaVersion,
+        retention,
     });
 }
-const RECORD_MIGRATION_IMPLEMENTATION_ID = "niceeval.record/root-1-observability-1-to-root-2-observability-2/v1";
+function migrationLocationKey(owner, runId, attemptId, family) {
+    return `${owner}\u0000${runId}\u0000${attemptId ?? ""}\u0000${family}`;
+}
+function validateProspectiveCrossFamilyJoins(values) {
+    const byLocation = new Map(values.map(({ location, payload }) => [
+        migrationLocationKey(location.owner, location.runId, location.attemptId, location.descriptor.family),
+        payload,
+    ]));
+    for (const { location, payload } of values) {
+        const runSources = () => byLocation.get(migrationLocationKey("run", location.runId, undefined, catalog_ts_1.NiceEvalRecordFamilyCatalog.sources.family));
+        if (isObservabilityDescriptor(location.descriptor)) {
+            const observability = payload;
+            if (hasSourceFrames(observability)) {
+                const sources = runSources();
+                if (sources === undefined || (0, observability_ts_1.observabilitySourceFrameIntegrityIssues)(observability, sources).length > 0) {
+                    return false;
+                }
+            }
+        }
+        else if (isAssertionsDescriptor(location.descriptor)) {
+            const assertions = payload;
+            if (assertions.sourceSites.length > 0) {
+                const sources = runSources();
+                if (sources === undefined || (0, assertions_ts_1.assertionsSourceSiteIntegrityIssues)(assertions, sources).length > 0) {
+                    return false;
+                }
+            }
+        }
+        else if (isSourceNavigationDescriptor(location.descriptor)) {
+            if (location.attemptId === undefined)
+                return false;
+            const navigation = payload;
+            const observability = byLocation.get(migrationLocationKey("attempt", location.runId, location.attemptId, catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.attempt.family));
+            const sources = hasMappedNavigationRows(navigation) ? runSources() : undefined;
+            if (observability === undefined ||
+                (hasMappedNavigationRows(navigation) && sources === undefined) ||
+                (0, source_navigation_ts_1.sourceNavigationIntegrityIssues)({ payload: navigation, observability, sources }).length > 0)
+                return false;
+        }
+    }
+    return true;
+}
+const RECORD_MIGRATION_IMPLEMENTATION_ID = "niceeval.record/current-attachments/v2";
 const migrationPlanSources = new WeakMap();
 function bytesEqual(left, right) {
     return left.byteLength === right.byteLength && left.every((byte, index) => byte === right[index]);
@@ -1896,11 +1937,9 @@ function sameMigrationPlan(left, right) {
         return true;
     if (JSON.stringify(left.backup) !== JSON.stringify(right.backup))
         return false;
-    if (JSON.stringify(left.root) !== JSON.stringify(right.root))
-        return false;
     if (left.attachments.length !== right.attachments.length)
         return false;
-    return left.attachments.every((target, index) => {
+    if (!left.attachments.every((target, index) => {
         const candidate = right.attachments[index];
         return candidate !== undefined &&
             target.family === candidate.family &&
@@ -1908,23 +1947,46 @@ function sameMigrationPlan(left, right) {
             target.runId === candidate.runId &&
             target.attemptId === candidate.attemptId &&
             target.fromSchemaVersion === candidate.fromSchemaVersion &&
-            target.toSchemaVersion === candidate.toSchemaVersion;
+            target.toSchemaVersion === candidate.toSchemaVersion &&
+            JSON.stringify(target.retention) === JSON.stringify(candidate.retention);
+    }))
+        return false;
+    const leftSources = migrationPlanSources.get(left);
+    const rightSources = migrationPlanSources.get(right);
+    if (leftSources === undefined || rightSources === undefined ||
+        leftSources.implementationIdentity !== rightSources.implementationIdentity ||
+        !bytesEqual(leftSources.rootIdentityBytes, rightSources.rootIdentityBytes) ||
+        leftSources.attachments.length !== rightSources.attachments.length)
+        return false;
+    return leftSources.attachments.every((source, index) => {
+        const candidate = rightSources.attachments[index];
+        return candidate !== undefined &&
+            bytesEqual(source.envelopeBytes, candidate.envelopeBytes) &&
+            bytesEqual(source.payloadBytes, candidate.payloadBytes) &&
+            source.rewritePayload === candidate.rewritePayload &&
+            source.removedBlobs.length === candidate.removedBlobs.length &&
+            source.removedBlobs.every((blob, blobIndex) => {
+                const other = candidate.removedBlobs[blobIndex];
+                return other !== undefined && blob.key === other.key && bytesEqual(blob.bytes, other.bytes);
+            });
     });
 }
 function planAttachmentMigration(input) {
     return effect_1.Effect.gen(function* () {
-        yield* validateCurrentFamilyInventory(input.fileSystem, input.root);
+        yield* validateCurrentFamilyInventory(input.fileSystem, input.root, input.runIds);
         const targets = [];
         const sources = [];
-        for (const location of yield* knownMigrationAttachments(input.fileSystem, input.root)) {
+        const prospective = [];
+        for (const location of yield* knownMigrationAttachments(input.fileSystem, input.root, input.runIds)) {
             const read = yield* readKnownMigrationAttachment(input.fileSystem, input.root, location);
-            if (read.state === "available")
+            if (read.state === "available") {
+                prospective.push(Object.freeze({ location, payload: read.value }));
                 continue;
-            if (read.state === "migration-required" &&
-                location.descriptor.family === catalog_ts_1.NiceEvalRecordAttachments.observability.family &&
-                read.fromSchemaVersion === 1 &&
-                read.toSchemaVersion === 2) {
-                const target = migrationTarget(location);
+            }
+            const migrationLink = read.state === "migration-required"
+                ? location.descriptor.adjacentMigrationLinks.find((link) => link.fromSchemaVersion === read.fromSchemaVersion && link.toSchemaVersion === read.toSchemaVersion)
+                : undefined;
+            if (read.state === "migration-required" && migrationLink !== undefined) {
                 const envelopeBytes = yield* input.fileSystem.readFile({
                     file: migrationEnvelopePath(input.root, location),
                     maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
@@ -1932,8 +1994,47 @@ function planAttachmentMigration(input) {
                 if (envelopeBytes === undefined) {
                     return yield* effect_1.Effect.fail(migrationInvalid(location.descriptor.family));
                 }
+                const facet = yield* loadAttachmentMaintenance(location.descriptor);
+                const historical = facet.historicalCodecs.find((codec) => codec.schemaVersion === read.fromSchemaVersion);
+                const step = facet.adjacentMigrations.find((migration) => migration.fromSchemaVersion === read.fromSchemaVersion &&
+                    migration.toSchemaVersion === read.toSchemaVersion);
+                if (historical === undefined || step === undefined) {
+                    return yield* effect_1.Effect.fail(migrationInvalid(location.descriptor.family));
+                }
+                const retention = normalizedMigrationRetention(step.retention);
+                if (retention === undefined) {
+                    return yield* effect_1.Effect.fail(migrationInvalid(location.descriptor.family));
+                }
+                const target = migrationTarget(location, read.fromSchemaVersion, read.toSchemaVersion, retention);
+                const prepared = yield* (0, runtime_ts_1.validateFixedRecordAttachmentMigrationSource)({
+                    fileSystem: input.fileSystem,
+                    root: input.root,
+                    location: migrationReaderLocation(location),
+                    descriptor: location.descriptor,
+                    fromSchemaVersion: read.fromSchemaVersion,
+                    decodeHistorical: historical.decode,
+                    ...(historical.verify === undefined ? {} : { verifyHistorical: historical.verify }),
+                    migrate: step.migrate,
+                });
+                if (prepared === false || prepared.rewritePayload !== migrationLink.rewritePayload) {
+                    return yield* effect_1.Effect.fail(migrationInvalid(location.descriptor.family));
+                }
+                prospective.push(Object.freeze({ location, payload: prepared.payload }));
+                const payloadBytes = yield* input.fileSystem.readFile({
+                    file: (0, services_ts_1.recordPortablePath)(input.root, ...migrationAttachmentDirectory(input.root, location).segments, "payload.json"),
+                    maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
+                });
+                if (payloadBytes === undefined)
+                    return yield* effect_1.Effect.fail(migrationInvalid(location.descriptor.family));
                 targets.push(target);
-                sources.push(Object.freeze({ target, envelopeBytes }));
+                sources.push(Object.freeze({
+                    target,
+                    location,
+                    envelopeBytes,
+                    payloadBytes,
+                    removedBlobs: prepared.removedBlobs,
+                    rewritePayload: migrationLink.rewritePayload,
+                }));
                 continue;
             }
             if (read.state === "unsupported") {
@@ -1944,6 +2045,9 @@ function planAttachmentMigration(input) {
             }
             return yield* effect_1.Effect.fail(migrationInvalid(location.descriptor.family));
         }
+        if (!validateProspectiveCrossFamilyJoins(prospective)) {
+            return yield* effect_1.Effect.fail(migrationInvalid("niceeval.record cross-family"));
+        }
         return Object.freeze({
             targets: Object.freeze(targets),
             sources: Object.freeze(sources),
@@ -1951,29 +2055,41 @@ function planAttachmentMigration(input) {
     });
 }
 function ensureOrdinaryCurrentAttachments(input) {
-    return planAttachmentMigration(input).pipe(effect_1.Effect.flatMap((plan) => plan.targets.length === 0
-        ? effect_1.Effect.void
-        : effect_1.Effect.fail(new errors_ts_3.RecordMigrationRequired({
-            code: "record-migration-required",
-            source: "niceeval.record attachment predecessor",
-            target: `${identifiers_ts_1.RECORD_FORMAT}@${identifiers_ts_1.RECORD_SCHEMA_VERSION}`,
-            command: "niceeval migrate",
-        }))), effect_1.Effect.mapError((error) => error instanceof errors_ts_3.RecordMigrationInvalid
-        ? bootstrapInvalid()
-        : error));
+    return effect_1.Effect.gen(function* () {
+        yield* validateCurrentFamilyInventory(input.fileSystem, input.root, input.runIds);
+        for (const location of yield* knownMigrationAttachments(input.fileSystem, input.root, input.runIds)) {
+            const envelope = yield* (0, runtime_ts_1.inspectFixedRecordAttachmentEnvelope)({
+                fileSystem: input.fileSystem,
+                root: input.root,
+                location: migrationReaderLocation(location),
+                descriptor: location.descriptor,
+            });
+            if (envelope.state === "current" || envelope.state === "unavailable")
+                continue;
+            if (envelope.state === "migration-required") {
+                return yield* effect_1.Effect.fail(new errors_ts_3.RecordMigrationRequired({
+                    code: "record-migration-required",
+                    source: `${envelope.family}@${envelope.fromSchemaVersion}`,
+                    target: `${envelope.family}@${envelope.toSchemaVersion}`,
+                    command: "niceeval migrate",
+                }));
+            }
+            if (envelope.state === "unsupported") {
+                return yield* effect_1.Effect.fail(new errors_ts_3.RecordFormatUnsupported({
+                    code: "record-format-unsupported",
+                    format: `${envelope.family}@${envelope.schemaVersion}`,
+                }));
+            }
+            return yield* effect_1.Effect.fail(bootstrapInvalid());
+        }
+    });
 }
 function migrationPlan(input) {
     return effect_1.Effect.gen(function* () {
         const format = yield* (0, format_ts_1.readRecordFormatForMaintenance)(input.fileSystem, input.root);
         yield* validateSealedCoreForMigration(input.fileSystem, input.root, format.document);
         const attachments = yield* planAttachmentMigration(input);
-        const rootMigration = format.sourceSchemaVersion === identifiers_ts_1.RECORD_SCHEMA_VERSION
-            ? null
-            : Object.freeze({
-                fromSchemaVersion: format.sourceSchemaVersion,
-                toSchemaVersion: identifiers_ts_1.RECORD_SCHEMA_VERSION,
-            });
-        if (rootMigration === null && attachments.targets.length === 0) {
+        if (attachments.targets.length === 0) {
             return Object.freeze({ state: "already-current", format: identifiers_ts_1.RECORD_FORMAT });
         }
         const backup = yield* input.git.inspectBackupState(input.root);
@@ -1981,13 +2097,11 @@ function migrationPlan(input) {
             state: "migration-required",
             format: identifiers_ts_1.RECORD_FORMAT,
             backup,
-            root: rootMigration,
             attachments: attachments.targets,
         });
         migrationPlanSources.set(plan, Object.freeze({
             attachments: attachments.sources,
-            rootBytes: rootMigration === null ? null : format.sourceBytes,
-            record: format.document,
+            rootIdentityBytes: format.sourceBytes,
             implementationIdentity: RECORD_MIGRATION_IMPLEMENTATION_ID,
         }));
         return plan;
@@ -1998,39 +2112,35 @@ function validateSealedCoreForMigration(fileSystem, root, record) {
         ? effect_1.Effect.void
         : effect_1.Effect.fail(migrationInvalid("niceeval.core")));
 }
-function loadObservabilityV1Maintenance() {
-    const loader = catalog_ts_1.NiceEvalRecordAttachments.observability.maintenance;
+function loadAttachmentMaintenance(descriptor) {
+    const loader = descriptor.maintenance;
     if (loader === undefined)
-        return effect_1.Effect.fail(migrationInvalid(catalog_ts_1.NiceEvalRecordAttachments.observability.family));
+        return effect_1.Effect.fail(migrationInvalid(descriptor.family));
     return effect_1.Effect.tryPromise({
         try: loader,
-        catch: () => migrationInvalid(catalog_ts_1.NiceEvalRecordAttachments.observability.family),
+        catch: () => migrationInvalid(descriptor.family),
     });
 }
-function migrateObservabilityAttachment(input) {
+function migrateKnownAttachment(input) {
     return effect_1.Effect.gen(function* () {
-        if (input.target.family !== catalog_ts_1.NiceEvalRecordAttachments.observability.family ||
-            input.target.fromSchemaVersion !== 1 ||
-            input.target.toSchemaVersion !== 2) {
+        const descriptor = input.location.descriptor;
+        const migrationLink = descriptor.adjacentMigrationLinks.find((link) => link.fromSchemaVersion === input.target.fromSchemaVersion &&
+            link.toSchemaVersion === input.target.toSchemaVersion);
+        if (migrationLink === undefined || migrationLink.rewritePayload !== input.rewritePayload) {
             return yield* effect_1.Effect.fail(migrationInvalid(input.target.family));
         }
-        const descriptor = input.target.owner === "run"
-            ? migrationDescriptor(catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.run)
-            : migrationDescriptor(catalog_ts_1.NiceEvalRecordFamilyCatalog.observability.attempt);
-        const location = input.target.owner === "run"
-            ? Object.freeze({ owner: "run", runId: input.target.runId, descriptor })
-            : Object.freeze({
-                owner: "attempt",
-                runId: input.target.runId,
-                attemptId: input.target.attemptId,
-                descriptor,
-            });
-        const facet = yield* loadObservabilityV1Maintenance();
-        const historical = facet.historicalCodecs.find((codec) => codec.schemaVersion === 1);
-        const step = facet.adjacentMigrations.find((migration) => migration.fromSchemaVersion === 1 && migration.toSchemaVersion === 2);
+        const location = input.location;
+        const facet = yield* loadAttachmentMaintenance(descriptor);
+        const historical = facet.historicalCodecs.find((codec) => codec.schemaVersion === input.target.fromSchemaVersion);
+        const step = facet.adjacentMigrations.find((migration) => migration.fromSchemaVersion === input.target.fromSchemaVersion &&
+            migration.toSchemaVersion === input.target.toSchemaVersion);
         if (historical === undefined || step === undefined) {
             return yield* effect_1.Effect.fail(migrationInvalid(input.target.family));
         }
+        const retention = normalizedMigrationRetention(step.retention);
+        if (retention === undefined || JSON.stringify(retention) !== JSON.stringify(input.target.retention)) {
+            return yield* effect_1.Effect.fail(migrationInvalid(input.target.family));
+        }
         const envelopePath = migrationEnvelopePath(input.root, location);
         const sourceBeforeValidation = yield* input.fileSystem.readFile({
             file: envelopePath,
@@ -2039,16 +2149,25 @@ function migrateObservabilityAttachment(input) {
         if (sourceBeforeValidation === undefined || !bytesEqual(sourceBeforeValidation, input.expectedEnvelopeBytes)) {
             return yield* effect_1.Effect.fail(migrationPlanStale());
         }
-        const valid = yield* (0, runtime_ts_1.validateFixedRecordAttachmentMigrationSource)({
+        const payloadPath = (0, services_ts_1.recordPortablePath)(input.root, ...migrationAttachmentDirectory(input.root, location).segments, "payload.json");
+        const payloadBeforeValidation = yield* input.fileSystem.readFile({
+            file: payloadPath,
+            maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
+        });
+        if (payloadBeforeValidation === undefined || !bytesEqual(payloadBeforeValidation, input.expectedPayloadBytes)) {
+            return yield* effect_1.Effect.fail(migrationPlanStale());
+        }
+        const validated = yield* (0, runtime_ts_1.validateFixedRecordAttachmentMigrationSource)({
             fileSystem: input.fileSystem,
             root: input.root,
             location: migrationReaderLocation(location),
             descriptor,
-            fromSchemaVersion: 1,
+            fromSchemaVersion: input.target.fromSchemaVersion,
             decodeHistorical: historical.decode,
+            ...(historical.verify === undefined ? {} : { verifyHistorical: historical.verify }),
             migrate: step.migrate,
         });
-        if (!valid) {
+        if (validated === false) {
             const sourceAfterInvalid = yield* input.fileSystem.readFile({
                 file: envelopePath,
                 maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
@@ -2059,8 +2178,8 @@ function migrateObservabilityAttachment(input) {
             return yield* effect_1.Effect.fail(migrationInvalid(input.target.family));
         }
         const envelope = (0, catalog_ts_1.encodeFixedRecordAttachmentEnvelope)({
-            family: catalog_ts_1.NiceEvalRecordAttachments.observability.family,
-            schemaVersion: 2,
+            family: descriptor.family,
+            schemaVersion: input.target.toSchemaVersion,
         });
         if (effect_1.Either.isLeft(envelope))
             return yield* effect_1.Effect.fail(migrationInvalid(input.target.family));
@@ -2071,6 +2190,44 @@ function migrateObservabilityAttachment(input) {
         if (sourceBeforeWrite === undefined || !bytesEqual(sourceBeforeWrite, input.expectedEnvelopeBytes)) {
             return yield* effect_1.Effect.fail(migrationPlanStale());
         }
+        if (validated.rewritePayload !== input.rewritePayload) {
+            return yield* effect_1.Effect.fail(migrationInvalid(input.target.family));
+        }
+        if (validated.removedBlobs.length !== input.expectedRemovedBlobs.length ||
+            validated.removedBlobs.some((blob, index) => {
+                const expected = input.expectedRemovedBlobs[index];
+                return expected === undefined || blob.key !== expected.key || !bytesEqual(blob.bytes, expected.bytes);
+            })) {
+            return yield* effect_1.Effect.fail(migrationPlanStale());
+        }
+        if (input.rewritePayload) {
+            const encodedPayload = descriptor.write.encodePayload(validated.payload);
+            if (effect_1.Either.isLeft(encodedPayload))
+                return yield* effect_1.Effect.fail(migrationInvalid(input.target.family));
+            const durablePayload = (0, attachment_payload_ts_1.encodeAttachmentPayloadForStorage)({
+                payload: encodedPayload.right,
+                blobKeys: validated.blobKeys,
+            });
+            if (effect_1.Either.isLeft(durablePayload))
+                return yield* effect_1.Effect.fail(migrationInvalid(input.target.family));
+            yield* input.fileSystem.writeFile({
+                file: payloadPath,
+                bytes: jsonBytes(durablePayload.right),
+                maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
+                mode: "replace-no-follow",
+            });
+        }
+        for (const blob of input.expectedRemovedBlobs) {
+            const blobPath = (0, services_ts_1.recordPortablePath)(input.root, ...migrationAttachmentDirectory(input.root, location).segments, "blobs", blob.key);
+            const beforeDelete = yield* input.fileSystem.readFile({
+                file: blobPath,
+                maximumBytes: descriptor.write.budget.maximumBlobBytes,
+            });
+            if (beforeDelete === undefined || !bytesEqual(beforeDelete, blob.bytes)) {
+                return yield* effect_1.Effect.fail(migrationPlanStale());
+            }
+            yield* input.fileSystem.removeFile((0, services_ts_1.recordPortablePath)(input.root, ...migrationAttachmentDirectory(input.root, location).segments, "blobs", blob.key));
+        }
         yield* input.fileSystem.writeFile({
             file: envelopePath,
             bytes: jsonBytes(envelope.right),
@@ -2102,35 +2259,10 @@ function validateCurrentKnownAttachments(input) {
 }
 function migrationRecoveryIsSafe(input) {
     return effect_1.Effect.gen(function* () {
-        const encoded = (0, catalog_ts_1.encodeFixedRecordAttachmentEnvelope)({
-            family: catalog_ts_1.NiceEvalRecordAttachments.observability.family,
-            schemaVersion: 2,
-        });
-        if (effect_1.Either.isLeft(encoded))
-            return false;
-        const currentEnvelopeBytes = jsonBytes(encoded.right);
-        const expectedPaths = [(0, services_ts_1.recordPortablePath)(input.root, "migration.in-progress")];
-        const currentRoot = yield* input.fileSystem.readFile({
-            file: (0, services_ts_1.recordPortablePath)(input.root, "record.json"),
-            maximumBytes: format_ts_1.RECORD_FORMAT_DOCUMENT_MAXIMUM_BYTES,
-        });
-        if (currentRoot !== undefined) {
-            const parsed = parseJson(currentRoot);
-            if (typeof parsed === "object" && parsed !== null &&
-                Reflect.get(parsed, "schemaVersion") === identifiers_ts_1.RECORD_SCHEMA_VERSION)
-                expectedPaths.push((0, services_ts_1.recordPortablePath)(input.root, "record.json"));
-        }
-        for (const location of yield* knownMigrationAttachments(input.fileSystem, input.root)) {
-            if (location.descriptor.family !== catalog_ts_1.NiceEvalRecordAttachments.observability.family)
-                continue;
-            const path = migrationEnvelopePath(input.root, location);
-            const bytes = yield* input.fileSystem.readFile({
-                file: path,
-                maximumBytes: limits_ts_1.RECORD_JSON_MAXIMUM_BYTES,
-            });
-            if (bytes !== undefined && bytesEqual(bytes, currentEnvelopeBytes))
-                expectedPaths.push(path);
-        }
+        const expectedPaths = [
+            (0, services_ts_1.recordPortablePath)(input.root, "migration.in-progress"),
+            ...input.expectedRelativePaths.map((relative) => (0, services_ts_1.recordPortablePath)(input.root, ...relative.split("/"))),
+        ];
         return yield* input.git.recoveryChangesAreExpected({
             root: input.root,
             restoreCommit: input.restoreCommit,
@@ -2145,11 +2277,17 @@ function openMaintenance(input) {
         const git = yield* services_ts_1.RecordGit;
         yield* coordination.enterRecordMaintenance(input.root);
         if (yield* fileSystem.migrationSentinelPresent(input.root)) {
-            const restoreCommit = yield* fileSystem.readMigrationSentinelRestoreCommit(input.root);
-            const restoreSafe = restoreCommit === undefined
+            const sentinel = yield* fileSystem.readMigrationSentinel(input.root);
+            const restoreSafe = sentinel === undefined
                 ? false
-                : yield* migrationRecoveryIsSafe({ fileSystem, git, root: input.root, restoreCommit });
-            return yield* effect_1.Effect.fail(migrationInterrupted(restoreCommit, restoreSafe));
+                : yield* migrationRecoveryIsSafe({
+                    fileSystem,
+                    git,
+                    root: input.root,
+                    restoreCommit: sentinel.restoreCommit,
+                    expectedRelativePaths: sentinel.expectedRelativePaths,
+                });
+            return yield* effect_1.Effect.fail(migrationInterrupted(sentinel?.restoreCommit, restoreSafe));
         }
         const inspect = () => currentFormatInspection(fileSystem, input.root);
         const planMigrate = () => effect_1.Effect.gen(function* () {
@@ -2183,14 +2321,32 @@ function openMaintenance(input) {
                 const plannedSources = migrationPlanSources.get(currentPlan);
                 if (plannedSources === undefined ||
                     plannedSources.implementationIdentity !== RECORD_MIGRATION_IMPLEMENTATION_ID ||
-                    plannedSources.attachments.length !== currentPlan.attachments.length ||
-                    (currentPlan.root === null) !== (plannedSources.rootBytes === null)) {
-                    return yield* effect_1.Effect.fail(migrationInvalid(catalog_ts_1.NiceEvalRecordAttachments.observability.family));
+                    plannedSources.attachments.length !== currentPlan.attachments.length) {
+                    return yield* effect_1.Effect.fail(migrationInvalid("niceeval.core"));
                 }
                 let portableTargetWritten = false;
+                const expectedRelativePaths = Object.freeze([
+                    ...plannedSources.attachments.flatMap((source) => {
+                        const base = migrationAttachmentDirectory(input.root, source.location).segments.join("/");
+                        return source.rewritePayload
+                            ? [
+                                `${base}/attachment.json`,
+                                `${base}/payload.json`,
+                                ...source.removedBlobs.map((blob) => `${base}/blobs/${blob.key}`),
+                            ]
+                            : [`${base}/attachment.json`];
+                    }),
+                ]);
+                const rootBeforeSentinel = yield* fileSystem.readFile({
+                    file: (0, services_ts_1.recordPortablePath)(input.root, "record.json"),
+                    maximumBytes: format_ts_1.RECORD_FORMAT_DOCUMENT_MAXIMUM_BYTES,
+                });
+                if (rootBeforeSentinel === undefined ||
+                    !bytesEqual(rootBeforeSentinel, plannedSources.rootIdentityBytes))
+                    return yield* effect_1.Effect.fail(migrationPlanStale());
                 // The sentinel is the first portable write. Any later failure or
                 // interruption intentionally leaves it behind for Git recovery.
-                yield* fileSystem.createMigrationSentinel(input.root, restoreCommit);
+                yield* fileSystem.createMigrationSentinel(input.root, restoreCommit, expectedRelativePaths);
                 const sentinelOnly = yield* git.recoveryChangesAreExpected({
                     root: input.root,
                     restoreCommit,
@@ -2202,31 +2358,15 @@ function openMaintenance(input) {
                 }
                 yield* effect_1.Effect.gen(function* () {
                     for (const source of plannedSources.attachments) {
-                        yield* migrateObservabilityAttachment({
+                        yield* migrateKnownAttachment({
                             fileSystem,
                             root: input.root,
+                            location: source.location,
                             target: source.target,
                             expectedEnvelopeBytes: source.envelopeBytes,
-                        });
-                        portableTargetWritten = true;
-                    }
-                    if (plannedSources.rootBytes !== null) {
-                        const rootPath = (0, services_ts_1.recordPortablePath)(input.root, "record.json");
-                        const sourceBeforeRootWrite = yield* fileSystem.readFile({
-                            file: rootPath,
-                            maximumBytes: format_ts_1.RECORD_FORMAT_DOCUMENT_MAXIMUM_BYTES,
-                        });
-                        if (sourceBeforeRootWrite === undefined ||
-                            !bytesEqual(sourceBeforeRootWrite, plannedSources.rootBytes))
-                            return yield* effect_1.Effect.fail(migrationPlanStale());
-                        const encodedRoot = (0, index_ts_1.encodeRecordDocument)(plannedSources.record);
-                        if (effect_1.Either.isLeft(encodedRoot))
-                            return yield* effect_1.Effect.fail(migrationInvalid("niceeval.core"));
-                        yield* fileSystem.writeFile({
-                            file: rootPath,
-                            bytes: jsonBytes(encodedRoot.right),
-                            maximumBytes: format_ts_1.RECORD_FORMAT_DOCUMENT_MAXIMUM_BYTES,
-                            mode: "replace-no-follow",
+                            expectedPayloadBytes: source.payloadBytes,
+                            expectedRemovedBlobs: source.removedBlobs,
+                            rewritePayload: source.rewritePayload,
                         });
                         portableTargetWritten = true;
                     }
@@ -2235,7 +2375,13 @@ function openMaintenance(input) {
                     yield* validateCurrentKnownAttachments({ fileSystem, root: input.root });
                     yield* fileSystem.removeMigrationSentinel(input.root);
                 }).pipe(effect_1.Effect.catchAll((error) => {
-                    const recoveryRequired = () => effect_1.Effect.flatMap(migrationRecoveryIsSafe({ fileSystem, git, root: input.root, restoreCommit }), (restoreSafe) => effect_1.Effect.fail(new errors_ts_3.RecordMigrationRecoveryRequired({
+                    const recoveryRequired = () => effect_1.Effect.flatMap(migrationRecoveryIsSafe({
+                        fileSystem,
+                        git,
+                        root: input.root,
+                        restoreCommit,
+                        expectedRelativePaths,
+                    }), (restoreSafe) => effect_1.Effect.fail(new errors_ts_3.RecordMigrationRecoveryRequired({
                         code: "record-migration-recovery-required",
                         causeCode: migrationFailureCode(error),
                         restoreCommit,
@@ -2249,7 +2395,11 @@ function openMaintenance(input) {
                     }
                     return recoveryRequired();
                 }));
-                return Object.freeze({ state: "migrated", format: identifiers_ts_1.RECORD_FORMAT });
+                return Object.freeze({
+                    state: "migrated",
+                    format: identifiers_ts_1.RECORD_FORMAT,
+                    attachments: currentPlan.attachments,
+                });
             }),
         });
     });