chainlesschain 0.166.90 → 0.166.92

package/src/lib/evolution/evolution-ledger-ports.js

@@ -22,6 +22,7 @@ import {
   EVOLUTION_LEDGER_QUERY_SCHEMA,
   EvolutionLedger,
 } from "./evolution-ledger.js";
+import { isEvolutionLedgerV2Journal } from "./evolution-ledger-v2-journal.js";
 import {
   SKILL_MUTATION_NONCE_ACK_SCHEMA,
   SKILL_MUTATION_OPERATIONS,
@@ -697,6 +698,37 @@ function requireStableInstance(value, prototype, label) {
   throw new TypeError(`${label} instance is required`);
 }
 
+// A migrated journal must execute its own recovery and retained-payload checks.
+// Never unwrap it to the source Ledger or accept matching ordinary callbacks.
+function captureLedgerJournal(ledger) {
+  rejectProxy(ledger, "EvolutionLedger journal");
+  const v2 = isEvolutionLedgerV2Journal(ledger);
+  if (!v2)
+    requireStableInstance(ledger, EvolutionLedger.prototype, "EvolutionLedger");
+  const methods = {};
+  for (const name of [
+    "appendDomainEvent",
+    "query",
+    "read",
+    "verify",
+    "verifyReceipt",
+  ]) {
+    const owner = v2 ? ledger : EvolutionLedger.prototype;
+    const field = Object.getOwnPropertyDescriptor(owner, name);
+    const method = field?.value;
+    if (typeof method !== "function" || utilTypes.isProxy(method))
+      throw portsError(
+        EVOLUTION_LEDGER_PORTS_INVALID_CODE,
+        "genuine Ledger journal method is missing",
+      );
+    // Do not invoke caller-editable function properties such as method.bind.
+    methods[name] = Object.freeze((...args) =>
+      Reflect.apply(method, ledger, args),
+    );
+  }
+  return Object.freeze({ ledger, methods: Object.freeze(methods) });
+}
+
 function captureDurabilityAuthority(value) {
   assertAllExactRecord(
     value,
@@ -1174,7 +1206,7 @@ class EvolutionLedgerDomainPorts {
     artifactPorts,
     artifactTenantId,
     audience,
-    ledger,
+    ledgerMethods,
     purpose,
   }) {
     this.#artifactTenantId = identifier(artifactTenantId, "artifactTenantId");
@@ -1184,35 +1216,34 @@ class EvolutionLedgerDomainPorts {
     this.#durabilityAuthority = artifactDurabilityAuthority;
     this.#durabilityAuthorityId = artifactDurabilityAuthority.id;
     this.#durabilityRetain = artifactDurabilityAuthority.retain;
-    this.#appendDomainEvent = Object.freeze(
-      EvolutionLedger.prototype.appendDomainEvent.bind(ledger),
-    );
-    this.#ledgerQuery = Object.freeze(
-      EvolutionLedger.prototype.query.bind(ledger),
-    );
-    this.#ledgerRead = Object.freeze(
-      EvolutionLedger.prototype.read.bind(ledger),
+    this.#appendDomainEvent = ledgerMethods.appendDomainEvent;
+    this.#ledgerQuery = ledgerMethods.query;
+    this.#ledgerRead = ledgerMethods.read;
+    this.#ledgerVerify = ledgerMethods.verify;
+    this.#ledgerVerifyReceipt = ledgerMethods.verifyReceipt;
+    const putCanonical = EvolutionArtifactPorts.prototype.putCanonical;
+    this.#artifactPut = Object.freeze((...args) =>
+      Reflect.apply(putCanonical, artifactPorts, args),
     );
-    this.#ledgerVerify = Object.freeze(
-      EvolutionLedger.prototype.verify.bind(ledger),
-    );
-    this.#ledgerVerifyReceipt = Object.freeze(
-      EvolutionLedger.prototype.verifyReceipt.bind(ledger),
-    );
-    this.#artifactPut = Object.freeze(
-      EvolutionArtifactPorts.prototype.putCanonical.bind(artifactPorts),
+    this.#artifactResolve = Reflect.apply(
+      EvolutionArtifactPorts.prototype.createEvolutionLedgerArtifactResolver,
+      artifactPorts,
+      [Object.freeze({ purpose: this.#purpose })],
     );
-    this.#artifactResolve =
-      EvolutionArtifactPorts.prototype.createEvolutionLedgerArtifactResolver.call(
-        artifactPorts,
-        Object.freeze({ purpose: this.#purpose }),
-      );
     this.#artifactResolveBatch = captureEvolutionLedgerBatchResolver(
       this.#artifactResolve,
     );
     Object.freeze(this);
   }
 
+  readArtifactScope() {
+    return deepFreeze({
+      artifactTenantId: this.#artifactTenantId,
+      audience: this.#audience,
+      purpose: this.#purpose,
+    });
+  }
+
   #assertAudience(value, label, { nullable = false } = {}) {
     if (value === null && nullable) return null;
     const normalized = identifier(value, label);
@@ -4078,16 +4109,15 @@ export function createEvolutionLedgerPorts(options = {}) {
     FACTORY_REQUIRED_KEYS,
     "evolution ledger ports options",
   );
-  const ledger = requireStableInstance(
+  const capturedLedger = captureLedgerJournal(
     ownData(
       options,
       "ledger",
       "evolution ledger ports options",
       EVOLUTION_LEDGER_PORTS_INVALID_CODE,
     ),
-    EvolutionLedger.prototype,
-    "EvolutionLedger",
   );
+  const { ledger, methods: ledgerMethods } = capturedLedger;
   const artifactPorts = requireStableInstance(
     ownData(
       options,
@@ -4123,7 +4153,7 @@ export function createEvolutionLedgerPorts(options = {}) {
           EVOLUTION_LEDGER_PORTS_INVALID_CODE,
         )
       : undefined,
-    ledger,
+    ledgerMethods,
     purpose: Object.hasOwn(options, "purpose")
       ? ownData(
           options,
@@ -4149,10 +4179,11 @@ export function createEvolutionLedgerPorts(options = {}) {
     prepare,
     query,
   });
-  const readCurrentHead = ledger.verify.bind(ledger);
+  const readCurrentHead = ledgerMethods.verify;
   RELEASE_OPERATION_READERS.set(
     transactionLedger,
     Object.freeze({
+      scope: adapter.readArtifactScope(),
       currentContext: Object.freeze(() => {
         const head = readCurrentHead();
         return deepFreeze({
@@ -4172,6 +4203,7 @@ export function createEvolutionLedgerPorts(options = {}) {
         captureWikiRevisionReader(wikiAdapter).matchesLedger(ledger),
       ),
       matchesLedger: Object.freeze((value) => value === ledger),
+      matchesArtifactPorts: Object.freeze((value) => value === artifactPorts),
       resolveOperation: Object.freeze((input) =>
         adapter.resolveReleaseOperation(input),
       ),

package/src/lib/evolution/evolution-ledger-v2-journal.js

@@ -4,6 +4,7 @@ import { types as utilTypes } from "node:util";
 import { withFileLock } from "../with-file-lock.js";
 import { EvolutionArtifactPorts } from "./evolution-artifact-ports.js";
 import {
+  EvolutionLedger,
   captureEvolutionLedgerMigrationSource,
   EVOLUTION_LEDGER_MAX_EVENTS,
   EVOLUTION_LEDGER_V2_MIGRATION_INTENT,
@@ -105,6 +106,38 @@ export function createEvolutionLedgerV2Journal(options) {
   });
   const source = captureEvolutionLedgerMigrationSource(config.sourceLedger);
   const ledger = source.ledger;
+  // Genuine subclasses also own migration capabilities. Capture original
+  // private-field operations and physical paths rather than virtual overrides.
+  const original = Object.fromEntries(
+    [
+      "read",
+      "query",
+      "queryMany",
+      "verifyReceipt",
+      "verify",
+      "checkpointState",
+      "exportAuditBundle",
+    ].map((name) => {
+      const method = Object.getOwnPropertyDescriptor(
+        EvolutionLedger.prototype,
+        name,
+      ).value;
+      return [name, (...args) => Reflect.apply(method, ledger, args)];
+    }),
+  );
+  const rootDir = Reflect.apply(
+    Object.getOwnPropertyDescriptor(EvolutionLedger.prototype, "rootDir").get,
+    ledger,
+    [],
+  );
+  const authorityRootDir = Reflect.apply(
+    Object.getOwnPropertyDescriptor(
+      EvolutionLedger.prototype,
+      "authorityRootDir",
+    ).get,
+    ledger,
+    [],
+  );
   const backend = captureEvolutionLedgerV2ManifestBackend(config.backend);
   const retention = config.minimumRetainedUntil;
   if (
@@ -120,7 +153,8 @@ export function createEvolutionLedgerV2Journal(options) {
   )
     fail("constructed EvolutionArtifactPorts are required");
   // Calling the original private-field method also rejects prototype forgeries.
-  const put = EvolutionArtifactPorts.prototype.putCanonical.bind(artifactPorts);
+  const putCanonical = EvolutionArtifactPorts.prototype.putCanonical;
+  const put = (...args) => Reflect.apply(putCanonical, artifactPorts, args);
   const lock = config.lock ?? withFileLock;
   if (typeof lock !== "function" || utilTypes.isProxy(lock))
     fail("synchronous journal lock is required");
@@ -134,7 +168,7 @@ export function createEvolutionLedgerV2Journal(options) {
   const locked = (operation) => {
     let calls = 0;
     const result = lock(
-      path.join(ledger.authorityRootDir, "manifest-cutover-v2"),
+      path.join(authorityRootDir, "manifest-cutover-v2"),
       (context) => {
         if (++calls !== 1)
           fail("journal lock callback must execute exactly once");
@@ -149,7 +183,7 @@ export function createEvolutionLedgerV2Journal(options) {
     return result;
   };
   const sourceEvents = () =>
-    ledger.read({ limit: EVOLUTION_LEDGER_MAX_EVENTS });
+    original.read({ limit: EVOLUTION_LEDGER_MAX_EVENTS });
 
   function binding(authority) {
     if (
@@ -252,7 +286,7 @@ export function createEvolutionLedgerV2Journal(options) {
     return receipt;
   }
   function recover() {
-    const authority = ledger.verify();
+    const authority = original.verify();
     const expectedBinding = binding(authority);
     let events = sourceEvents();
     let intents = events.filter(
@@ -416,8 +450,8 @@ export function createEvolutionLedgerV2Journal(options) {
   }
   const journal = Object.freeze({
     descriptor,
-    rootDir: ledger.rootDir,
-    authorityRootDir: ledger.authorityRootDir,
+    rootDir,
+    authorityRootDir,
     append: (input, options = {}) =>
       append("append", input, options, false, false),
     appendBatch: (inputs, options = {}) =>
@@ -433,14 +467,14 @@ export function createEvolutionLedgerV2Journal(options) {
     read: (options = {}) =>
       readOperation(({ events }) => {
         // Preserve exact v1 read validation and return events recovered from v2.
-        const selected = ledger.read(options);
+        const selected = original.read(options);
         return Object.freeze(
           selected.map((event) => events[event.sequence - 1]),
         );
       }),
     query: (selector, options = {}) =>
       readOperation(({ events }) => {
-        const result = ledger.query(selector, options);
+        const result = original.query(selector, options);
         return result
           ? Object.freeze({
               ...result,
@@ -451,7 +485,7 @@ export function createEvolutionLedgerV2Journal(options) {
     queryMany: (selectors, options = {}) =>
       readOperation(({ events }) =>
         Object.freeze(
-          ledger.queryMany(selectors, options).map((result) =>
+          original.queryMany(selectors, options).map((result) =>
             result
               ? Object.freeze({
                   ...result,
@@ -463,17 +497,20 @@ export function createEvolutionLedgerV2Journal(options) {
       ),
     findByEventId: (eventId) =>
       readOperation(({ events }) => {
-        const event = ledger.findByEventId(eventId);
+        const event =
+          original.query({ eventId }, { issueReceipt: false })?.event ?? null;
         return event ? events[event.sequence - 1] : null;
       }),
     recoverReceipt: (selector) =>
-      readOperation(() => ledger.recoverReceipt(selector)),
+      readOperation(
+        () => original.query(selector, { issueReceipt: true })?.receipt ?? null,
+      ),
     verifyReceipt: (receipt, options = {}) =>
-      readOperation(() => ledger.verifyReceipt(receipt, options)),
-    verify: () => readOperation(() => ledger.verify()),
-    getAuthority: () => readOperation(() => ledger.getAuthority()),
-    checkpointState: () => readOperation(() => ledger.checkpointState()),
-    exportAuditBundle: () => readOperation(() => ledger.exportAuditBundle()),
+      readOperation(() => original.verifyReceipt(receipt, options)),
+    verify: () => readOperation(() => original.verify()),
+    getAuthority: () => readOperation(() => original.verify()),
+    checkpointState: () => readOperation(() => original.checkpointState()),
+    exportAuditBundle: () => readOperation(() => original.exportAuditBundle()),
     recover: () =>
       readOperation(({ checkpoint, intent, completed }) =>
         Object.freeze({ checkpoint, intent, completed }),
@@ -506,8 +543,8 @@ export function createEvolutionLedgerV2JournalFromFactory(
     utilTypes.isProxy(config.createBackend)
   )
     fail("explicit manifest backend construction authority is required");
-  const authority =
-    captureEvolutionLedgerMigrationSource(sourceLedger).ledger.getAuthority();
+  const ledger = captureEvolutionLedgerMigrationSource(sourceLedger).ledger;
+  const authority = Reflect.apply(EvolutionLedger.prototype.verify, ledger, []);
   const scope = Object.freeze({
     ...record(config.descriptor, ["tenantId", "artifactTenantId", "audience"]),
   });

package/src/lib/evolution/evolution-workbench-file-resources.js

@@ -13,12 +13,21 @@ const ID = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,255}$/u;
 const DIGEST = /^sha256:[a-f0-9]{64}$/u;
 const STORAGE_ID = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/u;
 const FILE_RESOURCES = new WeakSet();
+const FILE_BACKEND_BINDINGS = new WeakMap();
 
 export function captureWorkbenchFileResources(value) {
   if (!FILE_RESOURCES.has(value))
     throw new TypeError("genuine Workbench file resources are required");
   return value;
 }
+
+/** Root composition retains the exact backends; public resource bytes stay compatible. */
+export function captureWorkbenchFileBackendBinding(value) {
+  const binding = FILE_BACKEND_BINDINGS.get(value);
+  if (!binding)
+    throw new TypeError("genuine Workbench file backend bindings are required");
+  return binding;
+}
 const DESCRIPTOR_KEYS = [
   "tenantId",
   "artifactTenantId",
@@ -327,7 +336,7 @@ export function openEvolutionWorkbenchFileResources(input) {
       artifactPorts.createEvolutionLedgerArtifactResolver({
         purpose: descriptor.purpose,
       });
-    const { ledger } = createEvolutionLedgerFileBackend({
+    const backend = createEvolutionLedgerFileBackend({
       rootDir: storage.ledgerRootDir,
       authorityRootDir: storage.ledgerAuthorityRootDir,
       witnessFilePath: storage.witnessFilePath,
@@ -339,6 +348,7 @@ export function openEvolutionWorkbenchFileResources(input) {
       fsImpl: io,
       clock: now,
     });
+    const { ledger } = backend;
     const ports = createEvolutionLedgerPorts({
       artifactPorts,
       ledger,
@@ -356,6 +366,7 @@ export function openEvolutionWorkbenchFileResources(input) {
       fsImpl: io,
     });
     return {
+      backend,
       artifactPorts,
       ledger,
       ledgerArtifactResolver,
@@ -399,5 +410,12 @@ export function openEvolutionWorkbenchFileResources(input) {
     }),
   });
   FILE_RESOURCES.add(result);
+  FILE_BACKEND_BINDINGS.set(
+    result,
+    Object.freeze({
+      backend: primary.backend,
+      verifierBackend: verifier.backend,
+    }),
+  );
   return result;
 }

package/src/lib/evolution/rrsi-cohort-registration.js

@@ -0,0 +1,275 @@
+/** Derive enrollment declarations only from a genuine History resolver at composition. */
+import {
+  snapshotRrsiData,
+  rrsiExact,
+  rrsiHash,
+  rrsiEnvelope,
+  rrsiFail,
+  rrsiInteger,
+  rrsiCanonical,
+  freezeRrsiData,
+} from "./rrsi-data.js";
+import { normalizeRrsiNativeEvaluationBatch } from "./rrsi-native-evaluation-batch.js";
+
+export const RRSI_COHORT_REGISTRATION_SCHEMA =
+  "chainlesschain.rrsi-cohort-registration/v1";
+export const RRSI_COHORT_PLAN_SCHEMA = "chainlesschain.rrsi-cohort-plan/v1";
+export const RRSI_COHORT_PLAN_V2_SCHEMA = "chainlesschain.rrsi-cohort-plan/v2";
+export const RRSI_COHORT_MANIFEST_SCHEMA =
+  "chainlesschain.rrsi-cohort-manifest/v1";
+export const RRSI_COHORT_MANIFEST_V2_SCHEMA =
+  "chainlesschain.rrsi-cohort-manifest/v2";
+export const RRSI_EVAL_CAMPAIGN_PLAN_SCHEMA =
+  "chainlesschain.rrsi-eval-campaign-plan/v1";
+
+/** Structural provenance only. Consumers obtain the registration from genuine History. */
+export function buildRrsiNativeStatisticsRegistrationBindings(
+  registrationInput,
+  reservationRecordInput,
+) {
+  const registration = snapshotRrsiData(registrationInput);
+  const reservationRecord = snapshotRrsiData(reservationRecordInput);
+  if (
+    registration.schema !==
+      "chainlesschain.rrsi-native-statistics-registration-resolution/v1" ||
+    registration.historyAuthenticated !== true ||
+    registration.preObservationRegistrationVerified !== true ||
+    registration.reservationKind !== "reserve-native-batch-v2" ||
+    registration.statisticsPlanDigest !==
+      registration.statisticsPlan?.statisticsPlanDigest ||
+    rrsiCanonical(registration.reservationRecord) !==
+      rrsiCanonical(reservationRecord) ||
+    !(
+      registration.binding.rootRegistrationRecord.sequence <
+        registration.scopeRegistrationRecord.sequence &&
+      registration.scopeRegistrationRecord.sequence <
+        registration.planRegistrationRecord.sequence &&
+      registration.planRegistrationRecord.sequence < reservationRecord.sequence
+    )
+  )
+    rrsiFail("native statistics registration provenance or sequence differs");
+  return freezeRrsiData({
+    schema: "chainlesschain.rrsi-native-statistics-registration-bindings/v1",
+    binding: registration.binding,
+    protocolDigest: registration.protocolDigest,
+    statisticsPlanDigest: registration.statisticsPlanDigest,
+    scopeRegistrationRecord: registration.scopeRegistrationRecord,
+    planRegistrationRecord: registration.planRegistrationRecord,
+    reservationRecord,
+    reservationKind: registration.reservationKind,
+  });
+}
+
+export function buildRrsiEvalCampaignPlan(rootInput) {
+  const root = snapshotRrsiData(rootInput);
+  return rrsiEnvelope(RRSI_EVAL_CAMPAIGN_PLAN_SCHEMA, "campaignRootDigest", {
+    historyScopeId: root.descriptor.scopeId,
+    historyDescriptorDigest: rrsiHash(
+      "chainlesschain.rrsi-history-descriptor/v1",
+      root.descriptor,
+    ),
+    ledgerIdentity: root.identity,
+    rootCampaignDigest: root.campaign.campaignDigest,
+    rootRegistrationRecord: root.registrationRecord,
+    policyDigest: root.campaign.policy.policyDigest,
+    executionDigest: rrsiHash(
+      "chainlesschain.rrsi-execution-bindings/v1",
+      root.campaign.execution,
+    ),
+    budgetDigest: rrsiHash(
+      "chainlesschain.rrsi-root-budget/v1",
+      root.campaign.budget,
+    ),
+    experimentDigest: rrsiHash(
+      "chainlesschain.rrsi-root-experiment/v1",
+      root.campaign.experiment,
+    ),
+    maxSelectionQueries: root.campaign.policy.limits.maxSelectionQueries,
+    querySlotPolicy: "global-history-ordinal-and-stage/v1",
+    productionBudgetAuthorityVerified: false,
+  });
+}
+
+export function rrsiEvalQueryStreamId(root, resolution) {
+  rrsiInteger(
+    resolution.queryOrdinal,
+    "global History query ordinal",
+    1,
+    root.maxSelectionQueries,
+  );
+  return `rrsi-query.${rrsiHash("chainlesschain.rrsi-eval-query-stream/v1", { campaignRootDigest: root.campaignRootDigest, queryOrdinal: resolution.queryOrdinal, stage: resolution.batch.stage }).slice(7)}`;
+}
+
+/** Immutable plan/manifest bytes exclude changing budget statuses and current head digests. */
+export function buildRrsiCohortRegistration(
+  rootInput,
+  resolutionInput,
+  cohortId,
+) {
+  return prepareRrsiCohortRegistration(rootInput, resolutionInput).build(
+    cohortId,
+  );
+}
+
+/** Structural preparation only; trusted audit callers supply genuine History data. */
+export function prepareRrsiCohortRegistration(rootInput, resolutionInput) {
+  const root = snapshotRrsiData(rootInput),
+    resolution = snapshotRrsiData(resolutionInput);
+  const batch = normalizeRrsiNativeEvaluationBatch(
+    resolution.batch,
+    resolution.campaign,
+  );
+  if (rrsiCanonical(root.ledgerIdentity) !== rrsiCanonical(resolution.identity))
+    rrsiFail("RRSI cohort belongs to another History journal");
+  const childrenByCohort = new Map();
+  for (const child of batch.children) {
+    if (!childrenByCohort.has(child.cohortId))
+      childrenByCohort.set(child.cohortId, []);
+    childrenByCohort.get(child.cohortId).push(child);
+  }
+  const groups = new Map();
+  for (const group of resolution.children)
+    if (!groups.has(group.bindings.childId))
+      groups.set(group.bindings.childId, group);
+  const statisticsRegistration = resolution.statisticsRegistration
+    ? buildRrsiNativeStatisticsRegistrationBindings(
+        resolution.statisticsRegistration,
+        resolution.reservationRecord,
+      )
+    : null;
+  return Object.freeze({
+    build(cohortId) {
+      return deriveRrsiCohortRegistration(
+        root,
+        resolution,
+        batch,
+        childrenByCohort.get(cohortId) ?? [],
+        groups,
+        cohortId,
+        statisticsRegistration,
+      );
+    },
+  });
+}
+
+function deriveRrsiCohortRegistration(
+  root,
+  resolution,
+  batch,
+  sourceChildren,
+  groups,
+  cohortId,
+  statisticsRegistration,
+) {
+  const children = [...sourceChildren].sort((a, b) =>
+    a.slotId < b.slotId ? -1 : a.slotId > b.slotId ? 1 : 0,
+  );
+  if (!children.length)
+    rrsiFail("RRSI cohort is outside the committed native batch");
+  const first = children[0];
+  const queryStreamId = rrsiEvalQueryStreamId(root, resolution);
+  const plan = rrsiEnvelope(
+    statisticsRegistration
+      ? RRSI_COHORT_PLAN_V2_SCHEMA
+      : RRSI_COHORT_PLAN_SCHEMA,
+    "planDigest",
+    {
+      campaignRootDigest: root.campaignRootDigest,
+      campaignDigest: batch.campaignDigest,
+      batchDigest: batch.batchDigest,
+      nativeEvaluationPlanDigest: batch.nativeEvaluationPlanDigest,
+      evaluationMappingDigest: batch.evaluationMappingDigest,
+      nativePlanDigest: first.nativePlanDigest,
+      candidateDigest: batch.candidate.candidateDigest,
+      rrsiAggregateContentDigest: batch.candidate.contentDigest,
+      nativeCandidateContents: batch.nativeCandidateContents,
+      versions: batch.versions,
+      lifecycleDigests: batch.lifecycleDigests,
+      queryOrdinal: resolution.queryOrdinal,
+      queryStreamId,
+      stage: batch.stage,
+      role: first.role,
+      variant: first.variant,
+      pairId: first.pairId,
+      variantMappingDigest: first.variantMappingDigest,
+      recipeDigest: first.recipeDigest,
+      costAttribution: batch.costAttribution,
+      executionCountSemantics: batch.executionCountSemantics,
+      productionAdmissionVerified: false,
+      ...(statisticsRegistration ? { statisticsRegistration } : {}),
+    },
+  );
+  const denominator = Object.fromEntries(
+    Object.keys(first.byArm).map((arm) => [
+      arm,
+      Object.fromEntries(
+        Object.keys(first.plannedObservationsPerArmByPartition).map(
+          (partition) => [
+            partition,
+            children.reduce(
+              (sum, child) =>
+                sum + child.plannedObservationsPerArmByPartition[partition],
+              0,
+            ),
+          ],
+        ),
+      ),
+    ]),
+  );
+  const childBindings = children.map((child) => {
+    const group = groups.get(child.childId);
+    if (!group) rrsiFail("RRSI cohort has no reserved paired child");
+    return {
+      slotId: child.slotId,
+      childId: child.childId,
+      bindings: group.bindings,
+      expectedContext: child.expectedContext,
+      evaluationContextDigest: child.evaluationContextDigest,
+      reservationDigestsByArm: group.bindings.armReservationDigests,
+    };
+  });
+  const manifest = rrsiEnvelope(
+    statisticsRegistration
+      ? RRSI_COHORT_MANIFEST_V2_SCHEMA
+      : RRSI_COHORT_MANIFEST_SCHEMA,
+    "manifestDigest",
+    {
+      cohortId,
+      planDigest: plan.planDigest,
+      batchDigest: batch.batchDigest,
+      campaignRootDigest: root.campaignRootDigest,
+      queryOrdinal: resolution.queryOrdinal,
+      queryStreamId,
+      reservationRecord: resolution.reservationRecord,
+      slotIds: children.map((child) => child.slotId),
+      childBindings,
+      allCohortIds: [
+        ...new Set(batch.children.map((child) => child.cohortId)),
+      ].sort(),
+      plannedObservationsPerArmByPartition: denominator,
+      denominatorSemantics: "complete-validation-and-test-paired-attempts/v1",
+      nativeExecutionDenominatorVerified: false,
+      ...(statisticsRegistration ? { statisticsRegistration } : {}),
+    },
+  );
+  const slots = children.map((child) => ({
+    slotId: child.slotId,
+    evaluationPlanDigest: child.nativePlanDigest,
+    requestDigest: child.requestDigest,
+    policyDigest: child.expectedContext.policyDigest,
+    evaluationAuthorityRoot: child.expectedContext.evaluationAuthorityRoot,
+  }));
+  return { plan, manifest, slots };
+}
+
+export function normalizeRrsiCohortLookup(input) {
+  const lookup = snapshotRrsiData(input);
+  rrsiExact(
+    lookup,
+    ["schema", "batchDigest", "cohortId"],
+    "RRSI cohort registration reference",
+  );
+  if (lookup.schema !== RRSI_COHORT_REGISTRATION_SCHEMA)
+    rrsiFail("RRSI registration schema differs");
+  return lookup;
+}