@ixo/editor 6.33.0 → 6.34.0

package/dist/chunk-JIDTNKKL.js

@@ -0,0 +1,1183 @@
+import {
+  TerminalRunExecutionError,
+  getAction,
+  isRecordInRun,
+  isRunTerminalOrPending
+} from "./chunk-IIIZZ4E4.js";
+import {
+  getExistingYMap
+} from "./chunk-NCSGIRRQ.js";
+
+// src/core/lib/designPod/contracts.ts
+var DESIGN_POD_TEMPLATE_ID = "design-pod-portal-journey-v2";
+var DESIGN_POD_PHASE_IDS = ["discovery", "design", "validation", "testing", "deployment"];
+var DESIGN_POD_CONTROL_IDS = [
+  "provider_onboarding",
+  "service_intent",
+  "service_architecture",
+  "outcome_contract",
+  "automation_feasibility",
+  "evidence_model",
+  "claims_and_rubrics",
+  "ucan_rights",
+  "flow_configuration",
+  "oracle_configuration",
+  "governance_risk",
+  "commercial_packaging",
+  "demo_build",
+  "domain_documentation",
+  "vfs_packaging",
+  "launch_readiness",
+  "operate_improve"
+];
+var PHASES = [
+  {
+    id: "discovery",
+    title: "Discovery",
+    description: "Confirm the provider, opportunity intent, youth benefit, and design boundaries.",
+    controls: ["provider_onboarding", "service_intent"]
+  },
+  {
+    id: "design",
+    title: "Design",
+    description: "Design the Deed, evidence, claims, rights, operational Flows, and service skills.",
+    controls: [
+      "service_architecture",
+      "outcome_contract",
+      "automation_feasibility",
+      "evidence_model",
+      "claims_and_rubrics",
+      "ucan_rights",
+      "flow_configuration",
+      "oracle_configuration"
+    ]
+  },
+  {
+    id: "validation",
+    title: "Validation",
+    description: "Resolve governance, safeguarding, risk, authority, and commercial packaging.",
+    controls: ["governance_risk", "commercial_packaging"]
+  },
+  {
+    id: "testing",
+    title: "Testing",
+    description: "Run a representative end-to-end Deed rehearsal and inspect its evidence.",
+    controls: ["demo_build"]
+  },
+  {
+    id: "deployment",
+    title: "Deployment",
+    description: "Package, publish, launch, and establish the operate-and-improve model.",
+    controls: ["domain_documentation", "vfs_packaging", "launch_readiness", "operate_improve"]
+  }
+];
+var DEPENDENCIES = {
+  provider_onboarding: [],
+  service_intent: ["provider_onboarding"],
+  service_architecture: ["service_intent"],
+  outcome_contract: ["service_intent", "service_architecture"],
+  automation_feasibility: ["service_architecture"],
+  evidence_model: ["outcome_contract"],
+  claims_and_rubrics: ["outcome_contract", "evidence_model"],
+  ucan_rights: ["service_architecture", "automation_feasibility"],
+  flow_configuration: ["service_architecture", "ucan_rights"],
+  oracle_configuration: ["service_architecture", "ucan_rights", "flow_configuration"],
+  governance_risk: [
+    "service_architecture",
+    "outcome_contract",
+    "automation_feasibility",
+    "evidence_model",
+    "claims_and_rubrics",
+    "ucan_rights",
+    "flow_configuration",
+    "oracle_configuration"
+  ],
+  commercial_packaging: ["service_intent", "outcome_contract"],
+  demo_build: ["claims_and_rubrics", "flow_configuration", "oracle_configuration"],
+  domain_documentation: ["governance_risk", "commercial_packaging"],
+  vfs_packaging: ["domain_documentation", "ucan_rights", "oracle_configuration"],
+  launch_readiness: ["demo_build", "governance_risk", "vfs_packaging"],
+  operate_improve: ["launch_readiness"]
+};
+var TITLES = {
+  provider_onboarding: "Opportunity Provider onboarding",
+  service_intent: "Deed and youth opportunity intent",
+  service_architecture: "Deed service architecture",
+  outcome_contract: "Theory-of-change outcome contract",
+  automation_feasibility: "Automation feasibility",
+  evidence_model: "Evidence model",
+  claims_and_rubrics: "Claims and evaluation rubrics",
+  ucan_rights: "Participant rights and UCAN capabilities",
+  flow_configuration: "Operational Flow configuration",
+  oracle_configuration: "Evaluation and service skills",
+  governance_risk: "Governance, safeguarding, consent, and risk",
+  commercial_packaging: "Funding and commercial packaging",
+  demo_build: "Representative dry-run",
+  domain_documentation: "Domain documentation",
+  vfs_packaging: "Entity VFS package",
+  launch_readiness: "Launch readiness",
+  operate_improve: "Operate and improve"
+};
+var SKILLS = {
+  service_intent: "design-pod-service-intent-scorer",
+  service_architecture: "design-pod-service-architect",
+  outcome_contract: "design-pod-outcome-contract",
+  automation_feasibility: "design-pod-automation-feasibility",
+  claims_and_rubrics: "design-pod-claims-architect",
+  ucan_rights: "design-pod-ucan-rights-architect",
+  flow_configuration: "design-pod-flow-builder",
+  governance_risk: "design-pod-governance-risk",
+  commercial_packaging: "design-pod-commercial-packager",
+  demo_build: "design-pod-demo-builder",
+  launch_readiness: "design-pod-qa-launch-readiness"
+};
+function buildControls() {
+  return Object.fromEntries(
+    DESIGN_POD_CONTROL_IDS.map((id) => [
+      id,
+      {
+        id,
+        title: TITLES[id],
+        schema: `ixo.design-pod.${id}.v1`,
+        skill: SKILLS[id] ?? "design-pod-orchestration",
+        dependencies: DEPENDENCIES[id]
+      }
+    ])
+  );
+}
+var BASE_MANIFEST = {
+  schemaVersion: "1.0",
+  templateId: DESIGN_POD_TEMPLATE_ID,
+  methodVersion: 1,
+  phases: PHASES,
+  controls: buildControls(),
+  publicationRules: {
+    independentReviewRequired: true,
+    phaseDecision: "Yes, continue",
+    canonicalPackageRoot: "/pod-blueprints/{releaseDigest}",
+    domainPath: "/.domain/domain.md",
+    contentAddressedArtifacts: true,
+    checklistItems: [
+      { id: "safeguarding-owner", title: "Safeguarding owner", description: "A named authority owns safeguarding decisions and escalation." },
+      { id: "rights-and-consent", title: "Rights and consent", description: "Participant rights, consent, and data handling are launch-ready." },
+      { id: "funding-readiness", title: "Funding readiness", description: "The governed funding source and payout controls are verified." },
+      { id: "credential-authority", title: "Credential authority", description: "Credential and outcome issuers have explicit authority." },
+      { id: "testnet-rehearsal", title: "Testnet rehearsal", description: "The representative end-to-end rehearsal has no unresolved blocker." }
+    ]
+  }
+};
+var PROFESSIONAL_SERVICE_METHOD_V1 = {
+  ...BASE_MANIFEST,
+  methodId: "professional-service/v1",
+  title: "Professional Service POD",
+  operationalActions: []
+};
+var DESIGN_YOMA_METHOD_V1 = {
+  ...BASE_MANIFEST,
+  methodId: "design-yoma/v1",
+  title: "Yoma Deed POD",
+  operationalActions: [
+    "qi/collection.lifecycle",
+    "qi/collection.users",
+    "qi/claim.submit",
+    "qi/claim.evaluate",
+    "qi/funding.verify",
+    "qi/credential.issue",
+    "qi/credential.store",
+    "qi/yoma.opportunity",
+    "qi/yoid.link",
+    "qi/outcome.certificate"
+  ]
+};
+var DESIGN_POD_METHODS = {
+  "professional-service/v1": PROFESSIONAL_SERVICE_METHOD_V1,
+  "design-yoma/v1": DESIGN_YOMA_METHOD_V1
+};
+
+// src/core/lib/flowEngine/runHistory.ts
+var INVOCATIONS_MAP_KEY = "invocations";
+function readInvocationsForRun(yDoc, sessionRunId) {
+  const existing = getExistingYMap(yDoc, INVOCATIONS_MAP_KEY);
+  if (!existing) return [];
+  const invocations = [];
+  existing.forEach((value) => {
+    if (!value || typeof value !== "object") return;
+    const invocation = value;
+    if (!invocation.cid) return;
+    if (!isRecordInRun(invocation.sessionRunId, sessionRunId)) return;
+    invocations.push({
+      ...invocation,
+      capability: { ...invocation.capability || {} },
+      proofCids: [...invocation.proofCids || []]
+    });
+  });
+  return invocations.sort((a, b) => b.executedAt - a.executedAt || a.cid.localeCompare(b.cid));
+}
+
+// src/core/lib/designPod/digest.ts
+function canonicalValue(value) {
+  if (value === null) return "null";
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("Design POD canonical JSON does not allow non-finite numbers");
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) return `[${value.map((item) => canonicalValue(item)).join(",")}]`;
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter(([, child]) => child !== void 0).sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${canonicalValue(child)}`).join(",")}}`;
+  }
+  throw new Error(`Design POD canonical JSON does not support ${typeof value}`);
+}
+function canonicalDesignPodJson(value) {
+  return canonicalValue(value);
+}
+async function digestDesignPodValue(value) {
+  const bytes = new TextEncoder().encode(canonicalDesignPodJson(value));
+  const hash = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  return `sha256:${Array.from(new Uint8Array(hash), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+
+// src/core/lib/designPod/state.ts
+var DESIGN_POD_DEFINITION_MAP_KEY = "designPodDefinition";
+var DESIGN_POD_STATE_MAP_KEY = "designPodState";
+var MANIFEST_KEY = "manifest";
+var IDENTITY_KEY = "identity";
+var REVIEW_KEY = "review";
+var REVIEW_ASSIGNMENT_KEY = "reviewAssignment";
+var REVIEW_REQUEST_KEY = "reviewRequest";
+var RELEASE_KEY = "release";
+var PROTOCOL_KEY = "protocol";
+var LEGACY_EVIDENCE_KEY = "legacyEvidence";
+var CONTROL_PREFIX = "control:";
+var ARTIFACT_PREFIX = "artifact:";
+var COMMITMENT_PREFIX = "commitment:";
+var CHECKLIST_PREFIX = "checklist:";
+function stateMap(doc) {
+  return doc.getMap(DESIGN_POD_STATE_MAP_KEY);
+}
+function definitionMap(doc) {
+  return doc.getMap(DESIGN_POD_DEFINITION_MAP_KEY);
+}
+function sameDesignPodActor(a, b) {
+  const norm = (value) => {
+    const v = (value || "").trim();
+    return v.startsWith("ixo1") ? `did:ixo:${v}` : v;
+  };
+  const left = norm(a);
+  return left !== "" && left === norm(b);
+}
+function seedDesignPodMethodDefinition(doc, methodId) {
+  const manifest = DESIGN_POD_METHODS[methodId];
+  if (!manifest) throw new Error(`Unknown Design POD method: ${methodId}`);
+  definitionMap(doc).set(MANIFEST_KEY, manifest);
+  return manifest;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+async function initializeDesignPod(doc, methodId, identity) {
+  const manifest = DESIGN_POD_METHODS[methodId];
+  if (!manifest) throw new Error(`Unknown Design POD method: ${methodId}`);
+  const methodManifestDigest = await digestDesignPodValue(manifest);
+  const pinnedIdentity = { ...identity, methodManifestDigest };
+  let initializedIdentity = pinnedIdentity;
+  doc.transact(() => {
+    const map = stateMap(doc);
+    const existingIdentity = map.get(IDENTITY_KEY);
+    if (existingIdentity) {
+      if (existingIdentity.designProjectEntityDid !== pinnedIdentity.designProjectEntityDid || existingIdentity.flowOwnerDid !== pinnedIdentity.flowOwnerDid || existingIdentity.flowRoomId !== pinnedIdentity.flowRoomId || existingIdentity.sessionRunId !== pinnedIdentity.sessionRunId || existingIdentity.methodManifestDigest !== pinnedIdentity.methodManifestDigest) {
+        throw new Error("Design POD identity is already pinned to a different project session");
+      }
+      const root2 = doc.getMap("root");
+      if (root2.get("doc_id") !== pinnedIdentity.flowRoomId || root2.get("flowOwnerDid") !== pinnedIdentity.flowOwnerDid) {
+        throw new Error("Design POD Flow authority no longer matches its pinned Flow owner and Matrix room");
+      }
+      if (isRunTerminalOrPending(doc, existingIdentity.sessionRunId)) {
+        throw new TerminalRunExecutionError(existingIdentity.sessionRunId, "design-pod-initialize");
+      }
+      initializedIdentity = existingIdentity;
+      return;
+    }
+    if (isRunTerminalOrPending(doc, pinnedIdentity.sessionRunId)) {
+      throw new TerminalRunExecutionError(pinnedIdentity.sessionRunId, "design-pod-initialize");
+    }
+    definitionMap(doc).set(MANIFEST_KEY, manifest);
+    map.set(IDENTITY_KEY, pinnedIdentity);
+    const root = doc.getMap("root");
+    root.set("@context", "https://ixo.world/flow/1.0");
+    root.set("schema_version", "1.0.0");
+    root.set("doc_id", pinnedIdentity.flowRoomId);
+    root.set("flowOwnerDid", pinnedIdentity.flowOwnerDid);
+  });
+  return initializedIdentity;
+}
+function readDesignPodDefinition(doc) {
+  return definitionMap(doc).get(MANIFEST_KEY);
+}
+function readDesignPodState(doc) {
+  const map = stateMap(doc);
+  const identity = map.get(IDENTITY_KEY);
+  if (!identity) return void 0;
+  const controls = {};
+  const artifactReceipts = [];
+  const phaseCommitments = {};
+  const checklistRecords = {};
+  const checklistDispositions = {};
+  map.forEach((value, key) => {
+    if (key.startsWith(CONTROL_PREFIX)) controls[key.slice(CONTROL_PREFIX.length)] = value;
+    if (key.startsWith(ARTIFACT_PREFIX)) artifactReceipts.push(value);
+    if (key.startsWith(COMMITMENT_PREFIX)) phaseCommitments[key.slice(COMMITMENT_PREFIX.length)] = value;
+    if (key.startsWith(CHECKLIST_PREFIX)) {
+      const itemId = key.slice(CHECKLIST_PREFIX.length);
+      checklistRecords[itemId] = value;
+      if (isRecord(value)) {
+        const record2 = value;
+        if (["resolved", "accepted_for_later", "blocking"].includes(record2.disposition)) checklistDispositions[itemId] = record2.disposition;
+      }
+    }
+  });
+  const commitmentCount = Object.values(phaseCommitments).filter((record2) => record2?.status === "current").length;
+  const review = map.get(REVIEW_KEY);
+  const reviewAssignment = map.get(REVIEW_ASSIGNMENT_KEY);
+  const reviewRequest = map.get(REVIEW_REQUEST_KEY);
+  const release = map.get(RELEASE_KEY);
+  const protocol = map.get(PROTOCOL_KEY);
+  const readiness = release?.status === "published" ? "published" : release?.status === "compiled" ? "compiled" : review?.status === "current" && review.decision === "approved" ? "reviewed" : commitmentCount === 5 ? "phases_committed" : "draft";
+  return {
+    schemaVersion: "1.0",
+    identity,
+    controls,
+    artifactReceipts: artifactReceipts.sort((left, right) => left.path.localeCompare(right.path)),
+    phaseCommitments,
+    checklistRecords,
+    checklistDispositions,
+    reviewAssignment,
+    reviewRequest,
+    review,
+    release,
+    protocol,
+    readiness,
+    publicationStatus: release?.status === "published" ? "published" : release?.status === "publishing" ? "publishing" : release?.status === "failed" ? "failed" : release?.status === "compiled" ? "ready" : "not_started"
+  };
+}
+function collectDependants(manifest, changed) {
+  const affected = /* @__PURE__ */ new Set();
+  let grew = true;
+  while (grew) {
+    grew = false;
+    for (const control of Object.values(manifest.controls)) {
+      if (control.id === changed || affected.has(control.id)) continue;
+      if (control.dependencies.some((dependency) => dependency === changed || affected.has(dependency))) {
+        affected.add(control.id);
+        grew = true;
+      }
+    }
+  }
+  return affected;
+}
+function phaseForControl(manifest, controlId) {
+  const phase = manifest.phases.find((candidate) => candidate.controls.includes(controlId));
+  if (!phase) throw new Error(`Control ${controlId} is not assigned to a Design POD phase`);
+  return phase.id;
+}
+function staleReviewAndRelease(map) {
+  const reviewRequest = map.get(REVIEW_REQUEST_KEY);
+  if (isRecord(reviewRequest)) map.set(REVIEW_REQUEST_KEY, { ...reviewRequest, status: "stale" });
+  const review = map.get(REVIEW_KEY);
+  if (isRecord(review)) map.set(REVIEW_KEY, { ...review, status: "stale" });
+  const release = map.get(RELEASE_KEY);
+  if (isRecord(release)) map.set(RELEASE_KEY, { ...release, status: "stale" });
+}
+function assertPublicationCanBeInvalidated(map, operation) {
+  const release = map.get(RELEASE_KEY);
+  if (isRecord(release) && release.status === "publishing") {
+    throw new Error(`${operation} cannot change Design POD authority while IXO publication is reserved`);
+  }
+}
+function assertProjectIdentity(map, expected, operation) {
+  const current = map.get(IDENTITY_KEY);
+  if (!current || current.designProjectEntityDid !== expected.designProjectEntityDid || current.flowOwnerDid !== expected.flowOwnerDid || current.flowRoomId !== expected.flowRoomId || current.sessionRunId !== expected.sessionRunId || current.methodManifestDigest !== expected.methodManifestDigest) {
+    throw new Error(`The pinned Design POD project identity changed while ${operation} was being prepared`);
+  }
+}
+async function updateDesignPodControl(doc, params) {
+  const manifest = readDesignPodDefinition(doc);
+  const state = readDesignPodState(doc);
+  if (!manifest || !state) throw new Error("Design POD method definition is not initialized");
+  if (!manifest.controls[params.controlId]) throw new Error(`Control ${params.controlId} is not in the pinned method manifest`);
+  const sessionRunId = params.sessionRunId ?? state.identity.sessionRunId;
+  if (sessionRunId !== state.identity.sessionRunId) throw new Error("Control mutation session does not match the pinned Design POD session");
+  const map = stateMap(doc);
+  const prior = map.get(`${CONTROL_PREFIX}${params.controlId}`);
+  const priorDigest = prior?.digest ?? null;
+  if (params.expectedBaseDigest !== void 0 && priorDigest !== params.expectedBaseDigest) {
+    throw new Error(`${params.controlId} changed before the proposed revision could be prepared`);
+  }
+  const revision = (prior?.revision ?? 0) + 1;
+  const digest = await digestDesignPodValue({ controlId: params.controlId, revision, content: params.content });
+  const next = {
+    controlId: params.controlId,
+    revision,
+    digest,
+    content: params.content,
+    status: params.importedLegacy ? "draft" : "current",
+    updatedAt: params.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+    updatedByDid: params.actorDid
+  };
+  const dependants = collectDependants(manifest, params.controlId);
+  const affectedPhases = /* @__PURE__ */ new Set([phaseForControl(manifest, params.controlId)]);
+  dependants.forEach((controlId) => affectedPhases.add(phaseForControl(manifest, controlId)));
+  doc.transact(() => {
+    assertProjectIdentity(map, state.identity, `control ${params.controlId}`);
+    if (isRunTerminalOrPending(doc, sessionRunId)) {
+      throw new TerminalRunExecutionError(sessionRunId, `design-pod-control:${params.controlId}`);
+    }
+    assertPublicationCanBeInvalidated(map, `Updating ${params.controlId}`);
+    const current = map.get(`${CONTROL_PREFIX}${params.controlId}`);
+    const currentDigest = current?.digest ?? null;
+    if (currentDigest !== priorDigest || params.expectedBaseDigest !== void 0 && currentDigest !== params.expectedBaseDigest) {
+      throw new Error(`${params.controlId} changed while the proposed revision was being prepared`);
+    }
+    map.set(`${CONTROL_PREFIX}${params.controlId}`, next);
+    dependants.forEach((controlId) => {
+      const current2 = map.get(`${CONTROL_PREFIX}${controlId}`);
+      if (isRecord(current2)) map.set(`${CONTROL_PREFIX}${controlId}`, { ...current2, status: "stale" });
+    });
+    affectedPhases.forEach((phaseId) => {
+      const commitment = map.get(`${COMMITMENT_PREFIX}${phaseId}`);
+      if (isRecord(commitment)) map.set(`${COMMITMENT_PREFIX}${phaseId}`, { ...commitment, status: "stale" });
+    });
+    staleReviewAndRelease(map);
+  });
+  return next;
+}
+function createDesignPodArtifactReceipt(doc, receipt) {
+  if (!receipt.id || !receipt.path || !receipt.version || !receipt.contentHash || !receipt.cid) {
+    throw new Error("A verified VFS artifact receipt requires id, path, version, contentHash, and cid");
+  }
+  const identity = stateMap(doc).get(IDENTITY_KEY);
+  if (identity && isRunTerminalOrPending(doc, identity.sessionRunId)) {
+    throw new TerminalRunExecutionError(identity.sessionRunId, `design-pod-artifact-receipt:${receipt.controlId}`);
+  }
+  const value = { schemaVersion: "1.0", ...receipt };
+  stateMap(doc).set(`${ARTIFACT_PREFIX}${receipt.controlId}:${receipt.digest}`, value);
+  return value;
+}
+async function commitDesignPodPhase(doc, params) {
+  const manifest = readDesignPodDefinition(doc);
+  const state = readDesignPodState(doc);
+  if (!manifest || !state) throw new Error("Design POD is not initialized");
+  if (params.decision !== manifest.publicationRules.phaseDecision) throw new Error("Phase commitment requires the explicit \u201CYes, continue\u201D decision");
+  const phase = manifest.phases.find((candidate) => candidate.id === params.phaseId);
+  if (!phase) throw new Error(`Unknown Design POD phase: ${params.phaseId}`);
+  const controlDigests = {};
+  const receipts = [];
+  for (const controlId of phase.controls) {
+    const revision = state.controls[controlId];
+    if (!revision || revision.status !== "current") throw new Error(`${controlId} must have a current revision before committing ${params.phaseId}`);
+    if (params.expectedControlDigests[controlId] !== revision.digest) throw new Error(`${controlId} changed while ${params.phaseId} was being committed`);
+    const receipt = state.artifactReceipts.find((candidate) => candidate.controlId === controlId && candidate.digest === revision.digest);
+    if (!receipt) throw new Error(`${controlId} has not been persisted and verified through the Design Project entity VFS`);
+    controlDigests[controlId] = revision.digest;
+    receipts.push(receipt);
+  }
+  const committedAt = params.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const digest = await digestDesignPodValue({ phaseId: params.phaseId, controlDigests, artifactReceipts: receipts, committedByDid: params.actorDid, committedAt });
+  const commitment = {
+    schemaVersion: "1.0",
+    phaseId: params.phaseId,
+    decision: "Yes, continue",
+    committedByDid: params.actorDid,
+    committedAt,
+    controlDigests,
+    artifactReceipts: receipts,
+    proof: params.proof,
+    digest,
+    status: "current"
+  };
+  const map = stateMap(doc);
+  doc.transact(() => {
+    assertProjectIdentity(map, state.identity, `${params.phaseId} commitment`);
+    if (isRunTerminalOrPending(doc, state.identity.sessionRunId)) {
+      throw new TerminalRunExecutionError(state.identity.sessionRunId, `design-pod-phase-commit:${params.phaseId}`);
+    }
+    for (const controlId of phase.controls) {
+      const current = map.get(`${CONTROL_PREFIX}${controlId}`);
+      if (!current || current.status !== "current" || current.digest !== controlDigests[controlId]) {
+        throw new Error(`${controlId} changed while ${params.phaseId} commitment was being prepared`);
+      }
+      const expectedReceipt = receipts.find((receipt) => receipt.controlId === controlId);
+      const currentReceipt = map.get(`${ARTIFACT_PREFIX}${controlId}:${current.digest}`);
+      if (!currentReceipt || currentReceipt.id !== expectedReceipt.id || currentReceipt.path !== expectedReceipt.path || currentReceipt.version !== expectedReceipt.version || currentReceipt.contentHash !== expectedReceipt.contentHash || currentReceipt.cid !== expectedReceipt.cid) {
+        throw new Error(`${controlId} VFS proof changed while ${params.phaseId} commitment was being prepared`);
+      }
+    }
+    const currentCommitment = map.get(`${COMMITMENT_PREFIX}${params.phaseId}`);
+    if (isRecord(currentCommitment) && currentCommitment.status === "current" && currentCommitment.digest !== commitment.digest) {
+      assertPublicationCanBeInvalidated(map, `Recommitting ${params.phaseId}`);
+      staleReviewAndRelease(map);
+    }
+    map.set(`${COMMITMENT_PREFIX}${params.phaseId}`, commitment);
+  });
+  return commitment;
+}
+async function computeDesignPodRevisionSetDigest(doc) {
+  const state = readDesignPodState(doc);
+  if (!state) throw new Error("Design POD is not initialized");
+  const phases = Object.entries(state.phaseCommitments).filter(([, commitment]) => commitment?.status === "current").sort(([left], [right]) => left.localeCompare(right));
+  const checklistRecords = Object.entries(state.checklistRecords).sort(([left], [right]) => left.localeCompare(right));
+  return digestDesignPodValue({ phases, checklistRecords });
+}
+function markDesignPodReviewed(doc, params) {
+  const identity = stateMap(doc).get(IDENTITY_KEY);
+  if (identity && isRunTerminalOrPending(doc, identity.sessionRunId)) {
+    throw new TerminalRunExecutionError(identity.sessionRunId, "design-pod-review");
+  }
+  const review = {
+    schemaVersion: "1.0",
+    reviewerDid: params.reviewerDid,
+    revisionSetDigest: params.revisionSetDigest,
+    decision: params.decision,
+    reviewedAt: params.now ?? (/* @__PURE__ */ new Date()).toISOString(),
+    assignmentDigest: params.assignmentDigest,
+    reviewRequestDigest: params.reviewRequestDigest,
+    proof: params.proof,
+    status: "current"
+  };
+  stateMap(doc).set(REVIEW_KEY, review);
+  return review;
+}
+async function importLegacyDesignPodEvidence(doc, evidence, identity, persistence) {
+  if (!evidence.legacyWorkspaceId || !["0.5", "0.6"].includes(evidence.sourceVersion) || !evidence.exportedAt) {
+    throw new Error("Legacy Design POD evidence metadata is invalid");
+  }
+  if (evidence.history.length === 0) throw new Error("Legacy Design POD evidence requires its exported hash-chained history");
+  let previousDigest = null;
+  const payloadDigests = /* @__PURE__ */ new Set();
+  for (const [index, record2] of evidence.history.entries()) {
+    if (record2.sequence !== index || record2.previousDigest !== previousDigest) {
+      throw new Error(`Legacy Design POD history chain is broken at sequence ${index}`);
+    }
+    const digest = await digestDesignPodValue({
+      sequence: record2.sequence,
+      previousDigest: record2.previousDigest,
+      eventType: record2.eventType,
+      payloadDigest: record2.payloadDigest,
+      occurredAt: record2.occurredAt
+    });
+    if (record2.digest !== digest) throw new Error(`Legacy Design POD history digest is invalid at sequence ${index}`);
+    payloadDigests.add(record2.payloadDigest);
+    previousDigest = digest;
+  }
+  if (evidence.historyDigest !== previousDigest) throw new Error("Legacy Design POD history head does not match the verified hash chain");
+  const artifacts = [];
+  for (const artifact of evidence.artifacts) {
+    const sourceDigest = await digestDesignPodValue({ controlId: artifact.controlId, content: artifact.content });
+    if (artifact.sourceDigest !== sourceDigest || !payloadDigests.has(sourceDigest)) {
+      throw new Error(`${artifact.controlId} is not bound to the verified legacy history`);
+    }
+    artifacts.push({ artifact, content: { ...artifact.content, legacySourceDigest: artifact.sourceDigest } });
+  }
+  await initializeDesignPod(doc, "design-yoma/v1", identity);
+  if (isRunTerminalOrPending(doc, identity.sessionRunId)) {
+    throw new TerminalRunExecutionError(identity.sessionRunId, "design-pod-legacy-import");
+  }
+  stateMap(doc).set(LEGACY_EVIDENCE_KEY, evidence);
+  for (const { artifact, content } of artifacts) {
+    const revision = await updateDesignPodControl(doc, {
+      controlId: artifact.controlId,
+      content,
+      actorDid: "did:ixo:legacy-import",
+      now: evidence.exportedAt,
+      importedLegacy: true
+    });
+    const persisted = await persistence.persistArtifact({
+      designProjectEntityDid: identity.designProjectEntityDid,
+      controlId: artifact.controlId,
+      revision: revision.revision,
+      digest: revision.digest,
+      content: revision.content
+    });
+    const receipt = { schemaVersion: "1.0", controlId: artifact.controlId, digest: revision.digest, ...persisted };
+    const verified = await persistence.verifyArtifactReceipt({ designProjectEntityDid: identity.designProjectEntityDid, revision, receipt });
+    if (verified.id !== receipt.id || verified.path !== receipt.path || verified.version !== receipt.version || verified.contentHash !== receipt.contentHash || verified.cid !== receipt.cid) {
+      throw new Error(`${artifact.controlId} legacy VFS import failed authoritative readback`);
+    }
+    createDesignPodArtifactReceipt(doc, { controlId: artifact.controlId, digest: revision.digest, ...verified });
+  }
+}
+
+// src/core/lib/designPod/compiler.ts
+var YOMA_OPERATIONAL_FLOW_GROUPS = [
+  {
+    id: "youth-participation",
+    title: "Youth opportunity participation and YoID linkage",
+    sourceControlIds: ["service_architecture", "ucan_rights", "flow_configuration", "governance_risk"],
+    actions: ["qi/yoma.opportunity", "qi/yoid.link"]
+  },
+  {
+    id: "work-claims",
+    title: "Work collection, claim submission, and evaluation",
+    sourceControlIds: ["service_architecture", "evidence_model", "claims_rubrics", "ucan_rights", "flow_configuration"],
+    actions: ["qi/collection.lifecycle", "qi/collection.users", "qi/claim.submit", "qi/claim.evaluate"]
+  },
+  {
+    id: "rewards-and-funding",
+    title: "Funding verification and claims-native reward readiness",
+    sourceControlIds: ["automation_feasibility", "claims_rubrics", "commercial_packaging", "flow_configuration"],
+    actions: ["qi/funding.verify"]
+  },
+  {
+    id: "youth-credentials",
+    title: "Youth credential issuance and delivery",
+    sourceControlIds: ["outcome_contract", "evidence_model", "ucan_rights", "flow_configuration"],
+    actions: ["qi/credential.issue", "qi/credential.store"]
+  },
+  {
+    id: "outcome-certification",
+    title: "Theory-of-change outcome certificate issuance",
+    sourceControlIds: ["outcome_contract", "evidence_model", "commercial_packaging", "governance_risk", "flow_configuration"],
+    actions: ["qi/outcome.certificate"]
+  }
+];
+function compileYomaOperationalFlows(manifest) {
+  if (manifest.methodId !== "design-yoma/v1") return [];
+  const declared = new Set(manifest.operationalActions);
+  const flows = YOMA_OPERATIONAL_FLOW_GROUPS.map((group) => ({
+    schemaVersion: "1.0",
+    kind: "OperationalFlowTemplate",
+    id: group.id,
+    title: group.title,
+    sourceControlIds: [...group.sourceControlIds],
+    nodes: group.actions.map((actionType, sequence) => ({ id: `${group.id}-${sequence + 1}`, sequence, actionType }))
+  }));
+  const compiledActions = flows.flatMap((flow) => flow.nodes.map((node) => node.actionType));
+  const missing = manifest.operationalActions.filter((action) => !compiledActions.includes(action));
+  const undeclared = compiledActions.filter((action) => !declared.has(action));
+  if (missing.length > 0 || undeclared.length > 0) {
+    throw new Error(
+      `Yoma operational Flow templates do not match the pinned action manifest (missing: ${missing.join(", ") || "none"}; undeclared: ${undeclared.join(", ") || "none"})`
+    );
+  }
+  return flows;
+}
+function governedInputs(state, inputs) {
+  return {
+    ...inputs,
+    designProjectEntityDid: state.identity.designProjectEntityDid,
+    flowRoomId: state.identity.flowRoomId,
+    sessionRunId: state.identity.sessionRunId,
+    methodManifestDigest: state.identity.methodManifestDigest
+  };
+}
+function flowAuthority(doc, state, authority) {
+  const root = doc.getMap("root");
+  if (state.identity.designProjectEntityDid !== authority.designProjectEntityDid || state.identity.flowOwnerDid !== authority.flowOwnerDid || state.identity.flowRoomId !== authority.flowRoomId || state.identity.sessionRunId !== authority.sessionRunId) {
+    throw new Error("The Design POD project identity does not match Portal-owned authority");
+  }
+  if (root.get("doc_id") !== authority.flowRoomId || root.get("flowOwnerDid") !== authority.flowOwnerDid) {
+    throw new Error("The collaborative Flow authority does not match the Portal-owned Flow owner and Matrix room");
+  }
+  return { flowUri: `ixo:flow:${authority.flowRoomId}`, flowOwnerDid: authority.flowOwnerDid };
+}
+async function verifyActionProof(doc, state, proof, expected, authority, verifyInvocation) {
+  if (!proof?.invocationCid || !proof.actionBlockId || !proof.inputDigest) {
+    throw new Error(`${expected.actionType} is missing its identity-bound Flow invocation proof`);
+  }
+  const expectedInputDigest = await digestDesignPodValue(expected.inputs);
+  if (proof.inputDigest !== expectedInputDigest) throw new Error(`${expected.actionType} proof is not bound to its canonical action input`);
+  const invocation = readInvocationsForRun(doc, state.identity.sessionRunId).find((candidate) => candidate.cid === proof.invocationCid);
+  if (!invocation) throw new Error(`${expected.actionType} invocation is not present in the pinned Matrix run history`);
+  const { flowUri, flowOwnerDid } = flowAuthority(doc, state, authority);
+  if (invocation.result !== "success" || invocation.invokerDid !== expected.actorDid || invocation.blockId !== proof.actionBlockId || invocation.sessionRunId !== state.identity.sessionRunId || invocation.capability?.can !== "flow/block/execute" || invocation.capability?.with !== `${flowUri}:${proof.actionBlockId}` || invocation.facts?.actionType !== expected.actionType || invocation.facts?.inputDigest !== proof.inputDigest || invocation.facts?.sessionRunId !== state.identity.sessionRunId) {
+    throw new Error(`${expected.actionType} invocation metadata does not match the reviewed Flow action`);
+  }
+  const verified = await verifyInvocation({
+    invocation,
+    expected: {
+      actorDid: expected.actorDid,
+      actionType: expected.actionType,
+      blockId: proof.actionBlockId,
+      inputDigest: proof.inputDigest,
+      flowUri,
+      flowOwnerDid,
+      designProjectEntityDid: state.identity.designProjectEntityDid,
+      sessionRunId: state.identity.sessionRunId
+    }
+  });
+  if (!verified.valid) throw new Error(`${expected.actionType} invocation failed cryptographic verification${verified.error ? `: ${verified.error}` : ""}`);
+}
+async function assertCompilable(doc, options) {
+  const manifest = readDesignPodDefinition(doc);
+  const state = readDesignPodState(doc);
+  if (!manifest || !state) throw new Error("Design POD is not initialized");
+  const registeredManifest = DESIGN_POD_METHODS[manifest.methodId];
+  if (!registeredManifest || canonicalDesignPodJson(manifest) !== canonicalDesignPodJson(registeredManifest)) {
+    throw new Error("The Design POD method definition does not match the registered Portal method");
+  }
+  if (await digestDesignPodValue(manifest) !== state.identity.methodManifestDigest) {
+    throw new Error("The current Design POD method manifest does not match its pinned digest");
+  }
+  const manifestControlIds = new Set(manifest.phases.flatMap((phase) => phase.controls));
+  const unknownControlIds = Object.keys(state.controls).filter((controlId) => !manifestControlIds.has(controlId));
+  if (unknownControlIds.length > 0) throw new Error(`Blueprint contains controls outside the pinned method manifest: ${unknownControlIds.join(", ")}`);
+  const governedChecklistIds = new Set(manifest.publicationRules.checklistItems.map((item) => item.id));
+  const unknownChecklistIds = Object.keys(state.checklistRecords).filter((itemId) => !governedChecklistIds.has(itemId));
+  if (unknownChecklistIds.length > 0) throw new Error(`Blueprint contains checklist records outside the pinned method manifest: ${unknownChecklistIds.join(", ")}`);
+  const blockers = [];
+  for (const item of manifest.publicationRules.checklistItems) {
+    const record2 = state.checklistRecords[item.id];
+    if (!record2) throw new Error(`Governed checklist item ${item.id} requires a signed disposition`);
+    if (record2.itemId !== item.id || !["resolved", "accepted_for_later", "blocking"].includes(record2.disposition)) {
+      throw new Error(`Governed checklist item ${item.id} has an invalid disposition record`);
+    }
+    const digest = await digestDesignPodValue({ itemId: record2.itemId, disposition: record2.disposition, updatedByDid: record2.updatedByDid, updatedAt: record2.updatedAt });
+    if (record2.digest !== digest) throw new Error(`Governed checklist item ${item.id} does not match its signed digest`);
+    await verifyActionProof(
+      doc,
+      state,
+      record2.proof,
+      {
+        actorDid: record2.updatedByDid,
+        actionType: "qi/blueprint.checklist-update",
+        inputs: governedInputs(state, { itemId: record2.itemId, disposition: record2.disposition })
+      },
+      options.authority,
+      options.verifyInvocation
+    );
+    if (record2.disposition === "blocking") blockers.push(item.id);
+  }
+  if (blockers.length > 0) throw new Error(`Publication blockers must be resolved before compilation: ${blockers.join(", ")}`);
+  const providerDids = /* @__PURE__ */ new Set();
+  for (const phase of manifest.phases) {
+    const commitment = state.phaseCommitments[phase.id];
+    if (commitment?.status !== "current") throw new Error(`${phase.title} requires a current provider commitment`);
+    for (const controlId of phase.controls) {
+      const revision = state.controls[controlId];
+      if (!revision || revision.status !== "current") throw new Error(`${controlId} requires a current control revision`);
+      const canonicalDigest = await digestDesignPodValue({ controlId: revision.controlId, revision: revision.revision, content: revision.content });
+      if (revision.controlId !== controlId || revision.digest !== canonicalDigest || commitment.controlDigests[controlId] !== canonicalDigest) {
+        throw new Error(`${controlId} current content is not bound to its signed phase commitment`);
+      }
+      const receipts = commitment.artifactReceipts.filter((receipt2) => receipt2.controlId === controlId && receipt2.digest === canonicalDigest);
+      if (receipts.length !== 1) throw new Error(`${controlId} requires exactly one committed VFS artifact receipt`);
+      const receipt = receipts[0];
+      const verified = await options.verifyArtifactReceipt({ designProjectEntityDid: state.identity.designProjectEntityDid, revision, receipt });
+      if (verified.id !== receipt.id || verified.path !== receipt.path || verified.version !== receipt.version || verified.contentHash !== receipt.contentHash || verified.cid !== receipt.cid) {
+        throw new Error(`${controlId} committed VFS artifact receipt failed authoritative readback`);
+      }
+    }
+    if (commitment.artifactReceipts.length !== phase.controls.length) throw new Error(`${phase.id} commitment contains unexpected VFS artifact receipts`);
+    const commitmentDigest = await digestDesignPodValue({
+      phaseId: commitment.phaseId,
+      controlDigests: commitment.controlDigests,
+      artifactReceipts: commitment.artifactReceipts,
+      committedByDid: commitment.committedByDid,
+      committedAt: commitment.committedAt
+    });
+    if (commitment.phaseId !== phase.id || commitment.digest !== commitmentDigest) throw new Error(`${phase.id} commitment does not match its governed digest`);
+    providerDids.add(commitment.committedByDid);
+    await verifyActionProof(
+      doc,
+      state,
+      commitment.proof,
+      {
+        actorDid: commitment.committedByDid,
+        actionType: "qi/blueprint.phase-commit",
+        inputs: governedInputs(state, { phase: phase.id, decision: commitment.decision, expectedControlDigests: commitment.controlDigests })
+      },
+      options.authority,
+      options.verifyInvocation
+    );
+  }
+  if (state.review?.status !== "current" || state.review.decision !== "approved") {
+    throw new Error("An identity-bound independent whole-blueprint approval is required before compilation");
+  }
+  const assignment = state.reviewAssignment;
+  const request = state.reviewRequest;
+  if (!assignment || assignment.digest !== state.review.assignmentDigest || !sameDesignPodActor(assignment.reviewerDid, state.review.reviewerDid)) {
+    const reason = !assignment ? "no reviewer assignment on the document" : assignment.digest !== state.review.assignmentDigest ? `assignment digest ${assignment.digest} != review-bound ${state.review.assignmentDigest}` : `assignment reviewer ${assignment.reviewerDid} != review reviewer ${state.review.reviewerDid}`;
+    throw new Error(`The independent review is not bound to the current reviewer assignment (${reason})`);
+  }
+  if (!request || request.status !== "responded" || request.digest !== state.review.reviewRequestDigest || request.revisionSetDigest !== state.review.revisionSetDigest) {
+    const reason = !request ? "no review request on the document" : request.status !== "responded" ? `request status is ${request.status}` : request.digest !== state.review.reviewRequestDigest ? `request digest ${request.digest} != review-bound ${state.review.reviewRequestDigest}` : `request revision set ${request.revisionSetDigest} != review-bound ${state.review.revisionSetDigest}`;
+    throw new Error(`The independent review is not bound to the current review request (${reason})`);
+  }
+  if (await digestDesignPodValue({ reviewerDid: assignment.reviewerDid, assignedByDid: assignment.assignedByDid, assignedAt: assignment.assignedAt }) !== assignment.digest) {
+    throw new Error("The reviewer assignment digest does not match its governed record");
+  }
+  if (await digestDesignPodValue({ revisionSetDigest: request.revisionSetDigest, submittedByDid: request.submittedByDid, submittedAt: request.submittedAt }) !== request.digest) {
+    throw new Error("The review request digest does not match its governed record");
+  }
+  const isCommittedProvider = (did) => [...providerDids].some((provider) => sameDesignPodActor(provider, did));
+  if (!isCommittedProvider(assignment.assignedByDid) || !isCommittedProvider(request.submittedByDid)) {
+    throw new Error("Reviewer assignment and review submission must be authorized by a committed provider");
+  }
+  if (isCommittedProvider(state.review.reviewerDid)) throw new Error("The independent reviewer cannot be a provider who committed this blueprint");
+  await verifyActionProof(
+    doc,
+    state,
+    assignment.proof,
+    { actorDid: assignment.assignedByDid, actionType: "qi/blueprint.reviewer-assign", inputs: governedInputs(state, { reviewerDid: assignment.reviewerDid }) },
+    options.authority,
+    options.verifyInvocation
+  );
+  await verifyActionProof(
+    doc,
+    state,
+    request.proof,
+    { actorDid: request.submittedByDid, actionType: "qi/blueprint.review-submit", inputs: governedInputs(state, {}) },
+    options.authority,
+    options.verifyInvocation
+  );
+  await verifyActionProof(
+    doc,
+    state,
+    state.review.proof,
+    {
+      actorDid: state.review.reviewerDid,
+      actionType: "qi/blueprint.review-respond",
+      inputs: governedInputs(state, {
+        revisionSetDigest: state.review.revisionSetDigest,
+        decision: state.review.decision,
+        assignmentDigest: state.review.assignmentDigest,
+        reviewRequestDigest: state.review.reviewRequestDigest
+      })
+    },
+    options.authority,
+    options.verifyInvocation
+  );
+  return { manifest, state };
+}
+async function compileDesignPodRelease(doc, options) {
+  const { manifest, state } = await assertCompilable(doc, options);
+  const committedPhases = Object.entries(state.phaseCommitments).filter(([, commitment]) => commitment?.status === "current").sort(([left], [right]) => left.localeCompare(right));
+  const checklistRecords = Object.entries(state.checklistRecords).sort(([left], [right]) => left.localeCompare(right));
+  const revisionSetDigest = await digestDesignPodValue({ phases: committedPhases, checklistRecords });
+  if (state.review?.revisionSetDigest !== revisionSetDigest) {
+    throw new Error("The independent review is not bound to the current committed revision set");
+  }
+  const controlRevisions = Object.fromEntries(manifest.phases.flatMap((phase) => phase.controls.map((controlId) => [controlId, state.controls[controlId]])));
+  const blueprint = {
+    schemaVersion: "1.0",
+    methodManifest: manifest,
+    methodManifestDigest: state.identity.methodManifestDigest,
+    designProjectEntityDid: state.identity.designProjectEntityDid,
+    flowRoomId: state.identity.flowRoomId,
+    controlRevisions,
+    phaseCommitments: state.phaseCommitments,
+    checklistRecords: state.checklistRecords,
+    review: state.review,
+    revisionSetDigest
+  };
+  const skillManifest = {
+    schemaVersion: "1.0",
+    methodId: manifest.methodId,
+    controls: Object.values(manifest.controls).map(({ id, skill, schema, dependencies }) => ({ id, skill, schema, dependencies }))
+  };
+  const operationalFlows = compileYomaOperationalFlows(manifest);
+  const operationalApp = {
+    schemaVersion: "1.0",
+    kind: manifest.methodId === "design-yoma/v1" ? "YomaDeed" : "ProfessionalServicePOD",
+    actions: manifest.operationalActions,
+    flowFiles: operationalFlows.map((flow) => `/apps/flows/${flow.id}.json`),
+    designFlowRoomId: state.identity.flowRoomId
+  };
+  const domain = [
+    "---",
+    `id: ${state.identity.designProjectEntityDid}`,
+    `kind: ${manifest.methodId === "design-yoma/v1" ? "YomaDeed" : "ServicePOD"}`,
+    `designPodMethod: ${manifest.methodId}`,
+    `revisionSetDigest: ${revisionSetDigest}`,
+    "---",
+    "",
+    `# ${manifest.title}`,
+    "",
+    "This private domain package was compiled from the independently reviewed Portal Design POD Flow.",
+    ""
+  ].join("\n");
+  const releaseDigest = await digestDesignPodValue({ blueprint, skillManifest, operationalApp, operationalFlows, domain });
+  const packageRoot = `/pod-blueprints/${releaseDigest}`;
+  return {
+    schemaVersion: "1.0",
+    releaseDigest,
+    revisionSetDigest,
+    packageRoot,
+    files: [
+      { relativePath: "/blueprint.json", mediaType: "application/json", content: canonicalDesignPodJson(blueprint) },
+      { relativePath: "/.skills/design-yoma.json", mediaType: "application/json", content: canonicalDesignPodJson(skillManifest) },
+      { relativePath: "/apps/yoma-deed.json", mediaType: "application/json", content: canonicalDesignPodJson(operationalApp) },
+      ...operationalFlows.map((flow) => ({
+        relativePath: `/apps/flows/${flow.id}.json`,
+        mediaType: "application/json",
+        content: canonicalDesignPodJson(flow)
+      })),
+      // domain.md is intentionally last. The host persists and verifies every
+      // private dependency before making this package discoverable.
+      { relativePath: "/.domain/domain.md", mediaType: "text/markdown", content: domain }
+    ]
+  };
+}
+
+// src/core/lib/designPod/publication.ts
+function record(value, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${name} is missing or invalid`);
+  return value;
+}
+function string(value, name) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${name} is missing or invalid`);
+  return value;
+}
+var LINKED_RESOURCE_FIELDS = ["id", "type", "description", "serviceEndpoint", "proof", "mediaType", "encrypted", "right"];
+async function verifyDesignPodPublishedRun(params) {
+  try {
+    const state = readDesignPodState(params.yDoc);
+    if (!state || state.identity.sessionRunId !== params.runId) throw new Error("The run is not the pinned Design POD session");
+    if (params.flowUri !== `ixo:flow:${state.identity.flowRoomId}`) throw new Error("The Flow URI does not match the pinned Matrix room");
+    const root = params.yDoc.getMap("root");
+    if (root.get("doc_id") !== state.identity.flowRoomId || root.get("flowOwnerDid") !== state.identity.flowOwnerDid) {
+      throw new Error("The collaborative Flow authority does not match the pinned Portal authority");
+    }
+    const release = state.release;
+    if (!release?.digest || release.status !== "published") throw new Error("The current Design POD release is not published");
+    const receipt = record(release.publicationReceipt, "publicationReceipt");
+    if (receipt.releaseDigest !== release.digest) throw new Error("The publication receipt is not bound to the current release");
+    const linkedResource = record(receipt.linkedResource, "publicationReceipt.linkedResource");
+    const resourceId = string(receipt.resourceId, "publicationReceipt.resourceId");
+    if (linkedResource.id !== resourceId) throw new Error("The publication receipt resource identity is inconsistent");
+    const publication = record(params.yDoc.getMap("designPodState").get(`publication:${release.digest}`), "authenticated publication record");
+    for (const field of ["releaseDigest", "resourceId", "domainCid"]) {
+      if (publication[field] !== receipt[field]) throw new Error(`The authenticated publication ${field} does not match its receipt`);
+    }
+    if (canonicalDesignPodJson(publication.linkedResource) !== canonicalDesignPodJson(linkedResource)) {
+      throw new Error("The authenticated publication linked resource does not match its receipt");
+    }
+    const invocationCid = string(publication.reconciledByInvocationCid, "publication.reconciledByInvocationCid");
+    const invocation = readInvocationsForRun(params.yDoc, params.runId).find((candidate) => candidate.cid === invocationCid);
+    if (!invocation) throw new Error("The signed publication invocation is missing from the pinned run history");
+    const blockId = string(invocation.blockId, "publication invocation blockId");
+    const inputDigest = await digestDesignPodValue({
+      releaseDigest: release.digest,
+      designProjectEntityDid: state.identity.designProjectEntityDid,
+      flowRoomId: state.identity.flowRoomId,
+      sessionRunId: state.identity.sessionRunId,
+      methodManifestDigest: state.identity.methodManifestDigest
+    });
+    if (invocation.result !== "success" || invocation.sessionRunId !== params.runId || invocation.capability?.can !== "flow/block/execute" || invocation.capability?.with !== `${params.flowUri}:${blockId}` || invocation.facts?.actionType !== "qi/blueprint.publish" || invocation.facts?.inputDigest !== inputDigest || invocation.facts?.sessionRunId !== params.runId) {
+      throw new Error("The publication record is not bound to a successful canonical publish invocation");
+    }
+    const verifiedInvocation = await params.service.verifyInvocation({
+      invocation,
+      expected: {
+        actorDid: invocation.invokerDid,
+        actionType: "qi/blueprint.publish",
+        blockId,
+        inputDigest,
+        flowUri: params.flowUri,
+        flowOwnerDid: state.identity.flowOwnerDid,
+        designProjectEntityDid: state.identity.designProjectEntityDid,
+        sessionRunId: params.runId
+      }
+    });
+    if (!verifiedInvocation.valid)
+      throw new Error(`The publication invocation failed cryptographic verification${verifiedInvocation.error ? `: ${verifiedInvocation.error}` : ""}`);
+    const typedLinkedResource = Object.fromEntries(LINKED_RESOURCE_FIELDS.map((field) => [field, string(linkedResource[field], `linkedResource.${field}`)]));
+    const authoritative = await params.service.verifyPublicationReceipt({
+      designProjectEntityDid: state.identity.designProjectEntityDid,
+      releaseDigest: release.digest,
+      linkedResource: typedLinkedResource
+    });
+    if (authoritative.status !== "published" || !authoritative.linkedResource) throw new Error("IXO has not authoritatively retained the published linked resource");
+    if (canonicalDesignPodJson(authoritative.linkedResource) !== canonicalDesignPodJson(typedLinkedResource)) {
+      throw new Error("IXO authoritative linked-resource readback does not match the publication receipt");
+    }
+    return { valid: true };
+  } catch (error) {
+    return { valid: false, error: error instanceof Error ? error.message : "Design POD publication verification failed" };
+  }
+}
+
+// src/core/lib/designPod/template.ts
+function createDesignPodPortalJourneyPlan(methodId) {
+  const manifest = DESIGN_POD_METHODS[methodId];
+  return {
+    kind: "qi.flow.base-ucan",
+    version: "1.0",
+    flowId: DESIGN_POD_TEMPLATE_ID,
+    title: manifest.title,
+    goal: "Design, independently review, dry-run, and deploy one evidence-backed POD Blueprint.",
+    capabilities: [
+      ...manifest.phases.map((phase) => ({
+        id: `design-pod-${phase.id}-commit`,
+        can: "blueprint/phase-commit",
+        with: `ixo:flow:${DESIGN_POD_TEMPLATE_ID}:${phase.id}`,
+        title: phase.title,
+        description: phase.description,
+        phase: phase.id,
+        nb: { phase: phase.id, decision: "Yes, continue" }
+      })),
+      {
+        id: "design-pod-checklist-update",
+        can: "blueprint/checklist-update",
+        with: `ixo:flow:${DESIGN_POD_TEMPLATE_ID}:publication-checklist`,
+        title: "Update publication checklist",
+        description: "Record one signed governed checklist disposition before review and publication.",
+        phase: "validation",
+        nb: {}
+      },
+      {
+        id: "design-pod-reviewer-assign",
+        can: "blueprint/reviewer-assign",
+        with: `ixo:flow:${DESIGN_POD_TEMPLATE_ID}:reviewer-assignment`,
+        title: "Assign independent reviewer",
+        description: "Nominate the IXO DID that will independently review the exact committed blueprint.",
+        phase: "deployment",
+        nb: {}
+      },
+      {
+        id: "design-pod-review-submit",
+        can: "blueprint/review-submit",
+        with: `ixo:flow:${DESIGN_POD_TEMPLATE_ID}:review-submission`,
+        title: "Submit blueprint for review",
+        description: "Bind the five current commitments into one immutable review request.",
+        phase: "deployment",
+        nb: {}
+      },
+      {
+        id: "design-pod-review-respond",
+        can: "blueprint/review-respond",
+        with: `ixo:flow:${DESIGN_POD_TEMPLATE_ID}:review-response`,
+        title: "Record independent review",
+        description: "Approve the submitted revision set or require governed changes.",
+        phase: "deployment",
+        nb: {}
+      },
+      {
+        id: "design-pod-release-compile",
+        can: "blueprint/release-compile",
+        with: `ixo:flow:${DESIGN_POD_TEMPLATE_ID}:release-compilation`,
+        title: "Compile reviewed blueprint",
+        description: "Compile the exact approved revision set into the deterministic private VFS package.",
+        phase: "deployment",
+        nb: {}
+      },
+      {
+        id: "design-pod-publish",
+        can: "blueprint/publish",
+        with: `ixo:flow:${DESIGN_POD_TEMPLATE_ID}:publication`,
+        title: "Publish blueprint",
+        description: "Persist the package through the entity VFS and publish its verified IXO linked resource.",
+        phase: "deployment",
+        nb: {}
+      },
+      {
+        id: "design-pod-protocol-mint",
+        can: "blueprint/protocol-mint",
+        with: `ixo:flow:${DESIGN_POD_TEMPLATE_ID}:protocol-mint`,
+        title: "Mint protocol",
+        description: "Create the protocol entity from the published release and unpack its package so instances are ready to run.",
+        phase: "deployment",
+        nb: {}
+      }
+    ]
+  };
+}
+var PROFESSIONAL_SERVICE_DESIGN_POD_PLAN_V1 = createDesignPodPortalJourneyPlan("professional-service/v1");
+var YOMA_DESIGN_POD_PLAN_V1 = createDesignPodPortalJourneyPlan("design-yoma/v1");
+
+// src/core/lib/designPod/operationalPlan.ts
+function parseDesignPodOperationalFlow(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const candidate = raw;
+  if (candidate.kind !== "OperationalFlowTemplate" || typeof candidate.id !== "string" || !Array.isArray(candidate.nodes)) return void 0;
+  const nodes = candidate.nodes.filter((node) => !!node && typeof node.id === "string" && typeof node.actionType === "string").map((node, index) => ({
+    id: node.id,
+    sequence: typeof node.sequence === "number" ? node.sequence : index,
+    actionType: node.actionType,
+    ...node.inputs && typeof node.inputs === "object" ? { inputs: node.inputs } : {}
+  })).sort((left, right) => left.sequence - right.sequence);
+  if (nodes.length === 0) return void 0;
+  return {
+    schemaVersion: "1.0",
+    kind: "OperationalFlowTemplate",
+    id: candidate.id,
+    title: typeof candidate.title === "string" && candidate.title.trim() ? candidate.title : candidate.id,
+    sourceControlIds: Array.isArray(candidate.sourceControlIds) ? candidate.sourceControlIds.filter((id) => typeof id === "string") : [],
+    nodes
+  };
+}
+function createDesignPodOperationalFlowPlan(flow) {
+  const capabilities = flow.nodes.map((node) => {
+    const can = getAction(node.actionType)?.can;
+    if (!can) throw new Error(`Operational Flow "${flow.id}" references ${node.actionType}, which is not a registered action with a UCAN ability`);
+    return {
+      id: node.id,
+      can,
+      with: `ixo:flow:${flow.id}:${node.id}`,
+      title: node.actionType,
+      description: `Operational step ${node.sequence + 1} of ${flow.title}.`,
+      nb: node.inputs ?? {}
+    };
+  });
+  return {
+    kind: "qi.flow.base-ucan",
+    version: "1.0",
+    // Left empty on purpose: setupFlowFromBaseUcan fills it from the room it is
+    // instantiated into, which is what makes each clone its own flow.
+    flowId: "",
+    title: flow.title,
+    goal: `Run ${flow.title}.`,
+    capabilities
+  };
+}
+
+// src/core/lib/designPod/prompts.ts
+function buildDesignPodPhasePrompt(definition, state, phase) {
+  const controls = phase.controls.map((id) => {
+    const control = definition.controls[id];
+    const status = state.controls[id]?.status ?? "missing";
+    return `- ${id} (${control.title}; schema ${control.schema}; skill ${control.skill}; depends on ${control.dependencies.join(", ") || "nothing"}) \u2014 ${status}`;
+  }).join("\n");
+  return [
+    `I am designing a ${definition.title} in the open Design POD Flow. Help me complete the "${phase.title}" phase: ${phase.description}`,
+    `Controls in this phase:
+${controls}`,
+    "First call get_design_pod_state to read the current state. It is the complete and only source of truth: the schema and skill names above are opaque identifiers, there is no external registry of control field definitions, so never search memory, skills or any knowledge base for them \u2014 design clear, named fields yourself from each control's title and description. Then work through the missing or stale controls: ask me one focused question at a time, and once you have enough, call propose_design_pod_patch with a complete typed content object for that control (include baseDigest when the control already exists). When you already have enough context for several controls \u2014 or when I explicitly ask you to cover multiple controls at once \u2014 call propose_design_pod_patch multiple times in the same turn, once per control; the proposals queue up in the Design POD panel and I accept each one separately. Do not ask me to paste JSON, and do not wait for one proposal to be accepted before proposing the next."
+  ].join("\n\n");
+}
+
+export {
+  DESIGN_POD_TEMPLATE_ID,
+  DESIGN_POD_PHASE_IDS,
+  DESIGN_POD_CONTROL_IDS,
+  PROFESSIONAL_SERVICE_METHOD_V1,
+  DESIGN_YOMA_METHOD_V1,
+  DESIGN_POD_METHODS,
+  INVOCATIONS_MAP_KEY,
+  readInvocationsForRun,
+  canonicalDesignPodJson,
+  digestDesignPodValue,
+  DESIGN_POD_DEFINITION_MAP_KEY,
+  DESIGN_POD_STATE_MAP_KEY,
+  sameDesignPodActor,
+  seedDesignPodMethodDefinition,
+  initializeDesignPod,
+  readDesignPodDefinition,
+  readDesignPodState,
+  updateDesignPodControl,
+  createDesignPodArtifactReceipt,
+  commitDesignPodPhase,
+  computeDesignPodRevisionSetDigest,
+  markDesignPodReviewed,
+  importLegacyDesignPodEvidence,
+  compileDesignPodRelease,
+  verifyDesignPodPublishedRun,
+  createDesignPodPortalJourneyPlan,
+  PROFESSIONAL_SERVICE_DESIGN_POD_PLAN_V1,
+  YOMA_DESIGN_POD_PLAN_V1,
+  parseDesignPodOperationalFlow,
+  createDesignPodOperationalFlowPlan,
+  buildDesignPodPhasePrompt
+};
+//# sourceMappingURL=chunk-JIDTNKKL.js.map