chainlesschain 0.166.16 → 0.166.18

package/src/lib/evolution/evolution-run-ledger-adapter.js

@@ -0,0 +1,409 @@
+import evolutionRun from "@chainlesschain/session-core/evolution-run";
+
+import {
+  EVOLUTION_DURABLE_ARTIFACT_RECORD_SCHEMA,
+  isEvolutionLedgerArtifactResolver,
+} from "./evolution-artifact-ports.js";
+import {
+  EVOLUTION_ARTIFACT_RESOLUTION_SCHEMA,
+  EVOLUTION_LEDGER_DOMAIN_EVENT_SCHEMA,
+} from "./evolution-ledger.js";
+
+const { EVENT_TYPES, projectEvolutionRun } = evolutionRun;
+
+export const EVOLUTION_RUN_LEDGER_EVENT_TYPE = "evolution.run.event.committed";
+export const EVOLUTION_RUN_LEDGER_CONFLICT_CODE =
+  "CC_EVOLUTION_RUN_LEDGER_CONFLICT";
+export const EVOLUTION_RUN_LEDGER_CORRUPT_CODE =
+  "CC_EVOLUTION_RUN_LEDGER_CORRUPT";
+
+const ARTIFACT_TYPE = "evolution-run-event";
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const EVENT_KEYS = new Set([
+  "schema",
+  "tenantId",
+  "runId",
+  "eventId",
+  "sequence",
+  "type",
+  "subjectId",
+  "payloadDigest",
+  "artifactRef",
+  "keyRef",
+  "data",
+]);
+
+function requiredString(value, label) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new TypeError(`${label} is required`);
+  }
+  return value;
+}
+
+function fail(code, message, options) {
+  const error = new Error(message, options);
+  error.code = code;
+  throw error;
+}
+
+function capture(owner, method, label = method) {
+  if (typeof owner?.[method] !== "function") {
+    throw new TypeError(`${label} port is required`);
+  }
+  const fn = owner[method];
+  return (...args) => Reflect.apply(fn, owner, args);
+}
+
+function canonical(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(canonical).join(",")}]`;
+  }
+  return `{${Object.keys(value)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+    .join(",")}}`;
+}
+
+function clone(value) {
+  return JSON.parse(canonical(value));
+}
+
+function same(left, right) {
+  return canonical(left) === canonical(right);
+}
+
+function normalizeDescriptor(input) {
+  return Object.freeze({
+    tenantId: requiredString(input?.tenantId, "tenantId"),
+    artifactTenantId: requiredString(
+      input?.artifactTenantId,
+      "artifactTenantId",
+    ),
+    runId: requiredString(input?.runId, "runId"),
+    audience: requiredString(input?.audience, "audience"),
+    purpose: requiredString(input?.purpose, "purpose"),
+  });
+}
+
+function normalizeEvent(input, descriptor) {
+  if (
+    !input ||
+    typeof input !== "object" ||
+    Array.isArray(input) ||
+    Reflect.ownKeys(input).length !== EVENT_KEYS.size ||
+    Reflect.ownKeys(input).some(
+      (key) => typeof key !== "string" || !EVENT_KEYS.has(key),
+    )
+  ) {
+    throw new TypeError("EvolutionRun event contains unsupported fields");
+  }
+  const event = clone(input);
+  projectEvolutionRun([event], {
+    tenantId: descriptor.tenantId,
+    runId: descriptor.runId,
+  });
+  return Object.freeze(event);
+}
+
+function parseRecord(resolution, descriptor) {
+  if (
+    resolution?.schema !== EVOLUTION_ARTIFACT_RESOLUTION_SCHEMA ||
+    resolution.authenticated !== true ||
+    resolution.found !== true ||
+    !DIGEST.test(resolution.digest ?? "") ||
+    !DIGEST.test(resolution.receiptDigest ?? "") ||
+    !Buffer.isBuffer(resolution.bytes)
+  ) {
+    fail(
+      EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+      "EvolutionRun artifact resolution is unauthenticated or incomplete",
+    );
+  }
+  let record;
+  try {
+    record = JSON.parse(resolution.bytes.toString("utf8"));
+  } catch {
+    fail(
+      EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+      "EvolutionRun artifact is not canonical JSON",
+    );
+  }
+  if (
+    record?.schema !== EVOLUTION_DURABLE_ARTIFACT_RECORD_SCHEMA ||
+    record.tenantId !== descriptor.artifactTenantId ||
+    record.audience !== descriptor.audience ||
+    record.purpose !== descriptor.purpose ||
+    record.retention !== "ledger" ||
+    record.type !== ARTIFACT_TYPE
+  ) {
+    fail(
+      EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+      "EvolutionRun artifact durable binding is invalid",
+    );
+  }
+  return normalizeEvent(record.value, descriptor);
+}
+
+export class EvolutionRunLedgerAdapter {
+  constructor({
+    descriptor: input,
+    artifactPorts,
+    ledger,
+    ledgerArtifactResolver,
+    now = Date.now,
+  } = {}) {
+    this.descriptor = normalizeDescriptor(input);
+    this._put = capture(artifactPorts, "putCanonical", "artifactPorts");
+    this._read = capture(ledger, "read", "ledger");
+    this._verify = capture(ledger, "verify", "ledger");
+    this._append = capture(ledger, "appendDomainEvent", "ledger");
+    if (!isEvolutionLedgerArtifactResolver(ledgerArtifactResolver)) {
+      throw new TypeError(
+        "a branded EvolutionArtifactPorts ledger resolver is required",
+      );
+    }
+    if (typeof now !== "function")
+      throw new TypeError("now must be a function");
+    this._resolve = ledgerArtifactResolver;
+    this._now = now;
+    Object.freeze(this);
+  }
+
+  _domainEvents() {
+    const events = this._read();
+    if (!Array.isArray(events)) {
+      fail(
+        EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+        "EvolutionLedger did not return events",
+      );
+    }
+    return events.filter(
+      (event) =>
+        event.schema === EVOLUTION_LEDGER_DOMAIN_EVENT_SCHEMA &&
+        event.type === EVOLUTION_RUN_LEDGER_EVENT_TYPE &&
+        event.tenantId === this.descriptor.tenantId &&
+        event.correlationId === this.descriptor.runId,
+    );
+  }
+
+  _resolveEvent(domainEvent) {
+    if (
+      !domainEvent?.subjectRef ||
+      typeof domainEvent.subjectRef.ref !== "string" ||
+      !DIGEST.test(domainEvent.subjectRef.digest ?? "")
+    ) {
+      fail(
+        EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+        "EvolutionRun ledger subject reference is invalid",
+      );
+    }
+    const identity = this._verify();
+    const resolution = this._resolve({
+      epoch: identity.epoch,
+      ledgerId: identity.ledgerId,
+      ref: domainEvent.subjectRef,
+      tenantId: this.descriptor.artifactTenantId,
+    });
+    if (
+      resolution?.ref !== domainEvent.subjectRef.ref ||
+      resolution.digest !== domainEvent.subjectRef.digest
+    ) {
+      fail(
+        EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+        "EvolutionRun ledger subject was substituted",
+      );
+    }
+    return parseRecord(resolution, this.descriptor);
+  }
+
+  _entries() {
+    const entries = this._domainEvents().map((domainEvent) => ({
+      domainEvent,
+      event: this._resolveEvent(domainEvent),
+    }));
+    entries.sort((left, right) => left.event.sequence - right.event.sequence);
+    for (let index = 0; index < entries.length; index += 1) {
+      const entry = entries[index];
+      const previous = entries[index - 1] ?? null;
+      const expectedDomainEventId = `${EVOLUTION_RUN_LEDGER_EVENT_TYPE}.${entry.domainEvent.subjectRef.digest.slice("sha256:".length)}`;
+      if (
+        entry.domainEvent.eventId !== expectedDomainEventId ||
+        entry.domainEvent.decision !== "committed" ||
+        entry.domainEvent.artifactTenantId !==
+          this.descriptor.artifactTenantId ||
+        entry.domainEvent.skillName !== null
+      ) {
+        fail(
+          EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+          "EvolutionRun domain event binding is invalid",
+        );
+      }
+      if (entry.event.sequence !== index + 1) {
+        fail(
+          EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+          "EvolutionRun event sequence has a gap or duplicate",
+        );
+      }
+      const expectedSources = previous ? [previous.domainEvent.subjectRef] : [];
+      if (!same(entry.domainEvent.sourceRefs, expectedSources)) {
+        fail(
+          EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+          "EvolutionRun artifact lineage is discontinuous",
+        );
+      }
+    }
+    const events = entries.map(({ event }) => event);
+    if (events.length > 0) {
+      if (events[0].type !== EVENT_TYPES.RUN_STARTED) {
+        fail(
+          EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+          "EvolutionRun does not begin with run-started",
+        );
+      }
+      projectEvolutionRun(events, {
+        tenantId: this.descriptor.tenantId,
+        runId: this.descriptor.runId,
+      });
+    }
+    return entries;
+  }
+
+  load() {
+    const entries = this._entries();
+    const events = entries.map(({ event }) => event);
+    return Object.freeze({
+      events: Object.freeze(events),
+      projection:
+        events.length === 0
+          ? null
+          : projectEvolutionRun(events, {
+              tenantId: this.descriptor.tenantId,
+              runId: this.descriptor.runId,
+            }),
+    });
+  }
+
+  appendEvent(input) {
+    const event = normalizeEvent(input, this.descriptor);
+    const before = this._entries();
+    const duplicate = before.find(
+      ({ event: stored }) => stored.eventId === event.eventId,
+    );
+    if (duplicate) {
+      if (!same(duplicate.event, event)) {
+        fail(
+          EVOLUTION_RUN_LEDGER_CONFLICT_CODE,
+          "EvolutionRun eventId already binds different content",
+        );
+      }
+      return Object.freeze({
+        committed: true,
+        recovered: true,
+        eventId: event.eventId,
+        projection: this.load().projection,
+      });
+    }
+    const expectedSequence = before.length + 1;
+    if (
+      event.sequence !== expectedSequence ||
+      (expectedSequence === 1 && event.type !== EVENT_TYPES.RUN_STARTED) ||
+      before.at(-1)?.event.type === EVENT_TYPES.RUN_COMPLETED
+    ) {
+      fail(
+        EVOLUTION_RUN_LEDGER_CONFLICT_CODE,
+        "EvolutionRun event does not extend the current stream",
+      );
+    }
+    const published = this._put(ARTIFACT_TYPE, event, {
+      audience: this.descriptor.audience,
+      purpose: this.descriptor.purpose,
+      retention: "ledger",
+    });
+    if (
+      !published?.ref ||
+      published.receipt?.persisted !== true ||
+      published.receipt.readbackVerified !== true ||
+      published.receipt.integrityVerified !== true ||
+      published.receipt.retention !== "ledger"
+    ) {
+      fail(
+        EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+        "EvolutionRun event persistence was not durably confirmed",
+      );
+    }
+    const head = this._verify();
+    const currentBeforeAppend = this._entries();
+    if (
+      currentBeforeAppend.length !== before.length ||
+      currentBeforeAppend.some(
+        ({ domainEvent }, index) =>
+          domainEvent.eventDigest !== before[index].domainEvent.eventDigest,
+      )
+    ) {
+      fail(
+        EVOLUTION_RUN_LEDGER_CONFLICT_CODE,
+        "EvolutionRun changed before ledger append",
+      );
+    }
+    const timestamp = new Date(Number(this._now())).toISOString();
+    const domainEventId = `${EVOLUTION_RUN_LEDGER_EVENT_TYPE}.${published.digest.slice("sha256:".length)}`;
+    let recoveredAfterAppend = false;
+    try {
+      const receipt = this._append(
+        {
+          artifactTenantId: this.descriptor.artifactTenantId,
+          correlationId: this.descriptor.runId,
+          decision: "committed",
+          eventId: domainEventId,
+          reason: `EvolutionRun sequence ${event.sequence} committed`,
+          skillName: null,
+          sourceRefs:
+            before.length === 0 ? [] : [before.at(-1).domainEvent.subjectRef],
+          subjectRef: published.ref,
+          tenantId: this.descriptor.tenantId,
+          timestamp,
+          type: EVOLUTION_RUN_LEDGER_EVENT_TYPE,
+        },
+        {
+          expectedHeadDigest: head.headDigest,
+          expectedSequence: head.sequence,
+        },
+      );
+      if (
+        receipt?.authenticated !== true ||
+        receipt.committed !== true ||
+        receipt.durable !== true ||
+        receipt.eventId !== domainEventId ||
+        !DIGEST.test(receipt.receiptDigest ?? "")
+      ) {
+        fail(
+          EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+          "EvolutionRun ledger append was not durably authenticated",
+        );
+      }
+    } catch (cause) {
+      const recovered = this._entries().find(
+        ({ event: stored }) => stored.eventId === event.eventId,
+      );
+      if (!recovered || !same(recovered.event, event)) throw cause;
+      recoveredAfterAppend = true;
+    }
+    const after = this.load();
+    const stored = after.events.at(-1);
+    if (!stored || !same(stored, event)) {
+      fail(
+        EVOLUTION_RUN_LEDGER_CORRUPT_CODE,
+        "EvolutionRun readback differs after append",
+      );
+    }
+    return Object.freeze({
+      committed: true,
+      recovered: recoveredAfterAppend,
+      eventId: event.eventId,
+      projection: after.projection,
+    });
+  }
+}

package/src/lib/evolution/evolution-run-runtime-adapter.js

@@ -0,0 +1,5 @@
+import evolutionRun from "@chainlesschain/session-core/evolution-run";
+
+export function projectCliEvolutionRun(events, options) {
+  return evolutionRun.projectEvolutionRun(events, options);
+}

package/src/lib/evolution/evolution-run-wiki-maintenance-source.js

@@ -0,0 +1,300 @@
+import { types as utilTypes } from "node:util";
+
+import evolutionRun from "@chainlesschain/session-core/evolution-run";
+
+import { captureAgentEvolutionRuntimeComposition } from "./agent-evolution-runtime-composition-brand.js";
+import {
+  WIKI_MAINTENANCE_TRIGGER_KIND,
+  WikiMaintenanceTriggerLedgerAdapter,
+} from "./wiki-maintenance-trigger-ledger-adapter.js";
+
+const { EVENT_TYPES } = evolutionRun;
+
+export const EVOLUTION_RUN_WIKI_MAINTENANCE_SOURCE_SCHEMA =
+  "chainlesschain.evolution-run-wiki-maintenance-source/v1";
+export const EVOLUTION_RUN_WIKI_MAINTENANCE_PRODUCER_SCHEMA =
+  "chainlesschain.evolution-run-wiki-maintenance-producer/v1";
+export const EVOLUTION_RUN_WIKI_MAINTENANCE_SOURCE_INVALID_CODE =
+  "CC_EVOLUTION_RUN_WIKI_MAINTENANCE_SOURCE_INVALID";
+
+const SOURCES = new WeakSet();
+const PRODUCERS = new WeakSet();
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const SUPPORTED_KINDS = new Set([
+  WIKI_MAINTENANCE_TRIGGER_KIND.SESSION_END,
+  WIKI_MAINTENANCE_TRIGGER_KIND.GOAL_END,
+]);
+const VERIFY_KEYS = new Set([
+  "tenantId",
+  "kind",
+  "sourceId",
+  "sourceReceiptDigest",
+  "evidenceRefs",
+  "effectiveAt",
+]);
+const BUILD_KEYS = new Set(["kind", "runId"]);
+
+function failure(message, options) {
+  const error = new Error(message, options);
+  error.code = EVOLUTION_RUN_WIKI_MAINTENANCE_SOURCE_INVALID_CODE;
+  return error;
+}
+
+function requiredString(value, label) {
+  if (
+    typeof value !== "string" ||
+    value.trim() === "" ||
+    Buffer.byteLength(value, "utf8") > 256
+  ) {
+    throw failure(`${label} is invalid`);
+  }
+  return value;
+}
+
+function assertExactRecord(value, keys, label) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    utilTypes.isProxy(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+  ) {
+    throw failure(`${label} must be a plain object`);
+  }
+  const ownKeys = Reflect.ownKeys(value);
+  if (
+    ownKeys.length !== keys.size ||
+    ownKeys.some((key) => typeof key !== "string" || !keys.has(key))
+  ) {
+    throw failure(`${label} must contain exactly the supported fields`);
+  }
+  for (const key of ownKeys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
+      throw failure(`${label}.${String(key)} must be an enumerable data field`);
+    }
+  }
+}
+
+function canonical(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  return `{${Object.keys(value)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+    .join(",")}}`;
+}
+
+function same(left, right) {
+  return canonical(left) === canonical(right);
+}
+
+function deepFreeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) deepFreeze(child);
+  }
+  return value;
+}
+
+function canonicalTimestamp(value, label) {
+  requiredString(value, label);
+  const parsed = new Date(value);
+  if (!Number.isFinite(parsed.getTime()) || parsed.toISOString() !== value) {
+    throw failure(`${label} must be a canonical timestamp`);
+  }
+  return value;
+}
+
+function captureCompositionResolver(value) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    utilTypes.isProxy(value) ||
+    typeof value.resolve !== "function"
+  ) {
+    throw new TypeError("runCompositionResolver.resolve is required");
+  }
+  const resolve = value.resolve.bind(value);
+  Object.freeze(value);
+  return resolve;
+}
+
+function captureSource(value) {
+  if (!SOURCES.has(value)) {
+    throw new TypeError(
+      "a branded EvolutionRun Wiki maintenance source is required",
+    );
+  }
+  return value;
+}
+
+function normalizeBuildInput(value) {
+  assertExactRecord(value, BUILD_KEYS, "completed run trigger input");
+  if (!SUPPORTED_KINDS.has(value.kind)) {
+    throw failure(
+      "completed EvolutionRun sources only support session-end and goal-end",
+    );
+  }
+  return deepFreeze({
+    kind: value.kind,
+    runId: requiredString(value.runId, "runId"),
+  });
+}
+
+function captureRun(resolveComposition, tenantId, runId) {
+  let composition;
+  try {
+    composition = captureAgentEvolutionRuntimeComposition(
+      resolveComposition(deepFreeze({ tenantId, runId })),
+    );
+  } catch (cause) {
+    throw failure(
+      "run resolver did not return a branded Agent evolution composition",
+      { cause },
+    );
+  }
+  if (
+    composition.tenantId !== tenantId ||
+    composition.runId !== runId ||
+    typeof composition.loadRun !== "function"
+  ) {
+    throw failure(
+      "run resolver did not return the exact tenant-scoped Agent evolution composition",
+    );
+  }
+  return composition;
+}
+
+function projectTrigger(resolveComposition, tenantId, input) {
+  const normalized = normalizeBuildInput(input);
+  const composition = captureRun(
+    resolveComposition,
+    tenantId,
+    normalized.runId,
+  );
+  const loaded = composition.loadRun();
+  const events = loaded?.events;
+  const projection = loaded?.projection;
+  const completion = Array.isArray(events) ? events.at(-1) : null;
+  if (
+    !Array.isArray(events) ||
+    events.length < 2 ||
+    projection?.tenantId !== tenantId ||
+    projection.runId !== normalized.runId ||
+    projection.status !== "completed" ||
+    !DIGEST.test(projection.projectionDigest ?? "") ||
+    completion?.type !== EVENT_TYPES.RUN_COMPLETED ||
+    completion.subjectId !== normalized.runId
+  ) {
+    throw failure("EvolutionRun is not durably completed");
+  }
+  const effectiveAt = canonicalTimestamp(
+    completion.data?.occurredAt,
+    "run completion occurredAt",
+  );
+  const evidenceEvents = events.filter(
+    (event) => event.type === EVENT_TYPES.RAW_EVENT_REFERENCED,
+  );
+  const evidenceRefs = [
+    ...new Set(
+      evidenceEvents.map((event) =>
+        requiredString(event.subjectId, "evidence subjectId"),
+      ),
+    ),
+  ].sort();
+  if (evidenceRefs.length === 0 || evidenceRefs.length > 256) {
+    throw failure("completed EvolutionRun has no bounded evidence set");
+  }
+  if (
+    normalized.kind === WIKI_MAINTENANCE_TRIGGER_KIND.GOAL_END &&
+    !evidenceEvents.some((event) => event.data?.evidenceKind === "goal-ended")
+  ) {
+    throw failure(
+      "goal-end trigger requires authenticated goal-ended evidence",
+    );
+  }
+  return deepFreeze({
+    kind: normalized.kind,
+    sourceId: normalized.runId,
+    sourceReceiptDigest: projection.projectionDigest,
+    evidenceRefs,
+    effectiveAt,
+  });
+}
+
+export function createEvolutionRunWikiMaintenanceSource({
+  tenantId: tenantInput,
+  runCompositionResolver,
+} = {}) {
+  const tenantId = requiredString(tenantInput, "tenantId");
+  const resolveComposition = captureCompositionResolver(runCompositionResolver);
+  const source = {
+    schema: EVOLUTION_RUN_WIKI_MAINTENANCE_SOURCE_SCHEMA,
+    tenantId,
+    build(input) {
+      return projectTrigger(resolveComposition, tenantId, input);
+    },
+    async verify(input) {
+      assertExactRecord(input, VERIFY_KEYS, "Wiki maintenance source request");
+      if (input.tenantId !== tenantId) {
+        throw failure("Wiki maintenance source belongs to another tenant");
+      }
+      const expected = projectTrigger(resolveComposition, tenantId, {
+        kind: input.kind,
+        runId: input.sourceId,
+      });
+      if (!same(input, { tenantId, ...expected })) {
+        throw failure(
+          "Wiki maintenance source no longer matches the durable EvolutionRun",
+        );
+      }
+      return deepFreeze({
+        authenticated: true,
+        durable: true,
+        tenantId,
+        kind: expected.kind,
+        sourceId: expected.sourceId,
+        receiptDigest: expected.sourceReceiptDigest,
+        evidenceRefs: expected.evidenceRefs,
+        effectiveAt: expected.effectiveAt,
+      });
+    },
+  };
+  SOURCES.add(source);
+  return Object.freeze(source);
+}
+
+export function createEvolutionRunWikiMaintenanceProducer({
+  source: sourceInput,
+  triggerAdapter,
+} = {}) {
+  const source = captureSource(sourceInput);
+  if (
+    !(triggerAdapter instanceof WikiMaintenanceTriggerLedgerAdapter) ||
+    triggerAdapter.descriptor?.tenantId !== source.tenantId
+  ) {
+    throw new TypeError(
+      "a tenant-matched WikiMaintenanceTriggerLedgerAdapter is required",
+    );
+  }
+  const enqueue = triggerAdapter.enqueue.bind(triggerAdapter);
+  const producer = {
+    schema: EVOLUTION_RUN_WIKI_MAINTENANCE_PRODUCER_SCHEMA,
+    tenantId: source.tenantId,
+    async enqueueCompletedRun(input) {
+      return enqueue(source.build(input));
+    },
+  };
+  PRODUCERS.add(producer);
+  return Object.freeze(producer);
+}
+
+export function captureEvolutionRunWikiMaintenanceProducer(value) {
+  if (!PRODUCERS.has(value)) {
+    throw new TypeError(
+      "a branded EvolutionRun Wiki maintenance producer is required",
+    );
+  }
+  return value;
+}