ai-workflow-logic 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-workflow-logic",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "private": false,
   "description": "AI workflow domain projections and pure runtime helpers with an explicit Halfcode filesystem adapter",
   "type": "module",
@@ -13,10 +13,12 @@
     "./run-freeze": "./src/run-freeze.ts"
   },
   "dependencies": {
-    "ai-workflow-contract": "0.1.4",
+    "ai-workflow-contract": "0.1.6",
+    "flow-step-space-contract": "0.1.1",
+    "flow-step-space-logic": "0.1.1",
     "halfcode-compiler.xnl": "0.2.2",
-    "work-ctrl-flow-contract": "0.1.1",
-    "work-ctrl-flow-logic": "0.1.1"
+    "work-ctrl-flow-contract": "0.1.3",
+    "work-ctrl-flow-logic": "0.1.3"
   },
   "files": [
     "src"

package/src/checkpoint-filesystem.ts

@@ -15,6 +15,7 @@ import type {
 import type { WorkCtrlFlowSnapshot } from 'work-ctrl-flow-contract';
 import {
   createMaterializedWorkCtrlFlowEngineFromDirectory,
+  loadFrozenCtrlDefinitionStepIds,
   loadMaterializedFlowInstance,
   materializeFlowInstance,
   type MaterializedWorkCtrlFlowDirectoryOptions,
@@ -30,6 +31,24 @@ import {
   normalizeFlowClosedObject,
   normalizeFlowRunCheckpoint,
 } from './run-checkpoint.js';
+import {
+  checkpointHeadJson,
+  createDirectoryDurably,
+  encodeCheckpointSidecars,
+  isCheckpointHead,
+  persistCheckpointSidecars,
+  readCheckpointHeadAndLogical,
+  renameDurably,
+  writeDurableCandidate,
+  type CheckpointDurabilityRuntime,
+  type FlowRunCheckpointHead,
+} from './checkpoint-sidecar.js';
+import type { StepMerkleTree } from 'flow-step-space-contract';
+import type { DefinitionStepExtensionCodecRegistryPort } from 'flow-step-space-contract';
+import {
+  validateCheckpointAgainstFrozenProfile,
+  type FlowRunProfileAuthorityPort,
+} from './checkpoint-profile.js';
 
 const CHECKPOINT_FILE = 'checkpoint.json';
 const CHECKPOINT_STAGING_FILE = 'checkpoint.staging.json';
@@ -47,6 +66,31 @@ const NO_FOLLOW = fs.constants.O_NOFOLLOW ?? 0;
 export interface FilesystemFlowRunCheckpointStoreOptions {
   /** Injected support root; the domain contract never derives a host path. */
   readonly storeRoot: string;
+  readonly durability?: CheckpointDurabilityRuntime;
+  readonly profileAuthority?: FlowRunProfileAuthorityPort;
+  readonly extensionCodecs?: DefinitionStepExtensionCodecRegistryPort;
+}
+
+export interface FilesystemFlowRunCheckpointRuntime {
+  readonly storage: FilesystemFlowRunCheckpointStoreOptions;
+}
+
+export interface CreateFilesystemFlowRunCheckpointStoreInput {}
+export interface CreateFilesystemFlowRunCheckpointStoreConfig {}
+
+export function createFilesystemFlowRunCheckpointRuntime(
+  options: FilesystemFlowRunCheckpointStoreOptions,
+): FilesystemFlowRunCheckpointRuntime {
+  return Object.freeze({ storage: Object.freeze({ ...options }) });
+}
+
+/** Processor authority; host root policy is injected only through runtime.storage. */
+export function createFilesystemFlowRunCheckpointStore(
+  runtime: FilesystemFlowRunCheckpointRuntime,
+  _input: CreateFilesystemFlowRunCheckpointStoreInput,
+  _config: CreateFilesystemFlowRunCheckpointStoreConfig,
+): FilesystemFlowRunCheckpointStore {
+  return new FilesystemFlowRunCheckpointStore(runtime.storage);
 }
 
 export interface CanonicalMaterializedWorkCtrlFlowOptions
@@ -85,7 +129,11 @@ export function createCanonicalMaterializedWorkCtrlFlowEngine(
             'bundleDir and source identity are required to admit a new canonical WorkCtrl instance.',
           );
         })();
-  const checkpointStore = new FilesystemFlowRunCheckpointStore({ storeRoot: options.storeRoot });
+  const checkpointStore = createFilesystemFlowRunCheckpointStore(
+    createFilesystemFlowRunCheckpointRuntime({ storeRoot: options.storeRoot }),
+    {},
+    {},
+  );
   const store = createWorkCtrlFlowCheckpointStore(
     { checkpointStore },
     {
@@ -222,12 +270,18 @@ type FlowRunFilesystemLocations = {
 export class FilesystemFlowRunCheckpointStore implements FlowRunCheckpointStore<FlowRunProfileState> {
   readonly #storeRoot: string;
   readonly #realStoreRoot: string;
+  readonly #durability: CheckpointDurabilityRuntime | undefined;
+  readonly #profileAuthority: FlowRunProfileAuthorityPort | undefined;
+  readonly #extensionCodecs: DefinitionStepExtensionCodecRegistryPort;
 
   constructor(options: FilesystemFlowRunCheckpointStoreOptions) {
     const root = path.resolve(options.storeRoot);
     assertExistingDirectory(root, undefined, 'flow-run-store-root-invalid');
     this.#storeRoot = root;
     this.#realStoreRoot = fs.realpathSync(root);
+    this.#durability = options.durability;
+    this.#profileAuthority = options.profileAuthority;
+    this.#extensionCodecs = options.extensionCodecs ?? Object.freeze({ resolve: () => undefined });
   }
 
   async load(key: FlowRunCheckpointKey): Promise<AIWorkflowFlowRunCheckpoint | undefined> {
@@ -241,6 +295,7 @@ export class FilesystemFlowRunCheckpointStore implements FlowRunCheckpointStore<
     if (!fs.existsSync(locations.checkpointFile)) return undefined;
     const checkpoint = readCheckpointFile(locations.checkpointFile, this.#realStoreRoot);
     this.#assertCheckpointIdentity(checkpoint, key, descriptor.definition);
+    this.#validateFrozenProfile(checkpoint);
     return checkpoint;
   }
 
@@ -254,24 +309,44 @@ export class FilesystemFlowRunCheckpointStore implements FlowRunCheckpointStore<
     this.#preflightExistingRunBoundary(locations);
     const descriptor = this.#requireInstance(locations.instanceDir, key.instanceId);
     this.#assertCheckpointIdentity(checkpoint, key, descriptor.definition);
+    const frozenAuthority = this.#validateFrozenProfile(checkpoint);
 
     this.#ensureRunDirectory(locations);
     const lock = await acquireLock(locations.runDir, locations.lockFile, this.#realStoreRoot);
     try {
       this.#assertRunPhysicalBoundary(locations);
       removeUncommittedStaging(locations.stagingFile, locations.runDir, this.#realStoreRoot);
-      const current = fs.existsSync(locations.checkpointFile)
-        ? readCheckpointFile(locations.checkpointFile, this.#realStoreRoot)
+      const currentStorage = fs.existsSync(locations.checkpointFile)
+        ? readCheckpointStorage(locations.checkpointFile, this.#realStoreRoot)
         : undefined;
-      if (current) this.#assertCheckpointIdentity(current, key, descriptor.definition);
+      const current = currentStorage?.checkpoint;
+      if (current) {
+        this.#assertCheckpointIdentity(current, key, descriptor.definition);
+        this.#validateFrozenProfile(current);
+      }
       const actualVersion = current?.version ?? null;
       if (actualVersion !== input.expectedVersion) {
         throw new FlowRunCheckpointVersionConflictError(input.expectedVersion, actualVersion);
       }
       validateFlowRunCheckpointTransition(current, checkpoint);
-      writeCheckpointCandidate(locations.stagingFile, checkpoint, this.#realStoreRoot);
+      ensureSidecarDirectories(locations.runDir, this.#realStoreRoot, this.#durability);
+      const definitionStepIds = frozenAuthority?.definitionStepIds ?? (checkpoint.profile.kind === 'AIDataWorkflow'
+        ? undefined
+        : loadFrozenCtrlDefinitionStepIds(
+            path.join(locations.instanceDir, 'definition'),
+            checkpoint.profile.kind,
+          ));
+      const encoded = encodeCheckpointSidecars(checkpoint, currentStorage?.tree, {
+        definitionStepIds,
+        previousMaterialRecordDigests: currentStorage?.materialRecordDigests,
+      });
+      removeUnacceptedSidecarReceipt(locations.runDir, checkpoint.version, this.#realStoreRoot);
+      persistCheckpointSidecars(locations.runDir, encoded, this.#durability);
+      assertSidecarDirectories(locations.runDir, this.#realStoreRoot);
+      writeCheckpointCandidate(locations.stagingFile, encoded.head, this.#realStoreRoot, this.#durability);
       const staged = readCheckpointFile(locations.stagingFile, this.#realStoreRoot);
       this.#assertCheckpointIdentity(staged, key, descriptor.definition);
+      this.#validateFrozenProfile(staged);
       if (stableJson(staged) !== stableJson(checkpoint)) {
         throw new FlowRunFilesystemStoreError(
           'flow-run-checkpoint-readback-mismatch',
@@ -283,9 +358,10 @@ export class FilesystemFlowRunCheckpointStore implements FlowRunCheckpointStore<
       if (fs.existsSync(locations.checkpointFile)) {
         assertRegularFile(locations.checkpointFile, this.#realStoreRoot, 'flow-run-checkpoint-invalid');
       }
-      fs.renameSync(locations.stagingFile, locations.checkpointFile);
+      renameDurably(locations.stagingFile, locations.checkpointFile, 'head', this.#durability);
       const accepted = readCheckpointFile(locations.checkpointFile, this.#realStoreRoot);
       this.#assertCheckpointIdentity(accepted, key, descriptor.definition);
+      this.#validateFrozenProfile(accepted);
       if (stableJson(accepted) !== stableJson(checkpoint)) {
         throw new FlowRunFilesystemStoreError(
           'flow-run-checkpoint-readback-mismatch',
@@ -491,9 +567,16 @@ export class FilesystemFlowRunCheckpointStore implements FlowRunCheckpointStore<
     }
   }
 
+  #validateFrozenProfile(checkpoint: AIWorkflowFlowRunCheckpoint) {
+    return validateCheckpointAgainstFrozenProfile(checkpoint, {
+      ...(this.#profileAuthority === undefined ? {} : { profileAuthority: this.#profileAuthority }),
+      extensionCodecs: this.#extensionCodecs,
+    }, { requireAIDataAuthority: true });
+  }
+
   #ensureRunDirectory(locations: FlowRunFilesystemLocations): void {
-    ensureChildDirectory(locations.instanceDir, locations.runsDir, this.#realStoreRoot);
-    ensureChildDirectory(locations.runsDir, locations.runDir, this.#realStoreRoot);
+    ensureChildDirectory(locations.instanceDir, locations.runsDir, this.#realStoreRoot, this.#durability, 'head');
+    ensureChildDirectory(locations.runsDir, locations.runDir, this.#realStoreRoot, this.#durability, 'head');
     this.#assertRunPhysicalBoundary(locations);
   }
 
@@ -919,20 +1002,46 @@ function assertRealContainment(realRoot: string, file: string, code: string): vo
   }
 }
 
-function ensureChildDirectory(parent: string, child: string, realRoot: string): void {
+function ensureChildDirectory(
+  parent: string,
+  child: string,
+  realRoot: string,
+  durability?: CheckpointDurabilityRuntime,
+  durabilityRole: 'record' | 'tree' | 'receipt' | 'head' = 'record',
+): void {
   assertExistingDirectory(parent, realRoot, 'flow-run-boundary-invalid');
   if (fs.existsSync(child)) {
     assertExistingDirectory(child, realRoot, 'flow-run-symlink-boundary');
     return;
   }
-  fs.mkdirSync(child);
+  createDirectoryDurably(child, durabilityRole, durability);
   assertExistingDirectory(child, realRoot, 'flow-run-boundary-invalid');
 }
 
 function readCheckpointFile(file: string, realRoot: string): AIWorkflowFlowRunCheckpoint {
+  return readCheckpointStorage(file, realRoot).checkpoint;
+}
+
+function readCheckpointStorage(
+  file: string,
+  realRoot: string,
+): {
+  readonly checkpoint: AIWorkflowFlowRunCheckpoint;
+  readonly tree?: StepMerkleTree;
+  readonly materialRecordDigests?: readonly import('flow-step-space-contract').DefinitionStepDigest[];
+} {
   const value = readJsonFile(file, realRoot, 'flow-run-checkpoint-invalid');
   try {
-    return normalizeFlowRunCheckpoint(value);
+    if (isCheckpointHead(value)) {
+      assertSidecarDirectories(path.dirname(file), realRoot);
+      const loaded = readCheckpointHeadAndLogical(file);
+      return {
+        checkpoint: loaded.checkpoint,
+        tree: loaded.tree,
+        materialRecordDigests: loaded.materialRecordDigests,
+      };
+    }
+    return { checkpoint: normalizeFlowRunCheckpoint(value) };
   } catch (error) {
     throw new FlowRunFilesystemStoreError(
       'flow-run-checkpoint-invalid',
@@ -959,14 +1068,44 @@ function readJsonFile(file: string, realRoot: string, code: string): unknown {
 
 function writeCheckpointCandidate(
   file: string,
-  checkpoint: AIWorkflowFlowRunCheckpoint,
+  checkpoint: FlowRunCheckpointHead,
   realRoot: string,
+  durability?: CheckpointDurabilityRuntime,
 ): void {
   if (fs.existsSync(file)) {
     throw new FlowRunFilesystemStoreError('flow-run-staging-invalid', 'Checkpoint staging file already exists after recovery.');
   }
   assertExistingDirectory(path.dirname(file), realRoot, 'flow-run-boundary-invalid');
-  writeBytesNoFollow(file, stableJson(checkpoint));
+  writeDurableCandidate(file, checkpointHeadJson(checkpoint), 'head', durability);
+}
+
+function ensureSidecarDirectories(
+  runDir: string,
+  realRoot: string,
+  durability?: CheckpointDurabilityRuntime,
+): void {
+  const sidecar = path.join(runDir, 'step-space');
+  ensureChildDirectory(runDir, sidecar, realRoot, durability, 'record');
+  ensureChildDirectory(sidecar, path.join(sidecar, 'controls'), realRoot, durability, 'record');
+  ensureChildDirectory(sidecar, path.join(sidecar, 'records'), realRoot, durability, 'record');
+  ensureChildDirectory(sidecar, path.join(sidecar, 'trees'), realRoot, durability, 'tree');
+  ensureChildDirectory(sidecar, path.join(sidecar, 'receipts'), realRoot, durability, 'receipt');
+}
+
+function assertSidecarDirectories(runDir: string, realRoot: string): void {
+  const sidecar = path.join(runDir, 'step-space');
+  assertExistingDirectory(sidecar, realRoot, 'flow-run-sidecar-boundary-invalid');
+  assertExistingDirectory(path.join(sidecar, 'controls'), realRoot, 'flow-run-sidecar-boundary-invalid');
+  assertExistingDirectory(path.join(sidecar, 'records'), realRoot, 'flow-run-sidecar-boundary-invalid');
+  assertExistingDirectory(path.join(sidecar, 'trees'), realRoot, 'flow-run-sidecar-boundary-invalid');
+  assertExistingDirectory(path.join(sidecar, 'receipts'), realRoot, 'flow-run-sidecar-boundary-invalid');
+}
+
+function removeUnacceptedSidecarReceipt(runDir: string, version: number, realRoot: string): void {
+  const file = path.join(runDir, 'step-space', 'receipts', `${version}.json`);
+  if (!fs.existsSync(file)) return;
+  assertRegularFile(file, realRoot, 'flow-run-sidecar-receipt-invalid');
+  fs.unlinkSync(file);
 }
 
 function writeBytesNoFollow(file: string, bytes: string): void {

package/src/checkpoint-profile.ts

@@ -0,0 +1,175 @@
+import type {
+  AIWorkflowFlowRunCheckpoint,
+  FlowClosedObject,
+  FlowClosedValue,
+  FlowDefinitionArtifactIdentity,
+  FlowRunProfileState,
+  FlowRunStepExtensions,
+} from 'ai-workflow-contract';
+import type { DefinitionStepExtensionCodecRegistryPort } from 'flow-step-space-contract';
+import { normalizeFlowClosedValue } from './run-checkpoint.js';
+import { FlowRunCheckpointTransitionError } from './errors.js';
+
+export interface FrozenRunStepExtensionDefinition {
+  readonly schemaRef?: string;
+  readonly initialValue: FlowClosedValue;
+}
+
+export interface FrozenFlowRunProfileAuthority {
+  readonly profileKind: FlowRunProfileState['kind'];
+  readonly definitionStepIds: readonly string[];
+  readonly binding?: FlowClosedObject;
+  readonly extensionsByStepId: Readonly<
+    Record<string, Readonly<Record<string, FrozenRunStepExtensionDefinition>>>
+  >;
+}
+
+export interface FlowRunProfileAuthorityRequest {
+  readonly instanceId: string;
+  readonly definition: FlowDefinitionArtifactIdentity;
+  readonly profileKind: FlowRunProfileState['kind'];
+}
+
+/** Runtime-only adapter over a materialized frozen instance definition. */
+export interface FlowRunProfileAuthorityPort {
+  load(request: FlowRunProfileAuthorityRequest): FrozenFlowRunProfileAuthority;
+}
+
+export interface FlowRunCheckpointAdmissionRuntime {
+  readonly profileAuthority?: FlowRunProfileAuthorityPort;
+  readonly extensionCodecs: DefinitionStepExtensionCodecRegistryPort;
+}
+
+const compareCodeUnits = (left: string, right: string): number => left < right ? -1 : left > right ? 1 : 0;
+const stable = (value: unknown): string => {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stable).join(',')}]`;
+  const record = value as Readonly<Record<string, unknown>>;
+  return `{${Object.keys(record).sort(compareCodeUnits).map((key) => `${JSON.stringify(key)}:${stable(record[key])}`).join(',')}}`;
+};
+
+export function createInitialRunStepExtensions(
+  authority: FrozenFlowRunProfileAuthority,
+): FlowRunStepExtensions | undefined {
+  const byStepId: Record<string, Record<string, {
+    readonly schemaRef?: string;
+    readonly revision: number;
+    readonly value: FlowClosedValue;
+  }>> = {};
+  for (const stepId of Object.keys(authority.extensionsByStepId).sort(compareCodeUnits)) {
+    const kinds = authority.extensionsByStepId[stepId];
+    const facts: Record<string, { readonly schemaRef?: string; readonly revision: number; readonly value: FlowClosedValue }> = {};
+    for (const kind of Object.keys(kinds).sort(compareCodeUnits)) {
+      const extension = kinds[kind];
+      facts[kind] = Object.freeze({
+        ...(extension.schemaRef === undefined ? {} : { schemaRef: extension.schemaRef }),
+        revision: 0,
+        value: normalizeFlowClosedValue(extension.initialValue, `profile.extensions.${stepId}.${kind}`),
+      });
+    }
+    if (Object.keys(facts).length > 0) byStepId[stepId] = Object.freeze(facts);
+  }
+  return Object.keys(byStepId).length === 0
+    ? undefined
+    : Object.freeze({
+        schemaVersion: 'depa.flow-run-step-extensions/v1' as const,
+        byStepId: Object.freeze(byStepId),
+      });
+}
+
+export function validateCheckpointAgainstFrozenProfile(
+  checkpoint: AIWorkflowFlowRunCheckpoint,
+  runtime: FlowRunCheckpointAdmissionRuntime,
+  options: { readonly requireAIDataAuthority?: boolean } = {},
+): FrozenFlowRunProfileAuthority | undefined {
+  const authority = runtime.profileAuthority?.load({
+    instanceId: checkpoint.instanceId,
+    definition: checkpoint.definition,
+    profileKind: checkpoint.profile.kind,
+  });
+  if (!authority) {
+    if (checkpoint.stepExtensions !== undefined) {
+      throw new FlowRunCheckpointTransitionError('Run step extension facts require frozen profile authority.');
+    }
+    if (options.requireAIDataAuthority && checkpoint.profile.kind === 'AIDataWorkflow') {
+      throw new FlowRunCheckpointTransitionError('AI Data checkpoint admission requires frozen profile authority.');
+    }
+    return undefined;
+  }
+  if (authority.profileKind !== checkpoint.profile.kind) {
+    throw new FlowRunCheckpointTransitionError('Frozen profile kind differs from the checkpoint profile.');
+  }
+  const ids = [...authority.definitionStepIds];
+  if (ids.some((id) => typeof id !== 'string' || !id || id !== id.trim()) || new Set(ids).size !== ids.length) {
+    throw new FlowRunCheckpointTransitionError('Frozen profile step membership is invalid.');
+  }
+  for (const stepId of Object.keys(authority.extensionsByStepId)) {
+    if (!ids.includes(stepId)) {
+      throw new FlowRunCheckpointTransitionError(`Frozen extension step ${stepId} is not a definition member.`);
+    }
+  }
+  if (checkpoint.profile.kind === 'AIDataWorkflow') {
+    if (!authority.binding) throw new FlowRunCheckpointTransitionError('Frozen AI Data authority is missing its binding.');
+    if (stable(checkpoint.profile.runGraph.binding) !== stable(authority.binding)) {
+      throw new FlowRunCheckpointTransitionError('AI Data binding differs from the materialized frozen definition.');
+    }
+    const binding = authority.binding as Record<string, FlowClosedValue>;
+    const definition = binding.definition as Record<string, FlowClosedValue> | undefined;
+    if (!definition || stable(definition.declarationOrder) !== stable(ids)) {
+      throw new FlowRunCheckpointTransitionError('Frozen AI Data binding and StepSpace membership differ.');
+    }
+  }
+  const initial = createInitialRunStepExtensions(authority);
+  if (initial === undefined) {
+    if (checkpoint.stepExtensions !== undefined) {
+      throw new FlowRunCheckpointTransitionError('Checkpoint contains extensions absent from the frozen definition.');
+    }
+    return authority;
+  }
+  const actual = checkpoint.stepExtensions;
+  if (!actual) throw new FlowRunCheckpointTransitionError('Checkpoint omits extensions required by the frozen definition.');
+  if (stable(Object.keys(actual.byStepId).sort(compareCodeUnits)) !== stable(Object.keys(initial.byStepId).sort(compareCodeUnits))) {
+    throw new FlowRunCheckpointTransitionError('Checkpoint extension step membership differs from the frozen definition.');
+  }
+  for (const stepId of Object.keys(initial.byStepId).sort(compareCodeUnits)) {
+    const expectedKinds = Object.keys(initial.byStepId[stepId]).sort(compareCodeUnits);
+    const actualKinds = Object.keys(actual.byStepId[stepId] ?? {}).sort(compareCodeUnits);
+    if (stable(actualKinds) !== stable(expectedKinds)) {
+      throw new FlowRunCheckpointTransitionError(`Checkpoint extension kinds differ for ${stepId}.`);
+    }
+    for (const kind of expectedKinds) {
+      const definition = authority.extensionsByStepId[stepId][kind];
+      const fact = actual.byStepId[stepId][kind];
+      if (definition.schemaRef !== fact.schemaRef) {
+        throw new FlowRunCheckpointTransitionError(`Checkpoint extension schema differs for ${stepId}/${kind}.`);
+      }
+      const registration = runtime.extensionCodecs.resolve(kind);
+      if (!registration?.codec || typeof registration.codec.normalize !== 'function') {
+        throw new FlowRunCheckpointTransitionError(`Checkpoint extension ${stepId}/${kind} has no runtime codec.`);
+      }
+      if (registration.schemaRef !== definition.schemaRef) {
+        throw new FlowRunCheckpointTransitionError(`Runtime codec schema differs for ${stepId}/${kind}.`);
+      }
+      let normalized: FlowClosedValue;
+      try {
+        normalized = normalizeFlowClosedValue(registration.codec.normalize(fact.value as never, {
+          kind,
+          ...(definition.schemaRef === undefined ? {} : { schemaRef: definition.schemaRef }),
+          sourceRef: `frozen-step://${stepId}/${kind}`,
+          stepId,
+        }), `checkpoint.stepExtensions.${stepId}.${kind}`);
+      } catch (error) {
+        throw new FlowRunCheckpointTransitionError(
+          `Checkpoint extension codec rejected ${stepId}/${kind}: ${(error as Error).message}`,
+        );
+      }
+      if (stable(normalized) !== stable(fact.value)) {
+        throw new FlowRunCheckpointTransitionError(`Checkpoint extension ${stepId}/${kind} is not normalized.`);
+      }
+      if (checkpoint.version === 0 && (fact.revision !== 0 || stable(fact.value) !== stable(definition.initialValue))) {
+        throw new FlowRunCheckpointTransitionError(`Initial checkpoint extension ${stepId}/${kind} differs from the frozen definition.`);
+      }
+    }
+  }
+  return authority;
+}