chainlesschain 0.166.7 → 0.166.9

package/src/lib/graph-kernel/compiler.js

@@ -7,6 +7,8 @@ export const GRAPH_DEFINITION_MIN_VERSION = Math.max(
   0,
   GRAPH_DEFINITION_VERSION - 1,
 );
+export const GRAPH_DEFINITION_MIGRATION_EVIDENCE_SCHEMA =
+  "chainlesschain.graph-definition-migration/v1";
 export const GRAPH_COMPILE_ERROR = "CC_GRAPH_COMPILE_FAILED";
 
 const compiledGraphs = new WeakSet();
@@ -1285,6 +1287,22 @@ export function compileGraphDefinition(input, options = {}) {
     definition,
     `cc.graph.definition/${definition.schemaVersion}`,
   );
+  const migrationBackup =
+    migrated.migratedFrom == null ? null : deepFreeze(stableValue(input));
+  const definitionMigration =
+    migrationBackup == null
+      ? null
+      : deepFreeze({
+          schema: GRAPH_DEFINITION_MIGRATION_EVIDENCE_SCHEMA,
+          fromVersion: migrated.migratedFrom,
+          toVersion: definition.schemaVersion,
+          revisionDigest,
+          backupDefinition: migrationBackup,
+          rollbackDigest: graphDigest(
+            migrationBackup,
+            `cc.graph.definition-backup/${migrated.migratedFrom}`,
+          ),
+        });
   const compiled = {
     schema: "chainlesschain.compiled-graph/v1",
     schemaVersion: definition.schemaVersion,
@@ -1293,6 +1311,7 @@ export function compileGraphDefinition(input, options = {}) {
     revision: definition.revision,
     revisionDigest,
     migratedFrom: migrated.migratedFrom,
+    definitionMigration,
     nodes: deepFreeze(
       Object.fromEntries([...nodes].map(([id, value]) => [id, value])),
     ),
@@ -1369,25 +1388,59 @@ export function assertCompiledGraph(value) {
 }
 
 export function migrateGraphDefinition(input, options = {}) {
-  const { definition, migratedFrom } = migrateDefinition(input, options);
-  const compiled = compileGraphDefinition(definition, options);
-  const backupDefinition =
-    migratedFrom == null ? null : deepFreeze(stableValue(input));
+  const compiled = compileGraphDefinition(input, options);
+  const migration = compiled.definitionMigration;
   return Object.freeze({
     dryRun: options.dryRun !== false,
-    fromVersion: migratedFrom ?? definition.schemaVersion,
+    fromVersion: migration?.fromVersion ?? compiled.schemaVersion,
     toVersion: compiled.schemaVersion,
     definition: compiled.definition,
     revisionDigest: compiled.revisionDigest,
-    backupRequired: migratedFrom != null,
+    backupRequired: migration != null,
+    backupDefinition: migration?.backupDefinition || null,
+    rollbackDigest: migration?.rollbackDigest || null,
+  });
+}
+
+export function validateGraphDefinitionMigrationEvidence(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    const error = new TypeError(
+      "graph definition migration evidence is required",
+    );
+    error.code = "CC_GRAPH_MIGRATION_EVIDENCE_INVALID";
+    throw error;
+  }
+  if (
+    value.schema !== GRAPH_DEFINITION_MIGRATION_EVIDENCE_SCHEMA ||
+    Number(value.fromVersion) !== GRAPH_DEFINITION_VERSION - 1 ||
+    Number(value.toVersion) !== GRAPH_DEFINITION_VERSION ||
+    !/^sha256:[a-f0-9]{64}$/u.test(String(value.revisionDigest || ""))
+  ) {
+    const error = new TypeError(
+      "graph definition migration evidence has an invalid schema or version",
+    );
+    error.code = "CC_GRAPH_MIGRATION_EVIDENCE_INVALID";
+    throw error;
+  }
+  const backupDefinition = restoreGraphDefinitionBackup(
+    value.backupDefinition,
+    value.rollbackDigest,
+  );
+  const replay = compileGraphDefinition(backupDefinition);
+  if (replay.revisionDigest !== value.revisionDigest) {
+    const error = new TypeError(
+      "graph definition migration replay does not match its canonical revision",
+    );
+    error.code = "CC_GRAPH_MIGRATION_REPLAY_MISMATCH";
+    throw error;
+  }
+  return deepFreeze({
+    schema: GRAPH_DEFINITION_MIGRATION_EVIDENCE_SCHEMA,
+    fromVersion: GRAPH_DEFINITION_VERSION - 1,
+    toVersion: GRAPH_DEFINITION_VERSION,
+    revisionDigest: value.revisionDigest,
     backupDefinition,
-    rollbackDigest:
-      backupDefinition == null
-        ? null
-        : graphDigest(
-            backupDefinition,
-            `cc.graph.definition-backup/${migratedFrom}`,
-          ),
+    rollbackDigest: value.rollbackDigest,
   });
 }
 

package/src/lib/graph-kernel/cutover-authority-resolver.js

@@ -9,6 +9,7 @@ import {
   graphRuntimeSurfaceEntry,
   loadGraphRuntimeSurfaceManifest,
 } from "./runtime-surface-manifest.js";
+import { normalizeGraphRetirementContract } from "./retirement-evidence.js";
 
 const AUTHORITY_MODES = new Set(["legacy", "shadow", "canonical"]);
 
@@ -68,6 +69,17 @@ export class GraphCutoverAuthorityResolver {
     this.retirementStores = [...declared.entry.storeDispositions.retire].sort();
     this.rebuildStores = [...declared.entry.storeDispositions.rebuild].sort();
     this.disabledStores = [...declared.entry.storeDispositions.disabled].sort();
+    this.retirementContract =
+      this.cutoverStrategy === "retire"
+        ? normalizeGraphRetirementContract({
+            rolloutKey: declared.entry.rolloutKey,
+            replacementEntrypoint: declared.entry.replacementEntrypoint,
+            replacementEntryIds: declared.entry.replacementEntryIds,
+            historicalReadFunctions: declared.entry.historicalReadFunctions,
+            mutationFunctions: declared.entry.mutationFunctions,
+            writerFiles: declared.entry.writerFiles,
+          })
+        : null;
     this.ledger = ledger;
     this.fallbackMode =
       fallbackMode === undefined
@@ -112,6 +124,19 @@ export class GraphCutoverAuthorityResolver {
         },
       );
     }
+    const stateRetirementContract =
+      this.cutoverStrategy === "retire"
+        ? normalizeGraphRetirementContract(state.retirementContract)
+        : null;
+    if (
+      JSON.stringify(stateRetirementContract) !==
+      JSON.stringify(this.retirementContract)
+    ) {
+      throw resolverError(
+        "CC_GRAPH_CUTOVER_RETIREMENT_CONTRACT_CONFLICT",
+        "cutover authority is bound to a stale retirement contract",
+      );
+    }
     return state;
   }
 
@@ -122,6 +147,7 @@ export class GraphCutoverAuthorityResolver {
       manifestDigest: this.manifestDigest,
       stores: this.stores,
       cutoverStrategy: this.cutoverStrategy,
+      retirementContract: this.retirementContract,
     });
   }
 

package/src/lib/graph-kernel/cutover-ledger.js

@@ -2,6 +2,11 @@ import { createHash } from "node:crypto";
 import { JsonlRolloutStore } from "../app-server/rollout-store.js";
 import { assertGraphCutoverTransition } from "./authority.js";
 import { graphDigest } from "./compiler.js";
+import {
+  normalizeGraphLegacyWriterObservation,
+  normalizeGraphRetirementContract,
+  normalizeGraphRetirementEvidence,
+} from "./retirement-evidence.js";
 import { graphStoreEvidenceDigest } from "./store-cutover-evidence.js";
 
 export const GRAPH_CUTOVER_LEDGER_SCHEMA =
@@ -329,17 +334,16 @@ function forwardEvidence(from, to, input, state) {
     if (state.cutoverStrategy === "retire") {
       return {
         ...canonicalEvidence,
-        retirementProbeDigest: digest(
-          input.retirementProbeDigest,
-          "retirementProbeDigest",
-        ),
-        activeLegacyRunCount: zero(
-          input.activeLegacyRunCount,
-          "activeLegacyRunCount",
-        ),
-        legacyMutationSuccessCount: zero(
-          input.legacyMutationSuccessCount,
-          "legacyMutationSuccessCount",
+        retirementEvidence: normalizeGraphRetirementEvidence(
+          input.retirementEvidence,
+          {
+            surface: state.surface,
+            entryId: state.entryId,
+            manifestDigest: state.manifestDigest,
+            commitSha: platforms[0].commitSha,
+            contract: state.retirementContract,
+            requiredPlatforms: GRAPH_CUTOVER_REQUIRED_PLATFORMS,
+          },
         ),
       };
     }
@@ -357,6 +361,21 @@ function forwardEvidence(from, to, input, state) {
     };
   }
   if (from === "canonical" && to === "legacy_read_only") {
+    if (state.cutoverStrategy === "retire") {
+      return {
+        legacyWriterObservation: normalizeGraphLegacyWriterObservation(
+          input.legacyWriterObservation,
+          {
+            surface: state.surface,
+            entryId: state.entryId,
+            manifestDigest: state.manifestDigest,
+            commitSha: state.canonicalCommitSha,
+            contract: state.retirementContract,
+            notBefore: state.updatedAt,
+          },
+        ),
+      };
+    }
     return {
       writerInventoryDigest: digest(
         input.writerInventoryDigest,
@@ -477,6 +496,7 @@ export class GraphCutoverLedger {
     manifestDigest,
     stores,
     cutoverStrategy: strategyInput = "migrate",
+    retirementContract = undefined,
   }) {
     const safeSurface = identifier(surface, "surface");
     const safeEntryId = identifier(entryId, "entryId");
@@ -485,6 +505,10 @@ export class GraphCutoverLedger {
     const safeStores = storeInventory(stores, {
       allowEmpty: safeCutoverStrategy !== "migrate",
     });
+    const safeRetirementContract =
+      safeCutoverStrategy === "retire"
+        ? normalizeGraphRetirementContract(retirementContract)
+        : null;
     const threadId = this._thread(safeSurface, safeEntryId);
     this.store.start({
       threadId,
@@ -516,6 +540,19 @@ export class GraphCutoverLedger {
           "cutover entry is already bound to a different strategy",
         );
       }
+      const existingRetirementContract =
+        safeCutoverStrategy === "retire"
+          ? normalizeGraphRetirementContract(existing.retirementContract)
+          : null;
+      if (
+        JSON.stringify(existingRetirementContract) !==
+        JSON.stringify(safeRetirementContract)
+      ) {
+        throw cutoverError(
+          "CC_GRAPH_CUTOVER_RETIREMENT_CONTRACT_CONFLICT",
+          "cutover entry is already bound to a different retirement contract",
+        );
+      }
       return projection(existing, events);
     }
     const timestamp = new Date(this.now()).toISOString();
@@ -525,6 +562,7 @@ export class GraphCutoverLedger {
       entryId: safeEntryId,
       manifestDigest: safeManifestDigest,
       cutoverStrategy: safeCutoverStrategy,
+      retirementContract: safeRetirementContract,
       stores: safeStores,
       stage: "legacy",
       canaryPercent: 0,
@@ -596,6 +634,10 @@ export class GraphCutoverLedger {
             ? 100
             : 0,
       optInOnly: to === "canary" ? normalized.optInOnly === true : false,
+      canonicalCommitSha:
+        to === "canonical"
+          ? normalized.platformEvidence[0].commitSha
+          : current.canonicalCommitSha || null,
       transitionCount: current.transitionCount + 1,
       rollbackCount: current.rollbackCount + (rollback ? 1 : 0),
       lastEvidenceDigest: graphDigest(