chainlesschain 0.166.21 → 0.166.24

package/src/lib/evolution/evolution-workbench-runtime.js

@@ -0,0 +1,133 @@
+import { types } from "node:util";
+import { capturePruningData as capture } from "./governed-wiki-pruning-journal.js";
+import { createEvolutionWorkbenchRegistrySource } from "./evolution-workbench-registry-source.js";
+import { createEvolutionWorkbenchReviewRuntime } from "./evolution-workbench-review-ledger-adapter.js";
+import { createEvolutionWorkbenchRollbackRuntime } from "./evolution-workbench-rollback-ledger-adapter.js";
+import { createEvolutionWorkbenchCliHost } from "./evolution-workbench-cli-host.js";
+
+const REQUIRED = [
+  "descriptor",
+  "artifactPorts",
+  "ledger",
+  "ledgerArtifactResolver",
+  "releaseRegistry",
+  "transactionLedger",
+  "verifierLedger",
+  "verifierLedgerArtifactResolver",
+  "verifierReleaseRegistry",
+  "verifierTransactionLedger",
+  "rollbackProvider",
+  "authorizationProvider",
+  "identityProvider",
+  "decisionVerifier",
+  "humanDecisionProvider",
+  "humanDecisionVerifier",
+  "humanRollbackProvider",
+  "humanRollbackVerifier",
+];
+const OPTIONAL = ["invocationReceiptSource", "pilotSource", "now"];
+
+function optionsRecord(value) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    types.isProxy(value)
+  )
+    throw new TypeError("Workbench runtime requires explicit resource options");
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const allowed = new Set([...REQUIRED, ...OPTIONAL]);
+  if (
+    Reflect.ownKeys(descriptors).some((key) => !allowed.has(key)) ||
+    REQUIRED.some((key) => !Object.hasOwn(descriptors, key))
+  )
+    throw new TypeError("Workbench runtime resources are missing or replaced");
+  const output = {};
+  for (const [key, property] of Object.entries(descriptors)) {
+    if (!Object.hasOwn(property, "value"))
+      throw new TypeError(
+        "Workbench runtime resource accessors are not allowed",
+      );
+    output[key] = property.value;
+  }
+  return output;
+}
+
+function fixed(owner, name) {
+  if (!owner || types.isProxy(owner))
+    throw new TypeError(`Workbench ${name} fixed port is required`);
+  const fn = Object.getOwnPropertyDescriptor(owner, name)?.value;
+  if (typeof fn !== "function" || types.isProxy(fn))
+    throw new TypeError(`Workbench ${name} fixed own method is required`);
+  return Object.freeze({ [name]: fn.bind(owner) });
+}
+
+// Open/recover the actual Registry before calling this assembly. Nothing here
+// creates credentials or grants permissions. No host escapes before current
+// storage, all adapters and existing-effect reconciliation have been verified.
+export async function createEvolutionWorkbenchRuntime(input) {
+  const options = optionsRecord(input);
+  const descriptor = capture(options.descriptor);
+  const shared = {
+    descriptor,
+    artifactPorts: options.artifactPorts,
+    ledger: options.ledger,
+    ledgerArtifactResolver: options.ledgerArtifactResolver,
+    now: options.now ?? Date.now,
+  };
+  const identityProvider = fixed(options.identityProvider, "current");
+  const registrySource = createEvolutionWorkbenchRegistrySource({
+    ...shared,
+    releaseRegistry: options.releaseRegistry,
+    transactionLedger: options.transactionLedger,
+    verifierLedger: options.verifierLedger,
+    verifierLedgerArtifactResolver: options.verifierLedgerArtifactResolver,
+    verifierReleaseRegistry: options.verifierReleaseRegistry,
+    verifierTransactionLedger: options.verifierTransactionLedger,
+  });
+  const review = createEvolutionWorkbenchReviewRuntime({
+    ...shared,
+    registrySource,
+    decisionVerifier: fixed(options.decisionVerifier, "verify"),
+    humanDecisionProvider: fixed(options.humanDecisionProvider, "request"),
+    humanDecisionVerifier: fixed(options.humanDecisionVerifier, "verify"),
+    invocationReceiptSource: options.invocationReceiptSource ?? null,
+    pilotSource: options.pilotSource ?? null,
+  });
+  const rollback = createEvolutionWorkbenchRollbackRuntime({
+    ...shared,
+    projectionReader: review.projectionReader,
+    releaseRegistry: options.releaseRegistry,
+    transactionLedger: options.transactionLedger,
+    verifierReleaseRegistry: options.verifierReleaseRegistry,
+    verifierTransactionLedger: options.verifierTransactionLedger,
+    rollbackProvider: options.rollbackProvider,
+    authorizationProvider: fixed(
+      options.authorizationProvider,
+      "authorizeRollback",
+    ),
+    humanRollbackProvider: fixed(options.humanRollbackProvider, "authorize"),
+    humanRollbackVerifier: fixed(options.humanRollbackVerifier, "verify"),
+  });
+  const reviewRecovery = await review.reconcileCommitted();
+  const rollbackRecovery = await rollback.reconcileCommitted();
+  await review.projectionLoader.load();
+  const workbenchHost = createEvolutionWorkbenchCliHost({
+    tenantId: descriptor.tenantId,
+    projectionLoader: review.projectionLoader,
+    projectionAuthority: review.projectionAuthority,
+    identityProvider,
+    activeStateReader: rollback.activeStateReader,
+    batchExecutor: review.batchExecutor,
+    rollbackExecutor: rollback.rollbackExecutor,
+  });
+  return Object.freeze({
+    workbenchHost,
+    recovery: capture({
+      reviewsSettled: reviewRecovery.settledItems.length,
+      reviewPreparationsDeferred: reviewRecovery.deferredRequestDigests.length,
+      rollbacksSettled: rollbackRecovery.settledReceipts.length,
+      rollbackPlansDeferred: rollbackRecovery.deferredPlanDigests.length,
+    }),
+  });
+}

package/src/lib/evolution/evolution-workbench-version-control.js

@@ -1,4 +1,6 @@
 import { createHash } from "node:crypto";
+import { types } from "node:util";
+import { capturePruningData } from "./governed-wiki-pruning-journal.js";
 
 import { filterEvolutionWorkbenchProjection } from "./evolution-workbench-projection.js";
 
@@ -156,7 +158,8 @@ export function buildEvolutionWorkbenchRollbackPlan(
   });
 }
 
-function verifyPlan(plan, tenantId) {
+export function verifyEvolutionWorkbenchRollbackPlan(input, tenantId) {
+  const plan = capturePruningData(input);
   if (
     plan?.schema !== EVOLUTION_WORKBENCH_ROLLBACK_PLAN_SCHEMA ||
     plan.tenantId !== tenantId ||
@@ -170,9 +173,57 @@ function verifyPlan(plan, tenantId) {
   return freeze(clone(plan));
 }
 
+export function buildEvolutionWorkbenchRollbackRequest(
+  plan,
+  authorizationReceiptDigest,
+) {
+  const core = {
+    planDigest: plan.planDigest,
+    expectedActiveStateDigest: plan.expectedActiveStateDigest,
+    fromContentDigest: plan.fromContentDigest,
+    toContentDigest: plan.toContentDigest,
+    authorizationReceiptDigest: digest(
+      authorizationReceiptDigest,
+      "authorization receipt",
+    ),
+  };
+  return freeze({
+    ...core,
+    requestDigest: hash(
+      "chainlesschain.evolution-workbench-rollback-request/v1",
+      core,
+    ),
+  });
+}
+
+export function buildEvolutionWorkbenchRollbackReceipt(
+  plan,
+  request,
+  transitionReceiptDigest,
+  active,
+) {
+  const core = {
+    schema: EVOLUTION_WORKBENCH_ROLLBACK_RECEIPT_SCHEMA,
+    tenantId: plan.tenantId,
+    skillName: plan.skillName,
+    planDigest: plan.planDigest,
+    requestDigest: request.requestDigest,
+    authorizationReceiptDigest: request.authorizationReceiptDigest,
+    transitionReceiptDigest,
+    activeStateDigest: active.stateDigest,
+    activeContentDigest: active.contentDigest,
+  };
+  return freeze({
+    ...core,
+    receiptDigest: hash(EVOLUTION_WORKBENCH_ROLLBACK_RECEIPT_SCHEMA, core),
+  });
+}
+
 export class EvolutionWorkbenchRollbackExecutor {
   constructor({ tenantId, ports } = {}) {
     this.tenantId = string(tenantId, "tenantId");
+    if (!ports || types.isProxy(ports))
+      throw new TypeError("fixed rollback ports are required");
     for (const name of [
       "loadProjection",
       "authorizeHumanRollback",
@@ -180,14 +231,16 @@ export class EvolutionWorkbenchRollbackExecutor {
       "readActiveState",
       "commitRollback",
     ]) {
-      if (typeof ports?.[name] !== "function")
+      const method = Object.getOwnPropertyDescriptor(ports, name)?.value;
+      if (typeof method !== "function" || types.isProxy(method))
         throw new TypeError(`Workbench rollback port ${name} is required`);
-      this[`_${name}`] = ports[name].bind(ports);
+      this[`_${name}`] = method.bind(ports);
     }
+    Object.freeze(this);
   }
 
   async execute(input) {
-    const plan = verifyPlan(input, this.tenantId);
+    const plan = verifyEvolutionWorkbenchRollbackPlan(input, this.tenantId);
     const projection = await this._loadProjection({
       tenantId: this.tenantId,
       projectionDigest: plan.sourceProjectionDigest,
@@ -210,20 +263,10 @@ export class EvolutionWorkbenchRollbackExecutor {
       !DIGEST.test(authorization.receiptDigest ?? "")
     )
       throw new Error("Workbench rollback lacks exact human authorization");
-    const requestCore = {
-      planDigest: plan.planDigest,
-      expectedActiveStateDigest: plan.expectedActiveStateDigest,
-      fromContentDigest: plan.fromContentDigest,
-      toContentDigest: plan.toContentDigest,
-      authorizationReceiptDigest: authorization.receiptDigest,
-    };
-    const request = freeze({
-      ...requestCore,
-      requestDigest: hash(
-        "chainlesschain.evolution-workbench-rollback-request/v1",
-        requestCore,
-      ),
-    });
+    const request = buildEvolutionWorkbenchRollbackRequest(
+      plan,
+      authorization.receiptDigest,
+    );
     const applied = await this._applyRollback(request);
     if (
       applied?.authenticated !== true ||
@@ -238,28 +281,19 @@ export class EvolutionWorkbenchRollbackExecutor {
     });
     if (
       active?.authenticated !== true ||
+      active.durable !== true ||
+      active.tenantId !== this.tenantId ||
+      active.skillName !== plan.skillName ||
       active.contentDigest !== plan.toContentDigest ||
       !DIGEST.test(active.stateDigest ?? "")
     )
       throw new Error("Workbench rollback active readback differs from target");
-    const receiptCore = {
-      schema: EVOLUTION_WORKBENCH_ROLLBACK_RECEIPT_SCHEMA,
-      tenantId: this.tenantId,
-      skillName: plan.skillName,
-      planDigest: plan.planDigest,
-      requestDigest: request.requestDigest,
-      authorizationReceiptDigest: authorization.receiptDigest,
-      transitionReceiptDigest: applied.receiptDigest,
-      activeStateDigest: active.stateDigest,
-      activeContentDigest: active.contentDigest,
-    };
-    const receipt = freeze({
-      ...receiptCore,
-      receiptDigest: hash(
-        EVOLUTION_WORKBENCH_ROLLBACK_RECEIPT_SCHEMA,
-        receiptCore,
-      ),
-    });
+    const receipt = buildEvolutionWorkbenchRollbackReceipt(
+      plan,
+      request,
+      applied.receiptDigest,
+      active,
+    );
     const committed = await this._commitRollback({ receipt });
     if (
       committed?.authenticated !== true ||