@ixo/editor 6.32.1 → 6.34.0

package/dist/chunk-3TUYY4HK.js

@@ -0,0 +1,20 @@
+// src/mantine/blocks/action/actionTypes/oraclePrompt/types.ts
+function parseOraclePromptInputs(json) {
+  try {
+    const parsed = typeof json === "string" ? JSON.parse(json) : json;
+    return {
+      prompt: typeof parsed?.prompt === "string" ? parsed.prompt : ""
+    };
+  } catch {
+    return { prompt: "" };
+  }
+}
+function serializeOraclePromptInputs(inputs) {
+  return JSON.stringify({ prompt: inputs.prompt });
+}
+
+export {
+  parseOraclePromptInputs,
+  serializeOraclePromptInputs
+};
+//# sourceMappingURL=chunk-3TUYY4HK.js.map

package/dist/chunk-3TUYY4HK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mantine/blocks/action/actionTypes/oraclePrompt/types.ts"],"sourcesContent":["export interface OraclePromptInputs {\n  prompt: string;\n}\n\nexport function parseOraclePromptInputs(json: string): OraclePromptInputs {\n  try {\n    const parsed = typeof json === 'string' ? JSON.parse(json) : json;\n    return {\n      prompt: typeof parsed?.prompt === 'string' ? parsed.prompt : '',\n    };\n  } catch {\n    return { prompt: '' };\n  }\n}\n\nexport function serializeOraclePromptInputs(inputs: OraclePromptInputs): string {\n  return JSON.stringify({ prompt: inputs.prompt });\n}\n"],"mappings":";AAIO,SAAS,wBAAwB,MAAkC;AACxE,MAAI;AACF,UAAM,SAAS,OAAO,SAAS,WAAW,KAAK,MAAM,IAAI,IAAI;AAC7D,WAAO;AAAA,MACL,QAAQ,OAAO,QAAQ,WAAW,WAAW,OAAO,SAAS;AAAA,IAC/D;AAAA,EACF,QAAQ;AACN,WAAO,EAAE,QAAQ,GAAG;AAAA,EACtB;AACF;AAEO,SAAS,4BAA4B,QAAoC;AAC9E,SAAO,KAAK,UAAU,EAAE,QAAQ,OAAO,OAAO,CAAC;AACjD;","names":[]}

package/dist/chunk-3XSLBJYI.js

@@ -0,0 +1,554 @@
+import {
+  addFlowNode,
+  auditFlowProjections,
+  readFlowDocument,
+  removeFlowNode,
+  reorderFlowNodes,
+  repairFlowProjections,
+  setBlockProps
+} from "./chunk-3O42FYT3.js";
+import {
+  readFlowConnections
+} from "./chunk-F4PTFXZH.js";
+import {
+  canonicalizeJson,
+  deepFreezeJson,
+  digestCanonicalJson,
+  signFlowDefinitionRevision
+} from "./chunk-RRYBAE6E.js";
+import {
+  isYMapLike
+} from "./chunk-NCSGIRRQ.js";
+
+// src/core/lib/flowCompiler/draftRepository.ts
+import * as Y from "yjs";
+var FlowDraftCommandError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "FlowDraftCommandError";
+  }
+};
+var COMMANDS_MAP = "qi.flow.draftCommands";
+var DRAFT_CONTROL_MAP = "qi.flow.draftControl";
+var LEGACY_COMMAND_REVISION_KEY = "legacyCommandRevision";
+var RESERVED_META_KEYS = /* @__PURE__ */ new Set(["draftRevision", "draftSchemaVersion", "draftUpdatedAt"]);
+function currentRevision(yDoc) {
+  const meta = yDoc.getMap("qi.flow.meta");
+  if (meta.get("draftSchemaVersion") === 1) return Number(meta.get("draftRevision") ?? 0);
+  return Number(yDoc.getMap(DRAFT_CONTROL_MAP).get(LEGACY_COMMAND_REVISION_KEY) ?? 0);
+}
+function fingerprint(command) {
+  return canonicalizeJson(command);
+}
+function advanceCommandRevision(yDoc) {
+  const meta = yDoc.getMap("qi.flow.meta");
+  const next = currentRevision(yDoc) + 1;
+  if (meta.get("draftSchemaVersion") !== 1) {
+    yDoc.getMap(DRAFT_CONTROL_MAP).set(LEGACY_COMMAND_REVISION_KEY, next);
+    return next;
+  }
+  meta.set("draftRevision", next);
+  meta.set("draftUpdatedAt", (/* @__PURE__ */ new Date()).toISOString());
+  return next;
+}
+function setMeta(yDoc, values) {
+  const meta = yDoc.getMap("qi.flow.meta");
+  for (const [key, value] of Object.entries(values)) {
+    if (value === null) meta.delete(key);
+    else meta.set(key, value);
+  }
+  advanceCommandRevision(yDoc);
+}
+function createYjsFlowDefinitionDraftRepository(yDoc) {
+  const repository = {
+    read: () => ({ revision: currentRevision(yDoc), document: readFlowDocument(yDoc) }),
+    apply: (command) => {
+      if (command.kind !== "qi.flow.draft-command" || command.schemaVersion !== "1.0" || !command.commandId || !command.actorDid) {
+        throw new FlowDraftCommandError("INVALID_COMMAND", "A versioned command id and actor are required");
+      }
+      if (command.operation.kind === "set-meta") {
+        const reservedKeys = Object.keys(command.operation.values).filter((key) => RESERVED_META_KEYS.has(key));
+        if (reservedKeys.length > 0) {
+          throw new FlowDraftCommandError("INVALID_COMMAND", `Flow metadata keys are reserved for draft bookkeeping: ${reservedKeys.sort().join(", ")}`, {
+            reservedKeys: reservedKeys.sort()
+          });
+        }
+      }
+      const commands = yDoc.getMap(COMMANDS_MAP);
+      const commandFingerprint = fingerprint(command);
+      const existing = commands.get(command.commandId);
+      if (existing) {
+        if (existing.fingerprint !== commandFingerprint) {
+          throw new FlowDraftCommandError("IDEMPOTENCY_CONFLICT", `Draft command ${command.commandId} was reused with different content`);
+        }
+        return { ...existing.result, outcome: "duplicate" };
+      }
+      const beforeRevision = currentRevision(yDoc);
+      if (command.expectedRevision !== beforeRevision) {
+        throw new FlowDraftCommandError("REVISION_CONFLICT", `Expected draft revision ${command.expectedRevision}, found ${beforeRevision}`);
+      }
+      let nodeId;
+      let blockId;
+      yDoc.transact(() => {
+        const operation = command.operation;
+        if (operation.kind === "add-step") {
+          const added = addFlowNode(yDoc, {
+            type: operation.actionType,
+            nodeId: operation.nodeId,
+            blockId: operation.blockId,
+            afterNodeId: operation.afterNodeId,
+            title: operation.title,
+            props: operation.props
+          });
+          if (!added) throw new FlowDraftCommandError("INVALID_COMMAND", "Action type or requested Flow step identity is unavailable");
+          nodeId = added.nodeId;
+          blockId = added.blockId;
+        } else if (operation.kind === "update-step-props") {
+          if (!setBlockProps(yDoc, operation.blockId, operation.props)) {
+            throw new FlowDraftCommandError("INVALID_COMMAND", `Unknown Flow block: ${operation.blockId}`);
+          }
+          blockId = operation.blockId;
+        } else if (operation.kind === "remove-step") {
+          const removed = removeFlowNode(yDoc, operation.nodeId);
+          if (!removed.ok) {
+            throw new FlowDraftCommandError("REFERENCED_STEP", `Flow step ${operation.nodeId} is still referenced`, { referencedBy: removed.referencedBy });
+          }
+          nodeId = operation.nodeId;
+        } else if (operation.kind === "reorder-steps") {
+          if (!reorderFlowNodes(yDoc, operation.order)) throw new FlowDraftCommandError("INVALID_COMMAND", "Step order must be a complete permutation");
+        } else {
+          setMeta(yDoc, operation.values);
+        }
+        const afterOperationRevision = currentRevision(yDoc);
+        if (afterOperationRevision === beforeRevision) advanceCommandRevision(yDoc);
+        const result = {
+          outcome: "applied",
+          commandId: command.commandId,
+          revision: currentRevision(yDoc),
+          ...nodeId ? { nodeId } : {},
+          ...blockId ? { blockId } : {}
+        };
+        commands.set(command.commandId, { fingerprint: commandFingerprint, result });
+      });
+      const stored = commands.get(command.commandId);
+      if (!stored) throw new FlowDraftCommandError("INVALID_COMMAND", "Draft command did not commit");
+      return { ...stored.result };
+    },
+    applyBatch: (commands) => {
+      if (commands.length === 0) return [];
+      const beforeVector = Y.encodeStateVector(yDoc);
+      const stagedDoc = new Y.Doc();
+      try {
+        Y.applyUpdate(stagedDoc, Y.encodeStateAsUpdate(yDoc));
+        const stagedRepository = createYjsFlowDefinitionDraftRepository(stagedDoc);
+        const results = commands.map((command) => stagedRepository.apply(command));
+        const update = Y.encodeStateAsUpdate(stagedDoc, beforeVector);
+        yDoc.transact(() => Y.applyUpdate(yDoc, update), "flow-draft-command-batch");
+        return results;
+      } finally {
+        stagedDoc.destroy();
+      }
+    },
+    auditProjections: () => auditFlowProjections(yDoc),
+    repairProjections: () => repairFlowProjections(yDoc)
+  };
+  return repository;
+}
+
+// src/core/lib/flowCompiler/participants.ts
+import * as Y2 from "yjs";
+var FLOW_PARTICIPANTS_MAP_KEY = "qi.flow.participants";
+function readFlowParticipants(yDoc) {
+  const participants = [];
+  getParticipantsMap(yDoc).forEach((value) => {
+    const participant = toParticipant(value);
+    if (participant) participants.push(participant);
+  });
+  return participants.sort((a, b) => {
+    const aAt = a.addedAt ?? Number.POSITIVE_INFINITY;
+    const bAt = b.addedAt ?? Number.POSITIVE_INFINITY;
+    if (aAt !== bAt) return aAt < bAt ? -1 : 1;
+    return compareUserIds(a.userId, b.userId);
+  });
+}
+function upsertFlowParticipant(yDoc, participant) {
+  const userId = participant.userId;
+  if (typeof userId !== "string" || userId.length === 0) return;
+  yDoc.transact(() => {
+    const entry = ensureEntry(getParticipantsMap(yDoc), userId);
+    entry.set("userId", userId);
+    entry.set("powerLevel", toPowerLevel(participant.powerLevel));
+    mergeOptionalString(entry, "displayName", participant.displayName);
+    mergeOptionalString(entry, "avatarUrl", participant.avatarUrl);
+    mergeRequirements(entry, participant.requires);
+    mergeSteps(entry, participant.steps);
+    const addedAt = toTimestamp(entry.get("addedAt")) ?? toTimestamp(participant.addedAt);
+    if (addedAt !== void 0) entry.set("addedAt", addedAt);
+  });
+}
+function removeFlowParticipant(yDoc, userId) {
+  yDoc.transact(() => {
+    const map = getParticipantsMap(yDoc);
+    if (map.has(userId)) map.delete(userId);
+  });
+}
+function setFlowParticipantPowerLevel(yDoc, userId, powerLevel) {
+  yDoc.transact(() => {
+    const entry = getParticipantsMap(yDoc).get(userId);
+    if (isYMapLike(entry)) entry.set("powerLevel", toPowerLevel(powerLevel));
+  });
+}
+function setFlowParticipantRequirements(yDoc, userId, requires) {
+  yDoc.transact(() => {
+    const entry = getParticipantsMap(yDoc).get(userId);
+    if (isYMapLike(entry)) mergeRequirements(entry, requires ?? []);
+  });
+}
+function setFlowParticipantSteps(yDoc, userId, steps) {
+  yDoc.transact(() => {
+    const entry = getParticipantsMap(yDoc).get(userId);
+    if (isYMapLike(entry)) mergeSteps(entry, steps ?? []);
+  });
+}
+function getParticipantsMap(yDoc) {
+  return yDoc.getMap(FLOW_PARTICIPANTS_MAP_KEY);
+}
+function ensureEntry(map, userId) {
+  const existing = map.get(userId);
+  if (isYMapLike(existing)) return existing;
+  const created = new Y2.Map();
+  map.set(userId, created);
+  return created;
+}
+function toParticipant(value) {
+  if (!isYMapLike(value)) return void 0;
+  const userId = value.get("userId");
+  if (typeof userId !== "string" || userId.length === 0) return void 0;
+  const participant = { userId, powerLevel: toPowerLevel(value.get("powerLevel")) };
+  const displayName = toNonEmptyString(value.get("displayName"));
+  if (displayName !== void 0) participant.displayName = displayName;
+  const avatarUrl = toNonEmptyString(value.get("avatarUrl"));
+  if (avatarUrl !== void 0) participant.avatarUrl = avatarUrl;
+  const requires = toRequirements(value.get("requires"));
+  if (requires.length > 0) participant.requires = requires;
+  const steps = toRequirements(value.get("steps"));
+  if (steps.length > 0) participant.steps = steps;
+  const addedAt = toTimestamp(value.get("addedAt"));
+  if (addedAt !== void 0) participant.addedAt = addedAt;
+  return participant;
+}
+function toPowerLevel(value) {
+  const numeric = typeof value === "string" ? Number(value) : value;
+  return typeof numeric === "number" && Number.isFinite(numeric) ? Math.trunc(numeric) : 0;
+}
+function toTimestamp(value) {
+  const numeric = typeof value === "string" ? Number(value) : value;
+  return typeof numeric === "number" && Number.isFinite(numeric) ? Math.trunc(numeric) : void 0;
+}
+function toNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function toRequirements(value) {
+  if (!Array.isArray(value)) return [];
+  const requires = [];
+  for (const entry of value) {
+    if (typeof entry !== "string" || entry.length === 0) continue;
+    if (!requires.includes(entry)) requires.push(entry);
+  }
+  return requires;
+}
+function mergeOptionalString(entry, key, value) {
+  if (value === void 0) return;
+  if (value.length === 0) entry.delete(key);
+  else entry.set(key, value);
+}
+function mergeRequirements(entry, value) {
+  if (value === void 0) return;
+  const requires = toRequirements(value);
+  if (requires.length === 0) entry.delete("requires");
+  else entry.set("requires", requires);
+}
+function mergeSteps(entry, value) {
+  if (value === void 0) return;
+  const steps = toRequirements(value);
+  if (steps.length === 0) entry.delete("steps");
+  else entry.set("steps", steps);
+}
+function compareUserIds(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+
+// src/core/lib/flowCompiler/publication.ts
+var FlowDefinitionPublicationError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "FlowDefinitionPublicationError";
+  }
+};
+function parseObject(value, field) {
+  if (!value) return {};
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+  } catch (error) {
+    throw new FlowDefinitionPublicationError("INVALID_CONFIGURATION", `Flow step ${field} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  throw new FlowDefinitionPublicationError("INVALID_CONFIGURATION", `Flow step ${field} must be a JSON object`);
+}
+function parseConditions(value) {
+  if (!value) return [];
+  const parsed = parseObject(value, "conditions");
+  if (!Array.isArray(parsed.conditions)) throw new FlowDefinitionPublicationError("INVALID_CONFIGURATION", "Flow step conditions must contain an array");
+  if (parsed.conditions.some((condition) => !condition || typeof condition !== "object" || Array.isArray(condition))) {
+    throw new FlowDefinitionPublicationError("INVALID_CONFIGURATION", "Every Flow step condition must be a JSON object");
+  }
+  return parsed.conditions;
+}
+function participantRequirement(participant) {
+  return {
+    userId: participant.userId,
+    powerLevel: participant.powerLevel,
+    ...participant.displayName ? { displayName: participant.displayName } : {},
+    ...participant.avatarUrl ? { avatarUrl: participant.avatarUrl } : {},
+    ...participant.requires ? { requires: [...participant.requires] } : {},
+    ...participant.addedAt !== void 0 ? { addedAt: participant.addedAt } : {}
+  };
+}
+function connectionRequirement(connection) {
+  return {
+    toolkit: connection.toolkit,
+    ...connection.label ? { label: connection.label } : {},
+    ...connection.optional ? { optional: true } : {},
+    ...connection.agent !== void 0 ? { agent: connection.agent } : {},
+    requires: [...connection.requires],
+    ...connection.addedAt !== void 0 ? { addedAt: connection.addedAt } : {}
+  };
+}
+function parseTrigger(value, triggerMode) {
+  let trigger = {};
+  if (value) {
+    try {
+      const parsed = JSON.parse(value);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new FlowDefinitionPublicationError("INVALID_TRIGGER", "Flow trigger must be a JSON object");
+      }
+      trigger = parsed;
+    } catch (error) {
+      if (error instanceof FlowDefinitionPublicationError) throw error;
+      throw new FlowDefinitionPublicationError("INVALID_TRIGGER", "Flow trigger is not valid JSON");
+    }
+  }
+  const type = String(trigger.type ?? triggerMode ?? "manual");
+  if (type === "manual") return { kind: "manual" };
+  if (type === "flow.start") return { kind: "flow.start" };
+  if (type === "topic.request") {
+    if (typeof trigger.requestKind !== "string" || trigger.requestKind.trim().length === 0) {
+      throw new FlowDefinitionPublicationError("INVALID_TRIGGER", "topic.request requires requestKind");
+    }
+    return { kind: "topic.request", requestKind: trigger.requestKind };
+  }
+  if (type === "block.event") {
+    if (typeof trigger.sourceBlockId !== "string" || typeof trigger.eventName !== "string") {
+      throw new FlowDefinitionPublicationError("INVALID_TRIGGER", "block.event requires sourceBlockId and eventName");
+    }
+    return { kind: "step.event", sourceBlockId: trigger.sourceBlockId, eventName: trigger.eventName };
+  }
+  if (type === "block.event.all") {
+    if (!Array.isArray(trigger.sources)) throw new FlowDefinitionPublicationError("INVALID_TRIGGER", "block.event.all requires sources");
+    const sources = trigger.sources.map((source) => {
+      if (!source || typeof source !== "object") throw new FlowDefinitionPublicationError("INVALID_TRIGGER", "Invalid block.event.all source");
+      const candidate = source;
+      if (typeof candidate.sourceBlockId !== "string" || typeof candidate.eventName !== "string" || typeof candidate.alias !== "string") {
+        throw new FlowDefinitionPublicationError("INVALID_TRIGGER", "Every block.event.all source requires sourceBlockId, eventName, and alias");
+      }
+      return {
+        sourceBlockId: candidate.sourceBlockId,
+        eventName: candidate.eventName,
+        alias: candidate.alias,
+        ...candidate.optional === true ? { optional: true } : {}
+      };
+    });
+    return { kind: "step.event.all", sources };
+  }
+  if (type === "schedule") {
+    if (typeof trigger.scheduleRef !== "string" || trigger.scheduleRef.trim().length === 0) {
+      throw new FlowDefinitionPublicationError("INVALID_TRIGGER", "schedule requires scheduleRef");
+    }
+    if (trigger.scheduleRevision !== void 0 && (!Number.isInteger(trigger.scheduleRevision) || Number(trigger.scheduleRevision) < 1)) {
+      throw new FlowDefinitionPublicationError("INVALID_TRIGGER", "scheduleRevision must be an integer greater than zero");
+    }
+    return {
+      kind: "schedule",
+      scheduleRef: trigger.scheduleRef,
+      ...typeof trigger.scheduleRevision === "number" ? { scheduleRevision: trigger.scheduleRevision } : {}
+    };
+  }
+  throw new FlowDefinitionPublicationError("INVALID_TRIGGER", `Unsupported Flow trigger: ${type}`);
+}
+function actorFromProps(props) {
+  const actor = {};
+  if (props.authorisedActors) {
+    let actors;
+    try {
+      actors = JSON.parse(props.authorisedActors);
+    } catch (error) {
+      throw new FlowDefinitionPublicationError("INVALID_CONFIGURATION", `Flow step authorisedActors is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!Array.isArray(actors) || actors.some((actorDid) => typeof actorDid !== "string")) {
+      throw new FlowDefinitionPublicationError("INVALID_CONFIGURATION", "Flow step authorisedActors must be an array of DID strings");
+    }
+    actor.authorisedActors = actors;
+  }
+  if (props.parentCapability) actor.parentCapability = props.parentCapability;
+  return actor;
+}
+function ttlMsFromProps(props) {
+  const raw = props.ttlMs ?? props.ttl;
+  if (!raw) return void 0;
+  const numeric = Number(raw);
+  if (!Number.isFinite(numeric) || numeric < 0) {
+    throw new FlowDefinitionPublicationError("INVALID_CONFIGURATION", "Flow step ttlMs must be a non-negative number");
+  }
+  return numeric;
+}
+function isPositiveDuration(value) {
+  const match = /^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?)?$/u.exec(value);
+  return Boolean(match && match.slice(1).some((part) => Number(part ?? 0) > 0));
+}
+function ttlConstraintsFromProps(props) {
+  const ttl = {};
+  if (props.ttlAbsoluteDueDate) {
+    if (!Number.isFinite(Date.parse(props.ttlAbsoluteDueDate))) {
+      throw new FlowDefinitionPublicationError("INVALID_CONFIGURATION", "Flow step ttlAbsoluteDueDate must be a valid ISO 8601 date");
+    }
+    ttl.absoluteDueDate = props.ttlAbsoluteDueDate;
+  }
+  for (const [prop, field] of [
+    ["ttlFromEnablement", "fromEnablement"],
+    ["ttlFromCommitment", "fromCommitment"]
+  ]) {
+    const value = props[prop];
+    if (!value) continue;
+    if (!isPositiveDuration(value)) {
+      throw new FlowDefinitionPublicationError("INVALID_CONFIGURATION", `Flow step ${prop} must be a positive ISO 8601 day/hour/minute duration`);
+    }
+    ttl[field] = value;
+  }
+  return Object.keys(ttl).length > 0 ? ttl : void 0;
+}
+function toStep(node, action) {
+  const ttlMs = ttlMsFromProps(node.props);
+  const ttl = ttlConstraintsFromProps(node.props);
+  return {
+    stepId: node.nodeId,
+    blockId: node.blockId,
+    title: node.title,
+    ...node.description ? { description: node.description } : {},
+    action,
+    resource: node.with,
+    configuration: { ...node.props },
+    inputs: parseObject(node.props.inputs, "inputs"),
+    trigger: parseTrigger(node.props.trigger, node.props.triggerMode),
+    conditions: parseConditions(node.props.conditions),
+    actor: actorFromProps(node.props),
+    ...ttlMs !== void 0 ? { ttlMs } : {},
+    ...ttl ? { ttl } : {}
+  };
+}
+async function publishFlowDefinitionRevision(params) {
+  const expectedParent = params.expectedParent ? deepFreezeJson(JSON.parse(canonicalizeJson(params.expectedParent))) : void 0;
+  if (params.yDoc.getMap("qi.flow.meta").get("draftSchemaVersion") !== 1) {
+    throw new FlowDefinitionPublicationError("NOT_VNEXT_DRAFT", "Legacy Flow documents must be explicitly republished before vNext publication");
+  }
+  const document = readFlowDocument(params.yDoc);
+  if (!document || document.nodes.length === 0) throw new FlowDefinitionPublicationError("EMPTY_FLOW", "A Flow definition requires at least one step");
+  const steps = document.nodes.map((node) => {
+    const actionType = node.props.actionType;
+    const action = actionType ? params.actionContracts[actionType] : void 0;
+    if (!action) throw new FlowDefinitionPublicationError("MISSING_ACTION_CONTRACT", `No pinned Action contract for ${actionType || node.nodeId}`);
+    if (action.type !== actionType || action.can !== node.can) {
+      throw new FlowDefinitionPublicationError("MISSING_ACTION_CONTRACT", `Pinned Action contract does not match ${actionType} (${node.can})`);
+    }
+    if (action.manifestDigest !== params.actionManifestDigest) {
+      throw new FlowDefinitionPublicationError("MISSING_ACTION_CONTRACT", `Action ${action.type} is not pinned to the publication manifest`);
+    }
+    return toStep(node, action);
+  });
+  const signed = await signFlowDefinitionRevision(
+    {
+      kind: "qi.flow.definition-revision",
+      schemaVersion: "1.0",
+      ref: { flowId: params.flowId, revision: params.revision },
+      ...expectedParent ? { parent: expectedParent } : {},
+      publishedAt: params.publishedAt,
+      publishedBy: params.publishedBy,
+      actionManifestDigest: params.actionManifestDigest,
+      title: document.meta.title,
+      ...document.meta.goal ? { goal: document.meta.goal } : {},
+      steps,
+      participantRequirements: readFlowParticipants(params.yDoc).map(participantRequirement),
+      connectionRequirements: readFlowConnections(params.yDoc).map(connectionRequirement),
+      ...params.source ? { source: params.source } : {}
+    },
+    params.signer
+  );
+  const ref = { ...signed.ref, digest: signed.integrity.digest.value };
+  const outcome = await params.repository.publish(signed, expectedParent);
+  if (outcome === "parent_conflict") throw new FlowDefinitionPublicationError("PARENT_CONFLICT", "Flow definition head changed before publication");
+  return { outcome, ref, revision: signed };
+}
+
+// src/core/lib/flowCompiler/draftProposal.ts
+function canonicalSnapshot(value) {
+  return deepFreezeJson(JSON.parse(canonicalizeJson(value)));
+}
+async function createFlowDraftProposal(payload) {
+  const snapshot = canonicalSnapshot(payload);
+  if (!snapshot.proposalId || !snapshot.proposedBy || snapshot.operations.length === 0) throw new Error("Flow draft proposal identity, proposer, and operations are required");
+  return deepFreezeJson({ ...snapshot, proposalDigest: await digestCanonicalJson(snapshot) });
+}
+async function applyApprovedFlowDraftProposal(repository, proposal, approval) {
+  const proposalSnapshot = canonicalSnapshot(proposal);
+  const approvalSnapshot = canonicalSnapshot(approval);
+  const { proposalDigest, ...proposalPayload } = proposalSnapshot;
+  const actualProposalDigest = await digestCanonicalJson(proposalPayload);
+  if (approvalSnapshot.kind !== "qi.flow.draft-proposal-approval" || approvalSnapshot.schemaVersion !== "1.0" || approvalSnapshot.proposalId !== proposalSnapshot.proposalId || approvalSnapshot.proposalDigest !== proposalDigest || actualProposalDigest !== proposalDigest || !approvalSnapshot.approvedBy || !approvalSnapshot.approvalReference) {
+    throw new Error("Flow draft proposal requires an approval for its exact digest");
+  }
+  const approvedRevision = repository.read().revision;
+  if (approvedRevision !== proposalSnapshot.baseRevision) {
+    throw new Error(`Flow draft proposal was approved for revision ${proposalSnapshot.baseRevision}, but the draft is now revision ${approvedRevision}`);
+  }
+  const commands = proposalSnapshot.operations.map(
+    (operation, index) => ({
+      kind: "qi.flow.draft-command",
+      schemaVersion: "1.0",
+      commandId: `${proposalSnapshot.proposalId}:${index}`,
+      expectedRevision: proposalSnapshot.baseRevision + index,
+      actorDid: approvalSnapshot.approvedBy,
+      operation
+    })
+  );
+  return repository.applyBatch(commands);
+}
+
+export {
+  FlowDraftCommandError,
+  createYjsFlowDefinitionDraftRepository,
+  FLOW_PARTICIPANTS_MAP_KEY,
+  readFlowParticipants,
+  upsertFlowParticipant,
+  removeFlowParticipant,
+  setFlowParticipantPowerLevel,
+  setFlowParticipantRequirements,
+  setFlowParticipantSteps,
+  FlowDefinitionPublicationError,
+  publishFlowDefinitionRevision,
+  createFlowDraftProposal,
+  applyApprovedFlowDraftProposal
+};
+//# sourceMappingURL=chunk-3XSLBJYI.js.map