@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7195.1.b5efd1d51a

package/dist/modules/workflows/lib/step-type-conversion.js

@@ -0,0 +1,167 @@
+const CONVERTIBLE_STEP_TYPES = [
+  "userTask",
+  "automated",
+  "invokeAgent",
+  "subWorkflow",
+  "waitForSignal",
+  "waitForTimer",
+  "waitForCondition",
+  "ifElse",
+  "switch",
+  "parallelFork",
+  "parallelJoin"
+];
+const SHARED_DATA_KEYS = [
+  "label",
+  "stepName",
+  "description",
+  "timeout",
+  "retryPolicy",
+  "errorDirective",
+  "status",
+  "stepNumber",
+  "stepMetadata"
+];
+const TYPE_DATA_KEYS = {
+  userTask: ["assignedTo", "assignedToRoles", "formKey", "userTaskConfig"],
+  automated: ["activityType", "activityId", "activities"],
+  invokeAgent: ["activityType", "activityId", "activities", "agentId", "signalConfig"],
+  subWorkflow: [],
+  waitForSignal: ["signalConfig"],
+  waitForTimer: [],
+  waitForCondition: [],
+  parallelFork: [],
+  parallelJoin: [],
+  ifElse: [],
+  switch: []
+};
+const TYPE_CONFIG_KEYS = {
+  userTask: [],
+  automated: [],
+  invokeAgent: [],
+  subWorkflow: ["subWorkflowId", "version", "inputMapping", "outputMapping"],
+  waitForSignal: [],
+  waitForTimer: ["duration", "until"],
+  waitForCondition: ["condition", "timeout", "onTimeout", "pollIntervalMs"],
+  parallelFork: ["joinStepId"],
+  parallelJoin: ["forkStepId"],
+  ifElse: [],
+  switch: []
+};
+const DEADLINE_SLOTS = {
+  waitForSignal: { container: "data", parent: "signalConfig", key: "timeout" },
+  waitForCondition: { container: "config", key: "timeout" }
+};
+function isConvertibleStepType(type) {
+  return typeof type === "string" && CONVERTIBLE_STEP_TYPES.includes(type);
+}
+function listStepTypeConversionTargets(sourceType) {
+  if (!isConvertibleStepType(sourceType)) return [];
+  return CONVERTIBLE_STEP_TYPES.filter((candidate) => candidate !== sourceType);
+}
+function listStepTypeConversionOptions(sourceType) {
+  if (!isConvertibleStepType(sourceType)) return [];
+  return [...CONVERTIBLE_STEP_TYPES];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasKeys(value) {
+  return Object.keys(value).length > 0;
+}
+function readDeadline(type, data) {
+  const slot = DEADLINE_SLOTS[type];
+  if (!slot) return void 0;
+  const container = slot.container === "config" ? data.config : slot.parent ? data[slot.parent] : data;
+  if (!isRecord(container)) return void 0;
+  const value = container[slot.key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function isDeadlineKey(type, container, parent, key) {
+  const slot = DEADLINE_SLOTS[type];
+  if (!slot) return false;
+  return slot.container === container && slot.parent === parent && slot.key === key;
+}
+function writeDeadline(type, data, config, value) {
+  const slot = DEADLINE_SLOTS[type];
+  if (!slot || value === void 0) return;
+  if (slot.container === "config") {
+    config[slot.key] = value;
+    return;
+  }
+  if (!slot.parent) {
+    data[slot.key] = value;
+    return;
+  }
+  const parent = isRecord(data[slot.parent]) ? { ...data[slot.parent] } : {};
+  parent[slot.key] = value;
+  data[slot.parent] = parent;
+}
+function convertStepType(step, targetType) {
+  const sourceType = step.type;
+  if (!isConvertibleStepType(sourceType)) return { ok: false, code: "unsupportedSource" };
+  if (!isConvertibleStepType(targetType)) return { ok: false, code: "unsupportedTarget" };
+  if (sourceType === targetType) return { ok: false, code: "sameType" };
+  const sourceData = isRecord(step.data) ? step.data : {};
+  const acceptedDataKeys = /* @__PURE__ */ new Set([...SHARED_DATA_KEYS, ...TYPE_DATA_KEYS[targetType]]);
+  const acceptedConfigKeys = new Set(TYPE_CONFIG_KEYS[targetType]);
+  const nextData = {};
+  const nextConfig = {};
+  const quarantine = isRecord(sourceData.unmappedConfig) ? { ...sourceData.unmappedConfig } : {};
+  const quarantinedConfig = isRecord(quarantine.config) ? { ...quarantine.config } : {};
+  const quarantined = [];
+  const deadline = readDeadline(sourceType, sourceData);
+  for (const [key, value] of Object.entries(sourceData)) {
+    if (key === "unmappedConfig" || key === "badge") continue;
+    if (value === void 0) continue;
+    if (key === "config") {
+      if (!isRecord(value)) continue;
+      for (const [configKey, configValue] of Object.entries(value)) {
+        if (configValue === void 0) continue;
+        if (acceptedConfigKeys.has(configKey)) {
+          nextConfig[configKey] = configValue;
+          continue;
+        }
+        if (isDeadlineKey(sourceType, "config", void 0, configKey) && DEADLINE_SLOTS[targetType]) continue;
+        quarantinedConfig[configKey] = configValue;
+        quarantined.push(`config.${configKey}`);
+      }
+      continue;
+    }
+    if (acceptedDataKeys.has(key)) {
+      nextData[key] = value;
+      continue;
+    }
+    const deadlineSlot = DEADLINE_SLOTS[sourceType];
+    if (deadlineSlot && deadlineSlot.container === "data" && deadlineSlot.parent === key && DEADLINE_SLOTS[targetType] && isRecord(value)) {
+      const remainder = { ...value };
+      delete remainder[deadlineSlot.key];
+      if (hasKeys(remainder)) {
+        quarantine[key] = remainder;
+        quarantined.push(key);
+      }
+      continue;
+    }
+    quarantine[key] = value;
+    quarantined.push(key);
+  }
+  writeDeadline(targetType, nextData, nextConfig, deadline);
+  if (hasKeys(nextConfig)) nextData.config = nextConfig;
+  if (hasKeys(quarantinedConfig)) quarantine.config = quarantinedConfig;
+  if (hasKeys(quarantine)) nextData.unmappedConfig = quarantine;
+  return { ok: true, type: targetType, data: nextData, quarantined };
+}
+function readUnmappedStepConfig(data) {
+  if (!isRecord(data)) return null;
+  const unmapped = data.unmappedConfig;
+  return isRecord(unmapped) && hasKeys(unmapped) ? unmapped : null;
+}
+export {
+  CONVERTIBLE_STEP_TYPES,
+  convertStepType,
+  isConvertibleStepType,
+  listStepTypeConversionOptions,
+  listStepTypeConversionTargets,
+  readUnmappedStepConfig
+};
+//# sourceMappingURL=step-type-conversion.js.map

package/dist/modules/workflows/lib/step-type-conversion.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/step-type-conversion.ts"],
+  "sourcesContent": ["/**\n * In-place step type conversion (spec section 4.5, issue #4237 A9a).\n *\n * \"Change type\u2026\" keeps the step's id, name, position and wiring; config the\n * target type genuinely shares is mapped across, and config it cannot execute\n * is quarantined under `unmappedConfig` \u2014 visible in the inspector, flagged in\n * Problems, never dropped. Restoring a quarantined value is a matter of\n * converting back, which is exactly why nothing may be discarded here.\n *\n * PURE: plain step data in, plain step data out. No React, no ORM, no DI, no\n * xyflow. The editor page owns the actual node mutation.\n *\n * The vocabulary is the editor's node types rather than the definition's\n * `stepType` enum, because that is the granularity an author changes: an\n * `invokeAgent` node compiles to an AUTOMATED step, and converting between the\n * two is a real, meaningful conversion the enum cannot express.\n */\n\nexport type ConvertibleStepType =\n  | 'userTask'\n  | 'automated'\n  | 'invokeAgent'\n  | 'subWorkflow'\n  | 'waitForSignal'\n  | 'waitForTimer'\n  | 'waitForCondition'\n  | 'parallelFork'\n  | 'parallelJoin'\n  | 'ifElse'\n  | 'switch'\n\n/**\n * START and END are deliberately absent: `validateWorkflowGraph` requires\n * exactly one START and at least one END, so converting either one (or into\n * one) breaks an invariant the author cannot see from the inspector.\n */\nexport const CONVERTIBLE_STEP_TYPES: ConvertibleStepType[] = [\n  'userTask',\n  'automated',\n  'invokeAgent',\n  'subWorkflow',\n  'waitForSignal',\n  'waitForTimer',\n  'waitForCondition',\n  'ifElse',\n  'switch',\n  'parallelFork',\n  'parallelJoin',\n]\n\n/** Step data that describes the step itself, never a single type's behaviour. */\nconst SHARED_DATA_KEYS = [\n  'label',\n  'stepName',\n  'description',\n  'timeout',\n  'retryPolicy',\n  'errorDirective',\n  'status',\n  'stepNumber',\n  'stepMetadata',\n] as const\n\n/** Top-level `node.data` keys each type actually executes. */\nconst TYPE_DATA_KEYS: Record<ConvertibleStepType, readonly string[]> = {\n  userTask: ['assignedTo', 'assignedToRoles', 'formKey', 'userTaskConfig'],\n  automated: ['activityType', 'activityId', 'activities'],\n  invokeAgent: ['activityType', 'activityId', 'activities', 'agentId', 'signalConfig'],\n  subWorkflow: [],\n  waitForSignal: ['signalConfig'],\n  waitForTimer: [],\n  waitForCondition: [],\n  parallelFork: [],\n  parallelJoin: [],\n  ifElse: [],\n  switch: [],\n}\n\n/** `node.data.config` keys each type actually executes. */\nconst TYPE_CONFIG_KEYS: Record<ConvertibleStepType, readonly string[]> = {\n  userTask: [],\n  automated: [],\n  invokeAgent: [],\n  subWorkflow: ['subWorkflowId', 'version', 'inputMapping', 'outputMapping'],\n  waitForSignal: [],\n  waitForTimer: ['duration', 'until'],\n  waitForCondition: ['condition', 'timeout', 'onTimeout', 'pollIntervalMs'],\n  parallelFork: ['joinStepId'],\n  parallelJoin: ['forkStepId'],\n  ifElse: [],\n  switch: [],\n}\n\n/**\n * Where a type keeps its \"give up after\" deadline. The two waiting types spell\n * the same ISO-8601 duration differently, so the value travels between them\n * instead of being quarantined. WAIT_FOR_TIMER's `duration` is deliberately not\n * part of this: it is how long to wait ON PURPOSE, not when to give up.\n */\nconst DEADLINE_SLOTS: Partial<Record<ConvertibleStepType, { container: 'data' | 'config'; parent?: string; key: string }>> = {\n  waitForSignal: { container: 'data', parent: 'signalConfig', key: 'timeout' },\n  waitForCondition: { container: 'config', key: 'timeout' },\n}\n\nexport interface ConvertibleStep {\n  type?: string | null\n  data?: Record<string, unknown> | null\n}\n\nexport type StepTypeConversionResult =\n  | {\n      ok: true\n      type: ConvertibleStepType\n      data: Record<string, unknown>\n      /** Config keys moved to `unmappedConfig` by THIS conversion. */\n      quarantined: string[]\n    }\n  | { ok: false; code: 'sameType' | 'unsupportedSource' | 'unsupportedTarget' }\n\nexport function isConvertibleStepType(type: string | null | undefined): type is ConvertibleStepType {\n  return typeof type === 'string' && (CONVERTIBLE_STEP_TYPES as string[]).includes(type)\n}\n\n/** Types a step of `sourceType` may be converted into (never itself). */\nexport function listStepTypeConversionTargets(sourceType: string | null | undefined): ConvertibleStepType[] {\n  if (!isConvertibleStepType(sourceType)) return []\n  return CONVERTIBLE_STEP_TYPES.filter((candidate) => candidate !== sourceType)\n}\n\n/**\n * Every type the inspector's step-type control lists, INCLUDING the step's\n * current one. The control states what the step is today and changes it by\n * picking something else, so an options list that omitted the current type\n * could never render a value for it.\n */\nexport function listStepTypeConversionOptions(sourceType: string | null | undefined): ConvertibleStepType[] {\n  if (!isConvertibleStepType(sourceType)) return []\n  return [...CONVERTIBLE_STEP_TYPES]\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nfunction hasKeys(value: Record<string, unknown>): boolean {\n  return Object.keys(value).length > 0\n}\n\nfunction readDeadline(type: ConvertibleStepType, data: Record<string, unknown>): unknown {\n  const slot = DEADLINE_SLOTS[type]\n  if (!slot) return undefined\n  const container = slot.container === 'config' ? data.config : slot.parent ? data[slot.parent] : data\n  if (!isRecord(container)) return undefined\n  const value = container[slot.key]\n  return typeof value === 'string' && value.length > 0 ? value : undefined\n}\n\nfunction isDeadlineKey(type: ConvertibleStepType, container: 'data' | 'config', parent: string | undefined, key: string): boolean {\n  const slot = DEADLINE_SLOTS[type]\n  if (!slot) return false\n  return slot.container === container && slot.parent === parent && slot.key === key\n}\n\nfunction writeDeadline(type: ConvertibleStepType, data: Record<string, unknown>, config: Record<string, unknown>, value: unknown): void {\n  const slot = DEADLINE_SLOTS[type]\n  if (!slot || value === undefined) return\n  if (slot.container === 'config') {\n    config[slot.key] = value\n    return\n  }\n  if (!slot.parent) {\n    data[slot.key] = value\n    return\n  }\n  const parent = isRecord(data[slot.parent]) ? { ...(data[slot.parent] as Record<string, unknown>) } : {}\n  parent[slot.key] = value\n  data[slot.parent] = parent\n}\n\n/**\n * Convert one step to another type.\n *\n * Everything the target type executes is carried across, the shared deadline\n * moves between the two waiting types, and every remaining key lands in\n * `data.unmappedConfig` (merged with anything an earlier conversion already\n * quarantined) so a later conversion back can pick it up.\n */\nexport function convertStepType(step: ConvertibleStep, targetType: string): StepTypeConversionResult {\n  const sourceType = step.type\n  if (!isConvertibleStepType(sourceType)) return { ok: false, code: 'unsupportedSource' }\n  if (!isConvertibleStepType(targetType)) return { ok: false, code: 'unsupportedTarget' }\n  if (sourceType === targetType) return { ok: false, code: 'sameType' }\n\n  const sourceData = isRecord(step.data) ? step.data : {}\n  const acceptedDataKeys = new Set<string>([...SHARED_DATA_KEYS, ...TYPE_DATA_KEYS[targetType]])\n  const acceptedConfigKeys = new Set<string>(TYPE_CONFIG_KEYS[targetType])\n\n  const nextData: Record<string, unknown> = {}\n  const nextConfig: Record<string, unknown> = {}\n  const quarantine: Record<string, unknown> = isRecord(sourceData.unmappedConfig)\n    ? { ...(sourceData.unmappedConfig as Record<string, unknown>) }\n    : {}\n  const quarantinedConfig: Record<string, unknown> = isRecord(quarantine.config)\n    ? { ...(quarantine.config as Record<string, unknown>) }\n    : {}\n  const quarantined: string[] = []\n\n  const deadline = readDeadline(sourceType, sourceData)\n\n  for (const [key, value] of Object.entries(sourceData)) {\n    if (key === 'unmappedConfig' || key === 'badge') continue\n    if (value === undefined) continue\n\n    if (key === 'config') {\n      if (!isRecord(value)) continue\n      for (const [configKey, configValue] of Object.entries(value)) {\n        if (configValue === undefined) continue\n        if (acceptedConfigKeys.has(configKey)) {\n          nextConfig[configKey] = configValue\n          continue\n        }\n        if (isDeadlineKey(sourceType, 'config', undefined, configKey) && DEADLINE_SLOTS[targetType]) continue\n        quarantinedConfig[configKey] = configValue\n        quarantined.push(`config.${configKey}`)\n      }\n      continue\n    }\n\n    if (acceptedDataKeys.has(key)) {\n      nextData[key] = value\n      continue\n    }\n\n    const deadlineSlot = DEADLINE_SLOTS[sourceType]\n    if (deadlineSlot && deadlineSlot.container === 'data' && deadlineSlot.parent === key && DEADLINE_SLOTS[targetType] && isRecord(value)) {\n      const remainder = { ...value }\n      delete remainder[deadlineSlot.key]\n      if (hasKeys(remainder)) {\n        quarantine[key] = remainder\n        quarantined.push(key)\n      }\n      continue\n    }\n\n    quarantine[key] = value\n    quarantined.push(key)\n  }\n\n  writeDeadline(targetType, nextData, nextConfig, deadline)\n\n  if (hasKeys(nextConfig)) nextData.config = nextConfig\n  if (hasKeys(quarantinedConfig)) quarantine.config = quarantinedConfig\n  if (hasKeys(quarantine)) nextData.unmappedConfig = quarantine\n\n  return { ok: true, type: targetType, data: nextData, quarantined }\n}\n\n/** True when a step carries quarantined config the Problems panel should flag. */\nexport function readUnmappedStepConfig(data: unknown): Record<string, unknown> | null {\n  if (!isRecord(data)) return null\n  const unmapped = data.unmappedConfig\n  return isRecord(unmapped) && hasKeys(unmapped) ? unmapped : null\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/workflows/lib/subgraph-clipboard.js

@@ -0,0 +1,114 @@
+import { definitionToGraph, generateStepId, generateTransitionId, graphToDefinition } from "./graph-utils.js";
+import { isDataMappingEdge } from "./data-edge-mapping.js";
+import { isAnnotationNode } from "./editor-annotations.js";
+const WORKFLOW_SUBGRAPH_CLIPBOARD_KIND = "open-mercato.workflow-subgraph";
+const WORKFLOW_SUBGRAPH_CLIPBOARD_VERSION = 1;
+const SUBGRAPH_PASTE_OFFSET = { x: 48, y: 48 };
+function serializeWorkflowSubgraph(nodes, edges, selectedNodeIds) {
+  const selected = new Set(selectedNodeIds);
+  const selectedNodes = nodes.filter((node) => selected.has(node.id) && !isAnnotationNode(node));
+  if (selectedNodes.length === 0) return null;
+  const internalEdges = edges.filter(
+    (edge) => selected.has(edge.source) && selected.has(edge.target) && !isDataMappingEdge(edge)
+  );
+  const definition = graphToDefinition(selectedNodes, internalEdges, { includePositions: true });
+  return {
+    kind: WORKFLOW_SUBGRAPH_CLIPBOARD_KIND,
+    version: WORKFLOW_SUBGRAPH_CLIPBOARD_VERSION,
+    steps: definition.steps,
+    transitions: definition.transitions
+  };
+}
+function stringifyWorkflowSubgraph(payload) {
+  return JSON.stringify(payload, null, 2);
+}
+function parseWorkflowSubgraph(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return { ok: false, code: "invalidJson" };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { ok: false, code: "unsupportedFormat" };
+  }
+  const candidate = parsed;
+  if (candidate.kind !== WORKFLOW_SUBGRAPH_CLIPBOARD_KIND) {
+    return { ok: false, code: "unsupportedFormat" };
+  }
+  if (candidate.version !== WORKFLOW_SUBGRAPH_CLIPBOARD_VERSION) {
+    return { ok: false, code: "unsupportedFormat" };
+  }
+  const steps = candidate.steps;
+  const transitions = candidate.transitions;
+  if (!Array.isArray(steps) || !Array.isArray(transitions)) {
+    return { ok: false, code: "unsupportedFormat" };
+  }
+  if (steps.length === 0) return { ok: false, code: "empty" };
+  return {
+    ok: true,
+    payload: {
+      kind: WORKFLOW_SUBGRAPH_CLIPBOARD_KIND,
+      version: WORKFLOW_SUBGRAPH_CLIPBOARD_VERSION,
+      steps,
+      transitions
+    }
+  };
+}
+function deriveStepIdPrefix(stepId) {
+  const withoutGeneratedSuffix = stepId.replace(/_\d{9,}_[a-z0-9]+$/i, "");
+  const prefix = withoutGeneratedSuffix.trim();
+  return prefix.length > 0 ? prefix : "step";
+}
+function pasteWorkflowSubgraph(nodes, edges, payload, options = {}) {
+  const offset = options.offset ?? SUBGRAPH_PASTE_OFFSET;
+  const existingIds = new Set(nodes.map((node) => node.id));
+  const stepIdMap = /* @__PURE__ */ new Map();
+  for (const step of payload.steps) {
+    let nextId = generateStepId(deriveStepIdPrefix(step.stepId));
+    while (existingIds.has(nextId) || stepIdMap.has(nextId)) {
+      nextId = generateStepId(deriveStepIdPrefix(step.stepId));
+    }
+    existingIds.add(nextId);
+    stepIdMap.set(step.stepId, nextId);
+  }
+  const rebasedSteps = payload.steps.map((step) => ({
+    ...step,
+    stepId: stepIdMap.get(step.stepId)
+  }));
+  const rebasedTransitions = payload.transitions.filter((transition) => stepIdMap.has(transition.fromStepId) && stepIdMap.has(transition.toStepId)).map((transition) => ({
+    ...transition,
+    transitionId: generateTransitionId(),
+    fromStepId: stepIdMap.get(transition.fromStepId),
+    toStepId: stepIdMap.get(transition.toStepId)
+  }));
+  const graph = definitionToGraph({
+    steps: rebasedSteps,
+    transitions: rebasedTransitions
+  });
+  const pastedNodes = graph.nodes.map((node) => {
+    const data = { ...node.data };
+    delete data.stepNumber;
+    return {
+      ...node,
+      position: { x: node.position.x + offset.x, y: node.position.y + offset.y },
+      selected: true,
+      data
+    };
+  });
+  return {
+    nodes: [...nodes.map((node) => node.selected ? { ...node, selected: false } : node), ...pastedNodes],
+    edges: [...edges, ...graph.edges],
+    pastedNodeIds: pastedNodes.map((node) => node.id)
+  };
+}
+export {
+  SUBGRAPH_PASTE_OFFSET,
+  WORKFLOW_SUBGRAPH_CLIPBOARD_KIND,
+  WORKFLOW_SUBGRAPH_CLIPBOARD_VERSION,
+  parseWorkflowSubgraph,
+  pasteWorkflowSubgraph,
+  serializeWorkflowSubgraph,
+  stringifyWorkflowSubgraph
+};
+//# sourceMappingURL=subgraph-clipboard.js.map

package/dist/modules/workflows/lib/subgraph-clipboard.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/subgraph-clipboard.ts"],
+  "sourcesContent": ["/**\n * Portable-JSON subgraph clipboard (spec section 4.5).\n *\n * \"Multi-select \u2192 portable-JSON subgraph on the clipboard; paste re-IDs and\n * splices; works across workflows and into the Code view.\"\n *\n * The payload speaks the DEFINITION vocabulary (`steps` + `transitions`), not\n * React Flow's nodes and edges: the Code view renders the definition JSON, so a\n * fragment copied from the canvas has to be the same shape a fragment copied out\n * of the Code view is \u2014 otherwise the two surfaces could not exchange anything.\n * Positions ride along as `_editorPosition`, exactly as a saved definition\n * carries them.\n *\n * Only transitions INTERNAL to the selection travel. A route with one endpoint\n * outside the selection describes a connection to a step that is not in the\n * payload, so pasting it could only invent a dangling id.\n *\n * PURE: plain data in, plain data out. Clipboard access, translation and flash\n * messages belong to the page.\n */\n\nimport type { Node, Edge } from '@xyflow/react'\nimport type { WorkflowDefinition } from '../data/entities'\nimport { definitionToGraph, generateStepId, generateTransitionId, graphToDefinition } from './graph-utils'\nimport { isDataMappingEdge } from './data-edge-mapping'\nimport { isAnnotationNode } from './editor-annotations'\n\n/** Format discriminator. Written by the canvas and by the Code view alike. */\nexport const WORKFLOW_SUBGRAPH_CLIPBOARD_KIND = 'open-mercato.workflow-subgraph'\n\n/** Bumped only for a breaking payload change; readers refuse what they do not know. */\nexport const WORKFLOW_SUBGRAPH_CLIPBOARD_VERSION = 1\n\n/** How far a pasted copy lands from the original, in flow units. */\nexport const SUBGRAPH_PASTE_OFFSET = { x: 48, y: 48 }\n\ntype DefinitionStep = WorkflowDefinition['definition']['steps'][number]\ntype DefinitionTransition = WorkflowDefinition['definition']['transitions'][number]\n\nexport interface WorkflowSubgraphClipboard {\n  kind: typeof WORKFLOW_SUBGRAPH_CLIPBOARD_KIND\n  version: typeof WORKFLOW_SUBGRAPH_CLIPBOARD_VERSION\n  steps: DefinitionStep[]\n  transitions: DefinitionTransition[]\n}\n\nexport type SubgraphClipboardParseFailure =\n  | { ok: false; code: 'invalidJson' }\n  | { ok: false; code: 'unsupportedFormat' }\n  | { ok: false; code: 'empty' }\n\nexport type SubgraphClipboardParseResult =\n  | { ok: true; payload: WorkflowSubgraphClipboard }\n  | SubgraphClipboardParseFailure\n\nexport interface SubgraphPasteResult {\n  nodes: Node[]\n  edges: Edge[]\n  /** Ids of the freshly minted steps, so the caller can select what it pasted. */\n  pastedNodeIds: string[]\n}\n\n/**\n * Serialize the selected steps and the routes strictly between them.\n *\n * Returns `null` when the selection holds no step: a clipboard payload with no\n * steps has nothing to splice, and writing one would silently clear whatever the\n * author copied earlier.\n */\nexport function serializeWorkflowSubgraph(\n  nodes: Node[],\n  edges: Edge[],\n  selectedNodeIds: string[],\n): WorkflowSubgraphClipboard | null {\n  const selected = new Set(selectedNodeIds)\n  // Annotations never travel on the clipboard: the payload speaks the definition\n  // vocabulary, and a note has no definition form to speak.\n  const selectedNodes = nodes.filter((node) => selected.has(node.id) && !isAnnotationNode(node))\n  if (selectedNodes.length === 0) return null\n\n  const internalEdges = edges.filter(\n    (edge) => selected.has(edge.source) && selected.has(edge.target) && !isDataMappingEdge(edge),\n  )\n  const definition = graphToDefinition(selectedNodes, internalEdges, { includePositions: true })\n\n  return {\n    kind: WORKFLOW_SUBGRAPH_CLIPBOARD_KIND,\n    version: WORKFLOW_SUBGRAPH_CLIPBOARD_VERSION,\n    steps: definition.steps,\n    transitions: definition.transitions,\n  }\n}\n\nexport function stringifyWorkflowSubgraph(payload: WorkflowSubgraphClipboard): string {\n  return JSON.stringify(payload, null, 2)\n}\n\n/** Read a clipboard payload, refusing anything that is not this exact format. */\nexport function parseWorkflowSubgraph(text: string): SubgraphClipboardParseResult {\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(text)\n  } catch {\n    return { ok: false, code: 'invalidJson' }\n  }\n  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {\n    return { ok: false, code: 'unsupportedFormat' }\n  }\n  const candidate = parsed as Record<string, unknown>\n  if (candidate.kind !== WORKFLOW_SUBGRAPH_CLIPBOARD_KIND) {\n    return { ok: false, code: 'unsupportedFormat' }\n  }\n  if (candidate.version !== WORKFLOW_SUBGRAPH_CLIPBOARD_VERSION) {\n    return { ok: false, code: 'unsupportedFormat' }\n  }\n  const steps = candidate.steps\n  const transitions = candidate.transitions\n  if (!Array.isArray(steps) || !Array.isArray(transitions)) {\n    return { ok: false, code: 'unsupportedFormat' }\n  }\n  if (steps.length === 0) return { ok: false, code: 'empty' }\n\n  return {\n    ok: true,\n    payload: {\n      kind: WORKFLOW_SUBGRAPH_CLIPBOARD_KIND,\n      version: WORKFLOW_SUBGRAPH_CLIPBOARD_VERSION,\n      steps: steps as DefinitionStep[],\n      transitions: transitions as DefinitionTransition[],\n    },\n  }\n}\n\n/**\n * Keep the meaningful part of a generated step id so a paste of `userTask_1753\u2026`\n * stays recognisably a user task instead of turning into `step_\u2026`, without the\n * id growing a suffix on every paste.\n */\nfunction deriveStepIdPrefix(stepId: string): string {\n  const withoutGeneratedSuffix = stepId.replace(/_\\d{9,}_[a-z0-9]+$/i, '')\n  const prefix = withoutGeneratedSuffix.trim()\n  return prefix.length > 0 ? prefix : 'step'\n}\n\nexport interface SubgraphPasteOptions {\n  /** Flow-space translation applied to every pasted step. */\n  offset?: { x: number; y: number }\n}\n\n/**\n * Splice a clipboard payload into the graph.\n *\n * Every step and every transition is re-IDed, so pasting into the workflow the\n * fragment came from can never collide with \u2014 or silently merge into \u2014 the\n * original. Internal routes are rewired onto the new ids; the copies land offset\n * from the originals so the paste is visible rather than hidden underneath them.\n */\nexport function pasteWorkflowSubgraph(\n  nodes: Node[],\n  edges: Edge[],\n  payload: WorkflowSubgraphClipboard,\n  options: SubgraphPasteOptions = {},\n): SubgraphPasteResult {\n  const offset = options.offset ?? SUBGRAPH_PASTE_OFFSET\n  const existingIds = new Set(nodes.map((node) => node.id))\n\n  const stepIdMap = new Map<string, string>()\n  for (const step of payload.steps) {\n    let nextId = generateStepId(deriveStepIdPrefix(step.stepId))\n    while (existingIds.has(nextId) || stepIdMap.has(nextId)) {\n      nextId = generateStepId(deriveStepIdPrefix(step.stepId))\n    }\n    existingIds.add(nextId)\n    stepIdMap.set(step.stepId, nextId)\n  }\n\n  const rebasedSteps = payload.steps.map((step) => ({\n    ...step,\n    stepId: stepIdMap.get(step.stepId) as string,\n  }))\n\n  const rebasedTransitions = payload.transitions\n    .filter((transition) => stepIdMap.has(transition.fromStepId) && stepIdMap.has(transition.toStepId))\n    .map((transition) => ({\n      ...transition,\n      transitionId: generateTransitionId(),\n      fromStepId: stepIdMap.get(transition.fromStepId) as string,\n      toStepId: stepIdMap.get(transition.toStepId) as string,\n    }))\n\n  const graph = definitionToGraph({\n    steps: rebasedSteps,\n    transitions: rebasedTransitions,\n  } as WorkflowDefinition['definition'])\n\n  const pastedNodes = graph.nodes.map((node) => {\n    // The running step number is derived from a node's index in the whole graph,\n    // so a fragment's own numbering would be a lie once it is spliced in.\n    const data = { ...(node.data as Record<string, unknown>) }\n    delete data.stepNumber\n    return {\n      ...node,\n      position: { x: node.position.x + offset.x, y: node.position.y + offset.y },\n      selected: true,\n      data,\n    }\n  })\n\n  return {\n    nodes: [...nodes.map((node) => (node.selected ? { ...node, selected: false } : node)), ...pastedNodes],\n    edges: [...edges, ...graph.edges],\n    pastedNodeIds: pastedNodes.map((node) => node.id),\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/workflows/lib/task-decision-context.js

@@ -0,0 +1,38 @@
+import { StepInstance, WorkflowInstance } from "../data/entities.js";
+import { findDefinitionForInstance } from "./find-definition.js";
+import { readAuthoredTaskDecisions } from "./task-decisions.js";
+import { resolveTaskDecisions } from "./task-resolution.js";
+const EMPTY_TASK_DECISION_CONTEXT = {
+  stepId: null,
+  decisions: [],
+  formKey: null
+};
+async function loadTaskDecisionContext(em, task) {
+  const instance = await em.findOne(WorkflowInstance, { id: task.workflowInstanceId });
+  if (!instance) return EMPTY_TASK_DECISION_CONTEXT;
+  const stepInstance = await em.findOne(StepInstance, { id: task.stepInstanceId });
+  if (!stepInstance) return EMPTY_TASK_DECISION_CONTEXT;
+  const definition = await findDefinitionForInstance(em, instance);
+  if (!definition) return { stepId: stepInstance.stepId, decisions: [], formKey: null };
+  const formKey = readAuthoredTaskFormKey(definition.definition, stepInstance.stepId);
+  const authored = readAuthoredTaskDecisions(definition.definition, stepInstance.stepId);
+  if (!authored.length) return { stepId: stepInstance.stepId, decisions: [], formKey };
+  const { interpolateVariables } = await import("./activity-executor.js");
+  const interpolate = (value) => interpolateVariables(value, instance.context ?? {}, instance);
+  return {
+    stepId: stepInstance.stepId,
+    decisions: resolveTaskDecisions(authored, interpolate),
+    formKey
+  };
+}
+function readAuthoredTaskFormKey(definition, stepId) {
+  const steps = definition?.steps;
+  const step = (steps ?? []).find((candidate) => candidate.stepId === stepId);
+  const formKey = step?.userTaskConfig?.formKey;
+  return typeof formKey === "string" && formKey.length > 0 ? formKey : null;
+}
+export {
+  EMPTY_TASK_DECISION_CONTEXT,
+  loadTaskDecisionContext
+};
+//# sourceMappingURL=task-decision-context.js.map

package/dist/modules/workflows/lib/task-decision-context.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/task-decision-context.ts"],
+  "sourcesContent": ["/**\n * Re-resolving a task's decision buttons from its instance's pinned definition.\n *\n * Separated from the pure `lib/task-decisions.ts` because it needs the ORM: the\n * task surfaces (a client page, a record-page widget) import the pure half, and\n * only the server imports this one.\n */\n\nimport type { EntityManager } from '@mikro-orm/core'\nimport { StepInstance, WorkflowInstance } from '../data/entities'\nimport type { UserTask } from '../data/entities'\nimport { findDefinitionForInstance } from './find-definition'\nimport { readAuthoredTaskDecisions } from './task-decisions'\nimport { resolveTaskDecisions } from './task-resolution'\nimport type { ResolvedTaskDecision, TaskInterpolate } from './task-resolution'\n\nexport type TaskDecisionContext = {\n  stepId: string | null\n  decisions: ResolvedTaskDecision[]\n  /**\n   * Authored `userTaskConfig.formKey`, resolved the same way the decisions are:\n   * from the instance's PINNED definition, never from a column. A task form is\n   * a rendering choice, so re-reading it per request is what lets a definition\n   * that gains a renderer key start using it \u2014 and it needs no migration.\n   */\n  formKey: string | null\n}\n\nexport const EMPTY_TASK_DECISION_CONTEXT: TaskDecisionContext = {\n  stepId: null,\n  decisions: [],\n  formKey: null,\n}\n\n/**\n * Re-resolve a task's decision buttons from its instance's pinned definition.\n *\n * Degrades to an empty list at every step \u2014 a task whose instance, step or\n * definition has gone missing still completes through the plain form, which is\n * exactly how every task behaved before decisions existed.\n */\nexport async function loadTaskDecisionContext(\n  em: EntityManager,\n  task: Pick<UserTask, 'workflowInstanceId' | 'stepInstanceId'>,\n): Promise<TaskDecisionContext> {\n  const instance = await em.findOne(WorkflowInstance, { id: task.workflowInstanceId })\n  if (!instance) return EMPTY_TASK_DECISION_CONTEXT\n\n  const stepInstance = await em.findOne(StepInstance, { id: task.stepInstanceId })\n  if (!stepInstance) return EMPTY_TASK_DECISION_CONTEXT\n\n  const definition = await findDefinitionForInstance(em, instance)\n  if (!definition) return { stepId: stepInstance.stepId, decisions: [], formKey: null }\n\n  const formKey = readAuthoredTaskFormKey(definition.definition, stepInstance.stepId)\n  const authored = readAuthoredTaskDecisions(definition.definition, stepInstance.stepId)\n  if (!authored.length) return { stepId: stepInstance.stepId, decisions: [], formKey }\n\n  const { interpolateVariables } = await import('./activity-executor')\n  const interpolate: TaskInterpolate = (value) =>\n    interpolateVariables(value, instance.context ?? {}, instance)\n\n  return {\n    stepId: stepInstance.stepId,\n    decisions: resolveTaskDecisions(authored, interpolate),\n    formKey,\n  }\n}\n\nfunction readAuthoredTaskFormKey(definition: unknown, stepId: string): string | null {\n  const steps = (definition as { steps?: { stepId?: string; userTaskConfig?: { formKey?: unknown } }[] })\n    ?.steps\n  const step = (steps ?? []).find((candidate) => candidate.stepId === stepId)\n  const formKey = step?.userTaskConfig?.formKey\n  return typeof formKey === 'string' && formKey.length > 0 ? formKey : null\n}\n"],
+  "mappings": "AASA,SAAS,cAAc,wBAAwB;AAE/C,SAAS,iCAAiC;AAC1C,SAAS,iCAAiC;AAC1C,SAAS,4BAA4B;AAe9B,MAAM,8BAAmD;AAAA,EAC9D,QAAQ;AAAA,EACR,WAAW,CAAC;AAAA,EACZ,SAAS;AACX;AASA,eAAsB,wBACpB,IACA,MAC8B;AAC9B,QAAM,WAAW,MAAM,GAAG,QAAQ,kBAAkB,EAAE,IAAI,KAAK,mBAAmB,CAAC;AACnF,MAAI,CAAC,SAAU,QAAO;AAEtB,QAAM,eAAe,MAAM,GAAG,QAAQ,cAAc,EAAE,IAAI,KAAK,eAAe,CAAC;AAC/E,MAAI,CAAC,aAAc,QAAO;AAE1B,QAAM,aAAa,MAAM,0BAA0B,IAAI,QAAQ;AAC/D,MAAI,CAAC,WAAY,QAAO,EAAE,QAAQ,aAAa,QAAQ,WAAW,CAAC,GAAG,SAAS,KAAK;AAEpF,QAAM,UAAU,wBAAwB,WAAW,YAAY,aAAa,MAAM;AAClF,QAAM,WAAW,0BAA0B,WAAW,YAAY,aAAa,MAAM;AACrF,MAAI,CAAC,SAAS,OAAQ,QAAO,EAAE,QAAQ,aAAa,QAAQ,WAAW,CAAC,GAAG,QAAQ;AAEnF,QAAM,EAAE,qBAAqB,IAAI,MAAM,OAAO,qBAAqB;AACnE,QAAM,cAA+B,CAAC,UACpC,qBAAqB,OAAO,SAAS,WAAW,CAAC,GAAG,QAAQ;AAE9D,SAAO;AAAA,IACL,QAAQ,aAAa;AAAA,IACrB,WAAW,qBAAqB,UAAU,WAAW;AAAA,IACrD;AAAA,EACF;AACF;AAEA,SAAS,wBAAwB,YAAqB,QAA+B;AACnF,QAAM,QAAS,YACX;AACJ,QAAM,QAAQ,SAAS,CAAC,GAAG,KAAK,CAAC,cAAc,UAAU,WAAW,MAAM;AAC1E,QAAM,UAAU,MAAM,gBAAgB;AACtC,SAAO,OAAO,YAAY,YAAY,QAAQ,SAAS,IAAI,UAAU;AACvE;",
+  "names": []
+}

package/dist/modules/workflows/lib/task-decisions.js

@@ -0,0 +1,49 @@
+import { excludeNonNormalTransitions } from "./route-kinds.js";
+const TASK_DECISION_FORM_KEY = "__decision";
+function findTaskDecision(decisions, decisionId) {
+  return decisions.find((decision) => decision.id === decisionId) ?? null;
+}
+function findTaskDecisionTransition(transitions, transitionId, fromStepId) {
+  if (!transitions?.length) return null;
+  const candidates = excludeNonNormalTransitions(transitions);
+  return candidates.find(
+    (transition) => transition.transitionId === transitionId && transition.fromStepId === fromStepId
+  ) ?? null;
+}
+function withRecordedDecision(formData, decisionId) {
+  if (!decisionId) return formData;
+  return { ...formData, [TASK_DECISION_FORM_KEY]: decisionId };
+}
+function readRecordedDecision(formData) {
+  if (!formData || typeof formData !== "object" || Array.isArray(formData)) return null;
+  const value = formData[TASK_DECISION_FORM_KEY];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readAuthoredTaskDecisions(definitionData, stepId) {
+  if (!definitionData || typeof definitionData !== "object") return [];
+  const steps = definitionData.steps;
+  if (!Array.isArray(steps)) return [];
+  const step = steps.find(
+    (candidate) => !!candidate && typeof candidate === "object" && candidate.stepId === stepId
+  );
+  const authored = step?.userTaskConfig?.decisions;
+  if (!Array.isArray(authored)) return [];
+  const decisions = [];
+  for (const entry of authored) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const candidate = entry;
+    if (typeof candidate.id !== "string" || !candidate.id.length) continue;
+    if (typeof candidate.transitionId !== "string" || !candidate.transitionId.length) continue;
+    decisions.push(candidate);
+  }
+  return decisions;
+}
+export {
+  TASK_DECISION_FORM_KEY,
+  findTaskDecision,
+  findTaskDecisionTransition,
+  readAuthoredTaskDecisions,
+  readRecordedDecision,
+  withRecordedDecision
+};
+//# sourceMappingURL=task-decisions.js.map

package/dist/modules/workflows/lib/task-decisions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/task-decisions.ts"],
+  "sourcesContent": ["/**\n * Decision buttons on a task: the CHOICE and the routing rules (PURE).\n *\n * Rendering the list and recording the press are two different requirements\n * wearing one name, and they are stored differently on purpose (run checkpoint\n * 2, decision #2):\n *\n * - **The list is derived state.** A task reaches its config through\n *   `workflowInstanceId -> definition -> step.userTaskConfig.decisions`, and an\n *   instance PINS its definition row, so re-resolving it per request is always\n *   correct and needs no column. `lib/task-decision-context.ts` does that\n *   resolution (it needs the ORM); everything here stays free of it so the task\n *   surfaces can import the reserved key and the readers without dragging the\n *   entity graph into a client bundle.\n * - **The choice is an audit fact about the completion**, with a different\n *   lifetime from the list. It is written into the completion payload that\n *   already exists (`user_tasks.form_data`, under `TASK_DECISION_FORM_KEY`) and\n *   into the `USER_TASK_COMPLETED` event, rather than into a new column.\n */\n\nimport type { TaskDecision } from '../data/validators'\nimport { excludeNonNormalTransitions } from './route-kinds'\nimport type { ResolvedTaskDecision } from './task-resolution'\n\n/**\n * Reserved key the chosen decision id is recorded under inside the completion\n * `formData`. Prefixed like the engine's other reserved context key\n * (`context.__error`) so it cannot collide with an authored form field, and so\n * a downstream route condition can branch on the operator's choice once the\n * form data is merged into the run context.\n */\nexport const TASK_DECISION_FORM_KEY = '__decision'\n\nexport type TaskDecisionTransitionLike = {\n  transitionId?: string\n  fromStepId?: string\n  toStepId?: string\n  kind?: string\n}\n\nexport function findTaskDecision(\n  decisions: ResolvedTaskDecision[],\n  decisionId: string,\n): ResolvedTaskDecision | null {\n  return decisions.find((decision) => decision.id === decisionId) ?? null\n}\n\n/**\n * The outgoing route a decision selects.\n *\n * Matched on the transition's DURABLE id and constrained to routes leaving the\n * step the task is parked on \u2014 a decision may never send the run down a route\n * that does not start where the run currently is. Error routes are excluded for\n * the same reason every other routing lookup excludes them: they are reachable\n * only from a failure, never from a button.\n */\nexport function findTaskDecisionTransition<T extends TaskDecisionTransitionLike>(\n  transitions: T[] | undefined | null,\n  transitionId: string,\n  fromStepId: string,\n): T | null {\n  if (!transitions?.length) return null\n  const candidates = excludeNonNormalTransitions(transitions)\n  return (\n    candidates.find(\n      (transition) =>\n        transition.transitionId === transitionId && transition.fromStepId === fromStepId,\n    ) ?? null\n  )\n}\n\n/** Record the chosen decision inside the completion payload that already exists. */\nexport function withRecordedDecision(\n  formData: Record<string, unknown>,\n  decisionId: string | null | undefined,\n): Record<string, unknown> {\n  if (!decisionId) return formData\n  return { ...formData, [TASK_DECISION_FORM_KEY]: decisionId }\n}\n\n/** The decision id a completed task recorded, when it recorded one. */\nexport function readRecordedDecision(formData: unknown): string | null {\n  if (!formData || typeof formData !== 'object' || Array.isArray(formData)) return null\n  const value = (formData as Record<string, unknown>)[TASK_DECISION_FORM_KEY]\n  return typeof value === 'string' && value.length > 0 ? value : null\n}\n\n/**\n * Decisions as authored, narrowed structurally.\n *\n * A definition row is validated on save, but code-registry definitions never\n * pass through zod, so an entry missing its id or its route binding is dropped\n * here rather than rendered as a button that can only fail.\n */\nexport function readAuthoredTaskDecisions(definitionData: unknown, stepId: string): TaskDecision[] {\n  if (!definitionData || typeof definitionData !== 'object') return []\n  const steps = (definitionData as { steps?: unknown }).steps\n  if (!Array.isArray(steps)) return []\n  const step = steps.find(\n    (candidate) =>\n      !!candidate &&\n      typeof candidate === 'object' &&\n      (candidate as { stepId?: unknown }).stepId === stepId,\n  ) as { userTaskConfig?: { decisions?: unknown } } | undefined\n  const authored = step?.userTaskConfig?.decisions\n  if (!Array.isArray(authored)) return []\n\n  const decisions: TaskDecision[] = []\n  for (const entry of authored) {\n    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue\n    const candidate = entry as Record<string, unknown>\n    if (typeof candidate.id !== 'string' || !candidate.id.length) continue\n    if (typeof candidate.transitionId !== 'string' || !candidate.transitionId.length) continue\n    decisions.push(candidate as unknown as TaskDecision)\n  }\n  return decisions\n}\n"],
+  "mappings": "AAqBA,SAAS,mCAAmC;AAUrC,MAAM,yBAAyB;AAS/B,SAAS,iBACd,WACA,YAC6B;AAC7B,SAAO,UAAU,KAAK,CAAC,aAAa,SAAS,OAAO,UAAU,KAAK;AACrE;AAWO,SAAS,2BACd,aACA,cACA,YACU;AACV,MAAI,CAAC,aAAa,OAAQ,QAAO;AACjC,QAAM,aAAa,4BAA4B,WAAW;AAC1D,SACE,WAAW;AAAA,IACT,CAAC,eACC,WAAW,iBAAiB,gBAAgB,WAAW,eAAe;AAAA,EAC1E,KAAK;AAET;AAGO,SAAS,qBACd,UACA,YACyB;AACzB,MAAI,CAAC,WAAY,QAAO;AACxB,SAAO,EAAE,GAAG,UAAU,CAAC,sBAAsB,GAAG,WAAW;AAC7D;AAGO,SAAS,qBAAqB,UAAkC;AACrE,MAAI,CAAC,YAAY,OAAO,aAAa,YAAY,MAAM,QAAQ,QAAQ,EAAG,QAAO;AACjF,QAAM,QAAS,SAAqC,sBAAsB;AAC1E,SAAO,OAAO,UAAU,YAAY,MAAM,SAAS,IAAI,QAAQ;AACjE;AASO,SAAS,0BAA0B,gBAAyB,QAAgC;AACjG,MAAI,CAAC,kBAAkB,OAAO,mBAAmB,SAAU,QAAO,CAAC;AACnE,QAAM,QAAS,eAAuC;AACtD,MAAI,CAAC,MAAM,QAAQ,KAAK,EAAG,QAAO,CAAC;AACnC,QAAM,OAAO,MAAM;AAAA,IACjB,CAAC,cACC,CAAC,CAAC,aACF,OAAO,cAAc,YACpB,UAAmC,WAAW;AAAA,EACnD;AACA,QAAM,WAAW,MAAM,gBAAgB;AACvC,MAAI,CAAC,MAAM,QAAQ,QAAQ,EAAG,QAAO,CAAC;AAEtC,QAAM,YAA4B,CAAC;AACnC,aAAW,SAAS,UAAU;AAC5B,QAAI,CAAC,SAAS,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,EAAG;AACjE,UAAM,YAAY;AAClB,QAAI,OAAO,UAAU,OAAO,YAAY,CAAC,UAAU,GAAG,OAAQ;AAC9D,QAAI,OAAO,UAAU,iBAAiB,YAAY,CAAC,UAAU,aAAa,OAAQ;AAClF,cAAU,KAAK,SAAoC;AAAA,EACrD;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/modules/workflows/lib/task-entity-access.js

@@ -0,0 +1,62 @@
+import { classifyRecordsEntity } from "@open-mercato/core/modules/entities/lib/entityClassification";
+import { resolveEntityAclRequirement } from "@open-mercato/core/modules/entities/lib/entityAcl";
+import {
+  RECORDS_VIEW_FEATURE,
+  deriveCustomEntityRecordFeature
+} from "@open-mercato/core/modules/entities/lib/recordFeatures";
+import {
+  normalizeTaskEntityTypeSpelling,
+  normalizeTaskEntityTypeToEntityId
+} from "./task-entity-types.js";
+function collectTaskEntityTypes(tasks) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const task of tasks) {
+    for (const binding of task.entityBindings ?? []) {
+      const entityType = binding?.entityType;
+      if (typeof entityType === "string" && entityType.length > 0) seen.add(entityType);
+    }
+  }
+  return [...seen];
+}
+function customEntityRequirement(entityId, restricted) {
+  return restricted ? {
+    kind: "requires",
+    features: [RECORDS_VIEW_FEATURE, deriveCustomEntityRecordFeature(entityId, "view")]
+  } : { kind: "requires", features: [RECORDS_VIEW_FEATURE] };
+}
+async function decideEntityType(entityType, em, scope) {
+  const entityId = normalizeTaskEntityTypeToEntityId(entityType);
+  if (!entityId) {
+    const spelling = normalizeTaskEntityTypeSpelling(entityType);
+    const fallback = await classifyRecordsEntity(em, spelling, scope);
+    if (fallback.kind !== "custom") return { kind: "unknown-entity-type" };
+    return customEntityRequirement(spelling, fallback.restricted);
+  }
+  const classification = await classifyRecordsEntity(em, entityId, scope);
+  if (classification.kind === "custom") return customEntityRequirement(entityId, classification.restricted);
+  if (classification.kind === "system") {
+    const requirement = resolveEntityAclRequirement(entityId);
+    if (!requirement || requirement.platformOnly) return { kind: "unavailable" };
+    return { kind: "requires", features: requirement.view };
+  }
+  return { kind: "unavailable" };
+}
+async function resolveTaskEntityAccess(input) {
+  const distinct = [...new Set(input.entityTypes)];
+  const acl = await input.rbac.loadAcl(input.userId, input.scope);
+  const isSuperAdmin = acl?.isSuperAdmin === true;
+  const grantedFeatures = acl?.features ?? [];
+  const map = /* @__PURE__ */ new Map();
+  for (const entityType of distinct) {
+    map.set(
+      entityType,
+      isSuperAdmin ? { kind: "requires", features: [] } : await decideEntityType(entityType, input.em, input.scope)
+    );
+  }
+  return { map, isSuperAdmin, grantedFeatures };
+}
+export {
+  collectTaskEntityTypes,
+  resolveTaskEntityAccess
+};
+//# sourceMappingURL=task-entity-access.js.map

package/dist/modules/workflows/lib/task-entity-access.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/task-entity-access.ts"],
+  "sourcesContent": ["/**\n * Builds the `TaskEntityAccessMap` the visibility predicate consumes \u2014 the\n * impure half of the entity gate.\n *\n * ## What \"entity access\" means here, exactly\n *\n * **Entity TYPE plus scope. There is no record-level ACL in this platform and\n * this resolver does not add one.** The query engine's public interface is\n * `query(entity, opts)` with no ACL seam anywhere in it, and the only per-record\n * rule in the repo is `assertCanAccessChannel`, a bespoke owner comparison over\n * an already-loaded row. So the guarantee this makes is: *you may see a task\n * about a deal iff you may see deals at all, and the task is inside your tenant\n * and organization.* A user who can see deals can see a task about ANY deal in\n * their organization, including one they would never have opened themselves.\n * Do not read more into it, and do not let a caller document it as row-level.\n *\n * Verifying each BOUND RECORD's own organization would cost one query per\n * (entity type, id) per row, and there is no generic `(entityType, recordId) \u2192\n * record` resolver to do it with. Accepted residual risk, on the review\n * checklist. The portal path does not accept it \u2014 there the record identity is\n * compared directly against the caller's owned ids.\n *\n * ## Cost\n *\n * ONE `loadAcl` and ONE classification pass per REQUEST, keyed on the distinct\n * entity types across the whole page. `assertEntityAclForRequest` calls\n * `rbac.loadAcl` on every invocation, so calling it per binding would issue ~100\n * ACL loads for a 50-row inbox page with two bindings each.\n *\n * ## Failure\n *\n * Nothing here is caught. A resolver that throws must fail the whole request \u2014\n * degrading to an empty map would leave the predicate with no key for any\n * binding, and while that denies today, \"swallow the error and carry on\" is the\n * shape of bug that later becomes \"swallow the error and pass\". Absence of data\n * is not failure: a task with no bindings asks nothing of this map.\n */\n\nimport type { EntityManager } from '@mikro-orm/core'\nimport { classifyRecordsEntity } from '@open-mercato/core/modules/entities/lib/entityClassification'\nimport { resolveEntityAclRequirement } from '@open-mercato/core/modules/entities/lib/entityAcl'\nimport {\n  RECORDS_VIEW_FEATURE,\n  deriveCustomEntityRecordFeature,\n} from '@open-mercato/core/modules/entities/lib/recordFeatures'\nimport {\n  normalizeTaskEntityTypeSpelling,\n  normalizeTaskEntityTypeToEntityId,\n} from './task-entity-types'\nimport type { TaskEntityAccessDecision, TaskEntityAccessMap } from './task-visibility'\n\nexport type TaskEntityAccessScope = { tenantId: string | null; organizationId: string | null }\n\nexport type TaskEntityAccessAcl = {\n  isSuperAdmin: boolean\n  features: string[]\n}\n\n/** The slice of `RbacService` this resolver needs, so tests need no container. */\nexport type TaskEntityAccessRbacService = {\n  loadAcl(userId: string, scope: TaskEntityAccessScope): Promise<TaskEntityAccessAcl | null>\n}\n\nexport type ResolveTaskEntityAccessInput = {\n  /** Distinct authored `entityType` values across the page. Deduped here. */\n  entityTypes: Iterable<string>\n  em: EntityManager\n  rbac: TaskEntityAccessRbacService\n  userId: string\n  scope: TaskEntityAccessScope\n}\n\nexport type TaskEntityAccessResult = {\n  map: TaskEntityAccessMap\n  /**\n   * Returned alongside the map because the caller needs both to build the\n   * principal, and loading the ACL twice per request is the cost this resolver\n   * exists to avoid.\n   */\n  isSuperAdmin: boolean\n  grantedFeatures: string[]\n}\n\ntype BoundTask = { entityBindings?: readonly { entityType?: unknown }[] | null }\n\n/**\n * The distinct authored entity types across a page of tasks, verbatim.\n *\n * Verbatim matters: the map is keyed on exactly the string the binding carries,\n * so the predicate's lookup is an identity match and \"no key\" unambiguously\n * means the resolver never saw that type. Normalization happens INSIDE the\n * resolver, where a normalization failure has a `unknown-entity-type` answer to\n * record.\n */\nexport function collectTaskEntityTypes(tasks: Iterable<BoundTask>): string[] {\n  const seen = new Set<string>()\n  for (const task of tasks) {\n    for (const binding of task.entityBindings ?? []) {\n      const entityType = binding?.entityType\n      if (typeof entityType === 'string' && entityType.length > 0) seen.add(entityType)\n    }\n  }\n  return [...seen]\n}\n\n/**\n * Mirrors `assertEntityAclForRequest`: an unrestricted custom entity is\n * authorized by the coarse route-level feature alone; a restricted one also\n * needs its synthesized per-entity grant.\n */\nfunction customEntityRequirement(entityId: string, restricted: boolean): TaskEntityAccessDecision {\n  return restricted\n    ? {\n        kind: 'requires',\n        features: [RECORDS_VIEW_FEATURE, deriveCustomEntityRecordFeature(entityId, 'view')],\n      }\n    : { kind: 'requires', features: [RECORDS_VIEW_FEATURE] }\n}\n\nasync function decideEntityType(\n  entityType: string,\n  em: EntityManager,\n  scope: TaskEntityAccessScope,\n): Promise<TaskEntityAccessDecision> {\n  const entityId = normalizeTaskEntityTypeToEntityId(entityType)\n\n  if (!entityId) {\n    // A TENANT-CREATED custom entity (a `custom_entities` row, not a module's\n    // `ce.ts`) is absent from the generated registry, so normalization cannot\n    // vouch for it and refusing here would hide every task bound to one. Ask the\n    // classifier instead: a real registration inside the caller's own scope is\n    // proof enough, and anything the classifier does not recognize either is a\n    // genuine authored typo \u2014 reported as its own reason so the Problems panel\n    // can name it rather than leaving an author staring at an invisible task.\n    const spelling = normalizeTaskEntityTypeSpelling(entityType)\n    const fallback = await classifyRecordsEntity(em, spelling, scope)\n    if (fallback.kind !== 'custom') return { kind: 'unknown-entity-type' }\n    return customEntityRequirement(spelling, fallback.restricted)\n  }\n\n  const classification = await classifyRecordsEntity(em, entityId, scope)\n\n  if (classification.kind === 'custom') return customEntityRequirement(entityId, classification.restricted)\n\n  if (classification.kind === 'system') {\n    const requirement = resolveEntityAclRequirement(entityId)\n    // No entry, or a platform-only entity: `entityAcl.ts` answers 403 for both,\n    // and so does this.\n    if (!requirement || requirement.platformOnly) return { kind: 'unavailable' }\n    return { kind: 'requires', features: requirement.view }\n  }\n\n  return { kind: 'unavailable' }\n}\n\n/**\n * Resolve, once per request, what each bound entity type requires of the caller.\n *\n * The map carries REQUIREMENTS, not verdicts \u2014 the wildcard-aware match happens\n * in the predicate, so there is exactly one place that decides anything. A\n * superadmin is the single exception: they short-circuit the entity gate in\n * `entityAcl.ts` too, so every type resolves to an empty requirement.\n */\nexport async function resolveTaskEntityAccess(\n  input: ResolveTaskEntityAccessInput,\n): Promise<TaskEntityAccessResult> {\n  const distinct = [...new Set(input.entityTypes)]\n  const acl = await input.rbac.loadAcl(input.userId, input.scope)\n  const isSuperAdmin = acl?.isSuperAdmin === true\n  const grantedFeatures = acl?.features ?? []\n\n  const map = new Map<string, TaskEntityAccessDecision>()\n  for (const entityType of distinct) {\n    map.set(\n      entityType,\n      isSuperAdmin ? { kind: 'requires', features: [] } : await decideEntityType(entityType, input.em, input.scope),\n    )\n  }\n\n  return { map, isSuperAdmin, grantedFeatures }\n}\n"],
+  "mappings": "AAuCA,SAAS,6BAA6B;AACtC,SAAS,mCAAmC;AAC5C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AA8CA,SAAS,uBAAuB,OAAsC;AAC3E,QAAM,OAAO,oBAAI,IAAY;AAC7B,aAAW,QAAQ,OAAO;AACxB,eAAW,WAAW,KAAK,kBAAkB,CAAC,GAAG;AAC/C,YAAM,aAAa,SAAS;AAC5B,UAAI,OAAO,eAAe,YAAY,WAAW,SAAS,EAAG,MAAK,IAAI,UAAU;AAAA,IAClF;AAAA,EACF;AACA,SAAO,CAAC,GAAG,IAAI;AACjB;AAOA,SAAS,wBAAwB,UAAkB,YAA+C;AAChG,SAAO,aACH;AAAA,IACE,MAAM;AAAA,IACN,UAAU,CAAC,sBAAsB,gCAAgC,UAAU,MAAM,CAAC;AAAA,EACpF,IACA,EAAE,MAAM,YAAY,UAAU,CAAC,oBAAoB,EAAE;AAC3D;AAEA,eAAe,iBACb,YACA,IACA,OACmC;AACnC,QAAM,WAAW,kCAAkC,UAAU;AAE7D,MAAI,CAAC,UAAU;AAQb,UAAM,WAAW,gCAAgC,UAAU;AAC3D,UAAM,WAAW,MAAM,sBAAsB,IAAI,UAAU,KAAK;AAChE,QAAI,SAAS,SAAS,SAAU,QAAO,EAAE,MAAM,sBAAsB;AACrE,WAAO,wBAAwB,UAAU,SAAS,UAAU;AAAA,EAC9D;AAEA,QAAM,iBAAiB,MAAM,sBAAsB,IAAI,UAAU,KAAK;AAEtE,MAAI,eAAe,SAAS,SAAU,QAAO,wBAAwB,UAAU,eAAe,UAAU;AAExG,MAAI,eAAe,SAAS,UAAU;AACpC,UAAM,cAAc,4BAA4B,QAAQ;AAGxD,QAAI,CAAC,eAAe,YAAY,aAAc,QAAO,EAAE,MAAM,cAAc;AAC3E,WAAO,EAAE,MAAM,YAAY,UAAU,YAAY,KAAK;AAAA,EACxD;AAEA,SAAO,EAAE,MAAM,cAAc;AAC/B;AAUA,eAAsB,wBACpB,OACiC;AACjC,QAAM,WAAW,CAAC,GAAG,IAAI,IAAI,MAAM,WAAW,CAAC;AAC/C,QAAM,MAAM,MAAM,MAAM,KAAK,QAAQ,MAAM,QAAQ,MAAM,KAAK;AAC9D,QAAM,eAAe,KAAK,iBAAiB;AAC3C,QAAM,kBAAkB,KAAK,YAAY,CAAC;AAE1C,QAAM,MAAM,oBAAI,IAAsC;AACtD,aAAW,cAAc,UAAU;AACjC,QAAI;AAAA,MACF;AAAA,MACA,eAAe,EAAE,MAAM,YAAY,UAAU,CAAC,EAAE,IAAI,MAAM,iBAAiB,YAAY,MAAM,IAAI,MAAM,KAAK;AAAA,IAC9G;AAAA,EACF;AAEA,SAAO,EAAE,KAAK,cAAc,gBAAgB;AAC9C;",
+  "names": []
+}

package/dist/modules/workflows/lib/task-entity-aliases.js

@@ -0,0 +1,39 @@
+const TASK_ENTITY_TYPE_ALIAS_GROUPS = [
+  {
+    entityId: "customers:customer_person_profile",
+    spellings: ["customers:person", "customers:people", "customers:customer_person_profile"]
+  },
+  {
+    entityId: "customers:customer_company_profile",
+    spellings: ["customers:company", "customers:companies", "customers:customer_company_profile"]
+  },
+  {
+    entityId: "customers:customer_deal",
+    spellings: ["customers:deal", "customers:deals", "customers:customer_deal"]
+  },
+  {
+    entityId: "sales:sales_order",
+    spellings: ["sales:order", "sales:orders", "sales:sales_order", "sales:document"]
+  }
+];
+const ALIAS_LOOKUP = new Map(
+  TASK_ENTITY_TYPE_ALIAS_GROUPS.flatMap(
+    (group) => group.spellings.map((spelling) => [spelling, group.entityId])
+  )
+);
+function normalizeTaskEntityTypeSpelling(entityType) {
+  return entityType.trim().toLowerCase().replace(/\./g, ":");
+}
+function resolveAliasedTaskEntityId(entityType) {
+  return ALIAS_LOOKUP.get(normalizeTaskEntityTypeSpelling(entityType)) ?? null;
+}
+function listTaskEntityTypeAliases() {
+  return ALIAS_LOOKUP;
+}
+export {
+  TASK_ENTITY_TYPE_ALIAS_GROUPS,
+  listTaskEntityTypeAliases,
+  normalizeTaskEntityTypeSpelling,
+  resolveAliasedTaskEntityId
+};
+//# sourceMappingURL=task-entity-aliases.js.map

package/dist/modules/workflows/lib/task-entity-aliases.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/task-entity-aliases.ts"],
+  "sourcesContent": ["/**\n * The ONE alias dictionary for authored task `entityType` values (PURE \u2014 zero\n * imports, safe in a client bundle).\n *\n * A binding's `entityType` is free text: the inspector offers `customers:person`\n * as a placeholder and stores whatever the author typed, while the ACL\n * requirement table and the entity registry are keyed on the GENERATED id\n * (`customers:customer_person_profile`). Two consumers need the same spellings \u2014\n * `task-entity-types.ts` resolves them to an entity id for the visibility gate,\n * `work-inbox/entity-links.ts` resolves them to a record deep link \u2014 and they\n * read this table rather than each keeping a copy. The repo already carries\n * divergent alias tables in `customers/ai-agents-context.ts` and the\n * optimistic-lock `resourceKind` readers; a fourth one is not acceptable.\n *\n * It lives in its own module, with nothing imported, so the client-side deep\n * link code never pulls the entity registry in behind it.\n */\n\nexport type TaskEntityTypeAliasGroup = {\n  /** The generated entity id every spelling in the group means. */\n  entityId: string\n  /** Normalized spellings (`module:entity`, lower case) that authors write. */\n  spellings: readonly string[]\n}\n\n/**\n * Alternate spellings that unambiguously mean one generated entity id.\n *\n * `customers:customer_entity` is deliberately absent \u2014 it backs both people and\n * companies, so no single id is the right answer and leaving a binding on it\n * unresolvable is the correct outcome.\n */\nexport const TASK_ENTITY_TYPE_ALIAS_GROUPS: readonly TaskEntityTypeAliasGroup[] = [\n  {\n    entityId: 'customers:customer_person_profile',\n    spellings: ['customers:person', 'customers:people', 'customers:customer_person_profile'],\n  },\n  {\n    entityId: 'customers:customer_company_profile',\n    spellings: ['customers:company', 'customers:companies', 'customers:customer_company_profile'],\n  },\n  {\n    entityId: 'customers:customer_deal',\n    spellings: ['customers:deal', 'customers:deals', 'customers:customer_deal'],\n  },\n  {\n    entityId: 'sales:sales_order',\n    spellings: ['sales:order', 'sales:orders', 'sales:sales_order', 'sales:document'],\n  },\n]\n\nconst ALIAS_LOOKUP: ReadonlyMap<string, string> = new Map(\n  TASK_ENTITY_TYPE_ALIAS_GROUPS.flatMap((group) =>\n    group.spellings.map((spelling) => [spelling, group.entityId] as const),\n  ),\n)\n\n/**\n * `Customers.Person` / `customers.person` / ` customers:person ` \u2192\n * `customers:person`.\n *\n * Entity ids are written `module:entity` while record-detail injection contexts\n * use `module.entity` (`resourceKind`), and authors type both.\n */\nexport function normalizeTaskEntityTypeSpelling(entityType: string): string {\n  return entityType.trim().toLowerCase().replace(/\\./g, ':')\n}\n\n/** The generated entity id an enumerated spelling means, or `null`. */\nexport function resolveAliasedTaskEntityId(entityType: string): string | null {\n  return ALIAS_LOOKUP.get(normalizeTaskEntityTypeSpelling(entityType)) ?? null\n}\n\n/** Every enumerated spelling, mapped to its generated entity id. */\nexport function listTaskEntityTypeAliases(): ReadonlyMap<string, string> {\n  return ALIAS_LOOKUP\n}\n"],
+  "mappings": "AAgCO,MAAM,gCAAqE;AAAA,EAChF;AAAA,IACE,UAAU;AAAA,IACV,WAAW,CAAC,oBAAoB,oBAAoB,mCAAmC;AAAA,EACzF;AAAA,EACA;AAAA,IACE,UAAU;AAAA,IACV,WAAW,CAAC,qBAAqB,uBAAuB,oCAAoC;AAAA,EAC9F;AAAA,EACA;AAAA,IACE,UAAU;AAAA,IACV,WAAW,CAAC,kBAAkB,mBAAmB,yBAAyB;AAAA,EAC5E;AAAA,EACA;AAAA,IACE,UAAU;AAAA,IACV,WAAW,CAAC,eAAe,gBAAgB,qBAAqB,gBAAgB;AAAA,EAClF;AACF;AAEA,MAAM,eAA4C,IAAI;AAAA,EACpD,8BAA8B;AAAA,IAAQ,CAAC,UACrC,MAAM,UAAU,IAAI,CAAC,aAAa,CAAC,UAAU,MAAM,QAAQ,CAAU;AAAA,EACvE;AACF;AASO,SAAS,gCAAgC,YAA4B;AAC1E,SAAO,WAAW,KAAK,EAAE,YAAY,EAAE,QAAQ,OAAO,GAAG;AAC3D;AAGO,SAAS,2BAA2B,YAAmC;AAC5E,SAAO,aAAa,IAAI,gCAAgC,UAAU,CAAC,KAAK;AAC1E;AAGO,SAAS,4BAAyD;AACvE,SAAO;AACT;",
+  "names": []
+}