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

package/dist/modules/workflows/lib/metrics/definition-metrics.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/modules/workflows/lib/metrics/definition-metrics.ts"],
+  "sourcesContent": ["/**\n * Per-definition operational KPIs (spec \u00A78.5) \u2014 the PURE arithmetic half.\n *\n * This module contains no ORM, DI, React or registry import, so every rule it\n * encodes is unit-testable without a database. `lib/metrics/rollup-service.ts`\n * owns the queries and the upsert; this file owns what the numbers MEAN.\n *\n * Three honesty rules govern what may appear here:\n *\n * 1. **A metric is computed only from a column the engine actually writes.**\n *    `StepInstance.executionTimeMs` is deliberately NOT used: `exitStep` writes\n *    it on the COMPLETED path only, while every FAILED path\n *    (`step-handler`, `activity-worker-handler`, `condition-handler`) sets\n *    `exitedAt` and leaves it null. A p95 over that column would silently be a\n *    success-only latency wearing the name of a step latency. Run duration is\n *    measured instead, from `startedAt` \u2192 the terminal timestamp, both of which\n *    the engine always writes.\n * 2. **Dry runs never count.** `WorkflowInstance.isDryRun` is the flag\n *    (spec \u00A78.2: \"excludes the instance from KPIs\"); the caller filters on it\n *    and the shapes below carry only already-filtered rows.\n * 3. **A denominator is always reported next to a rate.** `successRate` without\n *    `runsTerminal` and `taskSlaHitRate` without `tasksWithDeadline` are both\n *    unreadable \u2014 100% over one run is not the same claim as 100% over 4,000.\n * 4. **A run that tolerated a failure is not a success.** `successRate` counts\n *    the run's VERDICT, not its lifecycle status: a `partial_failure` reached\n *    END but did not do everything it was asked to. It is reported as its own\n *    number (`runsPartialFailure`) rather than folded into either bucket.\n */\n\nimport type { WorkflowRunOutcome } from '../run-outcome'\n\n/** Rollup window lengths, mirroring `AgentMetricRollup`'s window vocabulary. */\nexport const WORKFLOW_ROLLUP_WINDOW_MS = {\n  '24h': 24 * 60 * 60 * 1000,\n  '7d': 7 * 24 * 60 * 60 * 1000,\n  '30d': 30 * 24 * 60 * 60 * 1000,\n} as const\n\nexport type WorkflowRollupWindowKey = keyof typeof WORKFLOW_ROLLUP_WINDOW_MS\n\nexport const WORKFLOW_ROLLUP_WINDOW_KEYS = Object.keys(\n  WORKFLOW_ROLLUP_WINDOW_MS,\n) as WorkflowRollupWindowKey[]\n\n/**\n * Bucket the window boundaries snap to. Recomputing the SAME `windowStart` is\n * what makes a repeated rollup pass an overwrite rather than a second row, so\n * the bucket \u2014 not the wall clock \u2014 is the row's identity.\n */\nexport const WORKFLOW_ROLLUP_BUCKET_MS = 15 * 60 * 1000\n\n/** Snap a timestamp down to the rollup bucket grid. */\nexport function floorToRollupBucket(epochMs: number): number {\n  return Math.floor(epochMs / WORKFLOW_ROLLUP_BUCKET_MS) * WORKFLOW_ROLLUP_BUCKET_MS\n}\n\n/**\n * Terminal statuses a run can reach.\n *\n * `COMPENSATED` used to be absent because the engine wrote it NO terminal\n * timestamp \u2014 `compensation-handler` flipped the status and `completeWorkflow`\n * returned before its own `completedAt` assignment \u2014 so a compensated run had\n * no instant to attribute to any window. The run-outcome write now stamps that\n * timestamp on the compensating path, so a compensated run finally belongs to\n * the window it terminated in. Rows compensated BEFORE that fix still carry a\n * null timestamp and, exactly as before, fall into no window at all: nothing is\n * backfilled.\n */\nexport const WORKFLOW_TERMINAL_STATUSES = ['COMPLETED', 'FAILED', 'CANCELLED', 'COMPENSATED'] as const\n\nexport type WorkflowTerminalStatus = (typeof WORKFLOW_TERMINAL_STATUSES)[number]\n\n/** One terminal run, already scoped and already dry-run filtered by the caller. */\nexport type TerminalRunSample = {\n  status: string\n  /**\n   * The run's VERDICT (`WorkflowInstance.outcome`), or null for a row written\n   * before outcomes existed. Null is NOT read as `success`: a pre-upgrade\n   * COMPLETED run counts exactly as it did before, so upgrading does not\n   * retroactively rewrite a window's history.\n   */\n  outcome?: WorkflowRunOutcome | null\n  startedAt: Date | null\n  /** `completedAt` for COMPLETED/FAILED/COMPENSATED, `cancelledAt` for CANCELLED. */\n  terminalAt: Date | null\n}\n\n/** One completed task carrying an authored deadline. */\nexport type TaskDeadlineSample = {\n  dueDate: Date | null\n  completedAt: Date | null\n}\n\nexport type DefinitionMetrics = {\n  /** Runs whose `startedAt` falls in the window. */\n  runsStarted: number\n  /** Runs whose terminal timestamp falls in the window \u2014 the rate denominator. */\n  runsTerminal: number\n  runsCompleted: number\n  runsFailed: number\n  runsCancelled: number\n  /**\n   * COMPLETED runs whose verdict is `partial_failure` \u2014 they reached END while\n   * tolerating at least one activity or step failure.\n   *\n   * Its own number, folded into NEITHER bucket. It is not added to `runsFailed`\n   * (the run did reach END, and a failure-queue count that included it would\n   * disagree with the lifecycle) and it is excluded from `successRate`'s\n   * numerator (the work it skipped never happened). It stays in `runsTerminal`,\n   * so the denominators still add up.\n   */\n  runsPartialFailure: number\n  /**\n   * Runs rolled back by compensation. Its own number for the same reason\n   * `runsPartialFailure` is: a compensated run is neither a success nor an\n   * ordinary failure, and folding it into either would misstate both.\n   */\n  runsCompensated: number\n  /**\n   * `(runsCompleted - runsPartialFailure) / runsTerminal`, or null when nothing\n   * terminated.\n   */\n  successRate: number | null\n  /** Terminal runs that also had a usable `startedAt` \u2014 the duration denominator. */\n  durationSampleCount: number\n  avgDurationMs: number | null\n  p50DurationMs: number | null\n  p95DurationMs: number | null\n  /** Completed tasks that carried a `dueDate` \u2014 the SLA denominator. */\n  tasksWithDeadline: number\n  tasksMetDeadline: number\n  /** `tasksMetDeadline / tasksWithDeadline`, or null when no task had a deadline. */\n  taskSlaHitRate: number | null\n}\n\nexport const EMPTY_DEFINITION_METRICS: DefinitionMetrics = {\n  runsStarted: 0,\n  runsTerminal: 0,\n  runsCompleted: 0,\n  runsFailed: 0,\n  runsCancelled: 0,\n  runsPartialFailure: 0,\n  runsCompensated: 0,\n  successRate: null,\n  durationSampleCount: 0,\n  avgDurationMs: null,\n  p50DurationMs: null,\n  p95DurationMs: null,\n  tasksWithDeadline: 0,\n  tasksMetDeadline: 0,\n  taskSlaHitRate: null,\n}\n\n/**\n * Nearest-rank percentile over an unsorted sample; null when empty.\n *\n * Nearest rank (`percentile_disc` semantics) rather than interpolation, for the\n * same reason `agent_orchestrator`'s `percentileOf` chose it: every value it\n * returns is a duration some run actually took, which is what an operator\n * clicking through to that run needs to be true. It is also the variant that\n * behaves sanely on the small samples this rollup normally sees \u2014 a definition\n * with three runs a day has no meaningful interpolant.\n *\n * The rank is `ceil(fraction * n) - 1`, clamped into range, so p95 of a\n * one-element sample is that element and p95 of a 20-element sample is the\n * 19th-largest \u2014 never an off-by-one past the end of the array.\n */\nexport function percentileOf(values: number[], fraction: number): number | null {\n  if (values.length === 0) return null\n  const sorted = [...values].sort((left, right) => left - right)\n  const rank = Math.min(sorted.length - 1, Math.max(0, Math.ceil(fraction * sorted.length) - 1))\n  return sorted[rank]\n}\n\n/** Mean of a sample, rounded to whole milliseconds; null when empty. */\nexport function meanOf(values: number[]): number | null {\n  if (values.length === 0) return null\n  const total = values.reduce((sum, value) => sum + value, 0)\n  return Math.round(total / values.length)\n}\n\n/**\n * A rate reported as a fraction in [0, 1], or null when the denominator is 0.\n *\n * Null rather than 0: \"no runs finished\" and \"every run failed\" are opposite\n * facts and a KPI card that paints both as 0% is worse than one that says it\n * has nothing to show.\n */\nexport function rateOf(numerator: number, denominator: number): number | null {\n  if (denominator <= 0) return null\n  return numerator / denominator\n}\n\n/**\n * Wall-clock run duration, or null when either end is missing or the pair is\n * inverted (a clock skew or a hand-edited row must not contribute a negative\n * sample that drags a mean below zero).\n */\nexport function runDurationMs(run: TerminalRunSample): number | null {\n  if (!run.startedAt || !run.terminalAt) return null\n  const durationMs = run.terminalAt.getTime() - run.startedAt.getTime()\n  if (!Number.isFinite(durationMs) || durationMs < 0) return null\n  return durationMs\n}\n\n/** True when a completed task landed on or before its authored deadline. */\nexport function taskMetDeadline(task: TaskDeadlineSample): boolean {\n  if (!task.dueDate || !task.completedAt) return false\n  return task.completedAt.getTime() <= task.dueDate.getTime()\n}\n\nexport type DefinitionMetricsInput = {\n  runsStarted: number\n  terminalRuns: TerminalRunSample[]\n  completedTasks: TaskDeadlineSample[]\n}\n\n/**\n * Fold the sampled rows into one window's metrics.\n *\n * Pure and total: given the same input it returns the same output, which is\n * precisely what lets the rollup worker recompute a bucket instead of\n * incrementing it.\n */\nexport function buildDefinitionMetrics(input: DefinitionMetricsInput): DefinitionMetrics {\n  const terminalRuns = input.terminalRuns\n  let runsCompleted = 0\n  let runsFailed = 0\n  let runsCancelled = 0\n  let runsPartialFailure = 0\n  let runsCompensated = 0\n  const durations: number[] = []\n\n  for (const run of terminalRuns) {\n    if (run.status === 'COMPLETED') {\n      runsCompleted += 1\n      if (run.outcome === 'partial_failure') runsPartialFailure += 1\n    }\n    else if (run.status === 'FAILED') runsFailed += 1\n    else if (run.status === 'CANCELLED') runsCancelled += 1\n    else if (run.status === 'COMPENSATED') runsCompensated += 1\n    const duration = runDurationMs(run)\n    if (duration !== null) durations.push(duration)\n  }\n\n  const tasksWithDeadline = input.completedTasks.filter((task) => task.dueDate !== null).length\n  const tasksMetDeadline = input.completedTasks.filter(\n    (task) => task.dueDate !== null && taskMetDeadline(task),\n  ).length\n\n  return {\n    runsStarted: input.runsStarted,\n    runsTerminal: terminalRuns.length,\n    runsCompleted,\n    runsFailed,\n    runsCancelled,\n    runsPartialFailure,\n    runsCompensated,\n    successRate: rateOf(runsCompleted - runsPartialFailure, terminalRuns.length),\n    durationSampleCount: durations.length,\n    avgDurationMs: meanOf(durations),\n    p50DurationMs: percentileOf(durations, 0.5),\n    p95DurationMs: percentileOf(durations, 0.95),\n    tasksWithDeadline,\n    tasksMetDeadline,\n    taskSlaHitRate: rateOf(tasksMetDeadline, tasksWithDeadline),\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/workflows/lib/metrics/metrics-display.js

@@ -0,0 +1,26 @@
+const METRIC_RATE_GOOD = 0.95;
+const METRIC_RATE_FAIR = 0.8;
+function rateTone(rate) {
+  if (rate === null) return "neutral";
+  if (rate >= METRIC_RATE_GOOD) return "success";
+  if (rate >= METRIC_RATE_FAIR) return "warning";
+  return "error";
+}
+function formatRate(rate) {
+  if (rate === null) return null;
+  return `${Math.round(rate * 100)}%`;
+}
+const METRIC_TONE_CLASS = {
+  success: "text-status-success-text",
+  warning: "text-status-warning-text",
+  error: "text-status-error-text",
+  neutral: "text-muted-foreground"
+};
+export {
+  METRIC_RATE_FAIR,
+  METRIC_RATE_GOOD,
+  METRIC_TONE_CLASS,
+  formatRate,
+  rateTone
+};
+//# sourceMappingURL=metrics-display.js.map

package/dist/modules/workflows/lib/metrics/metrics-display.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/modules/workflows/lib/metrics/metrics-display.ts"],
+  "sourcesContent": ["/**\n * Presentation rules for the per-definition KPIs (spec \u00A78.5) \u2014 PURE.\n *\n * Separate from the arithmetic so \"what does a 60% success rate LOOK like\" is\n * testable without a canvas, and separate from the cell component so the\n * thresholds live in one place rather than in three `className` ternaries.\n */\n\nexport type MetricTone = 'success' | 'warning' | 'error' | 'neutral'\n\n/**\n * Thresholds for the success-rate and SLA-hit-rate tones.\n *\n * Deliberately generous at the top: a workflow that fails one run in twenty is\n * not healthy, and painting 95% green would make the column decorative.\n */\nexport const METRIC_RATE_GOOD = 0.95\nexport const METRIC_RATE_FAIR = 0.8\n\n/**\n * Tone for a rate in [0, 1].\n *\n * `null` \u2014 no denominator \u2014 is NEUTRAL, never an error tone: \"nothing terminated in\n * this window\" is not a failure, and a red cell would send an operator hunting\n * for a problem that does not exist.\n */\nexport function rateTone(rate: number | null): MetricTone {\n  if (rate === null) return 'neutral'\n  if (rate >= METRIC_RATE_GOOD) return 'success'\n  if (rate >= METRIC_RATE_FAIR) return 'warning'\n  return 'error'\n}\n\n/**\n * A rate as a whole-percent string, or `null` when there is no denominator.\n *\n * Whole percents because the underlying sample is usually tens of runs, where a\n * decimal place implies a precision the sample does not have.\n */\nexport function formatRate(rate: number | null): string | null {\n  if (rate === null) return null\n  return `${Math.round(rate * 100)}%`\n}\n\n/**\n * DS token classes per tone.\n *\n * Colour is never the only carrier \u2014 every cell using these also renders the\n * number itself and an `sr-only` name \u2014 but the tone still has to come from\n * status tokens rather than raw Tailwind shades.\n */\nexport const METRIC_TONE_CLASS: Record<MetricTone, string> = {\n  success: 'text-status-success-text',\n  warning: 'text-status-warning-text',\n  error: 'text-status-error-text',\n  neutral: 'text-muted-foreground',\n}\n"],
+  "mappings": "AAgBO,MAAM,mBAAmB;AACzB,MAAM,mBAAmB;AASzB,SAAS,SAAS,MAAiC;AACxD,MAAI,SAAS,KAAM,QAAO;AAC1B,MAAI,QAAQ,iBAAkB,QAAO;AACrC,MAAI,QAAQ,iBAAkB,QAAO;AACrC,SAAO;AACT;AAQO,SAAS,WAAW,MAAoC;AAC7D,MAAI,SAAS,KAAM,QAAO;AAC1B,SAAO,GAAG,KAAK,MAAM,OAAO,GAAG,CAAC;AAClC;AASO,MAAM,oBAAgD;AAAA,EAC3D,SAAS;AAAA,EACT,SAAS;AAAA,EACT,OAAO;AAAA,EACP,SAAS;AACX;",
+  "names": []
+}

package/dist/modules/workflows/lib/metrics/rollup-schedule.js

@@ -0,0 +1,7 @@
+const WORKFLOW_DEFINITION_METRIC_ROLLUP_QUEUE = "workflow-definition-metric-rollup";
+const WORKFLOW_DEFINITION_METRIC_ROLLUP_INTERVAL = "900s";
+export {
+  WORKFLOW_DEFINITION_METRIC_ROLLUP_INTERVAL,
+  WORKFLOW_DEFINITION_METRIC_ROLLUP_QUEUE
+};
+//# sourceMappingURL=rollup-schedule.js.map

package/dist/modules/workflows/lib/metrics/rollup-schedule.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/modules/workflows/lib/metrics/rollup-schedule.ts"],
+  "sourcesContent": ["/**\n * Scheduling constants for the per-definition KPI rollup (spec \u00A78.5).\n *\n * Kept in their own module so `setup.ts` can import them without dragging in\n * the ORM entities that `rollup-service.ts` pulls: tenant setup runs on a path\n * where importing the whole engine would be a needless cost.\n */\n\n/**\n * Queue the scheduled tick targets. Duplicated as a string literal in\n * `workers/workflow-definition-metric-rollup.worker.ts` because the generator's\n * AST extractor cannot resolve an imported queue name \u2014 see the NOTE there.\n * `workers/__tests__/definition-metric-rollup.worker.test.ts` asserts the two\n * spellings stay identical, so the duplication cannot drift.\n */\nexport const WORKFLOW_DEFINITION_METRIC_ROLLUP_QUEUE = 'workflow-definition-metric-rollup'\n\n/**\n * How often a rollup pass runs, as a `@open-mercato/scheduler` interval.\n *\n * Matched to `WORKFLOW_ROLLUP_BUCKET_MS` (15 minutes): ticking faster than the\n * bucket only rewrites the same row with the same numbers, and ticking slower\n * leaves buckets with no row at all, which the read route then has to\n * live-compute.\n */\nexport const WORKFLOW_DEFINITION_METRIC_ROLLUP_INTERVAL = '900s'\n"],
+  "mappings": "AAeO,MAAM,0CAA0C;AAUhD,MAAM,6CAA6C;",
+  "names": []
+}

package/dist/modules/workflows/lib/metrics/rollup-service.js

@@ -0,0 +1,160 @@
+import { createLogger } from "@open-mercato/shared/lib/logger";
+import { UserTask, WorkflowDefinitionMetricRollup, WorkflowInstance } from "../../data/entities.js";
+import {
+  WORKFLOW_ROLLUP_WINDOW_KEYS,
+  WORKFLOW_ROLLUP_WINDOW_MS,
+  WORKFLOW_TERMINAL_STATUSES,
+  buildDefinitionMetrics,
+  floorToRollupBucket
+} from "./definition-metrics.js";
+const logger = createLogger("workflows");
+function organizationFilter(scope) {
+  return scope.organizationIds ? { organizationId: { $in: scope.organizationIds } } : {};
+}
+const ROLLUP_DURATION_SAMPLE_LIMIT = 5e3;
+const ROLLUP_TASK_SAMPLE_LIMIT = 5e3;
+function resolveWindowBounds(nowMs) {
+  const windowEndMs = floorToRollupBucket(nowMs);
+  return WORKFLOW_ROLLUP_WINDOW_KEYS.map((windowKey) => ({
+    windowKey,
+    windowStart: new Date(windowEndMs - WORKFLOW_ROLLUP_WINDOW_MS[windowKey]),
+    windowEnd: new Date(windowEndMs)
+  }));
+}
+async function listActiveWorkflowIds(em, scope, since) {
+  const rows = await em.find(
+    WorkflowInstance,
+    {
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      isDryRun: false,
+      deletedAt: null,
+      startedAt: { $gte: since }
+    },
+    { fields: ["workflowId"] }
+  );
+  return Array.from(new Set(rows.map((row) => row.workflowId))).sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+async function computeDefinitionMetrics(em, scope, args) {
+  const baseScope = {
+    tenantId: scope.tenantId,
+    ...organizationFilter(scope),
+    workflowId: args.workflowId,
+    isDryRun: false,
+    deletedAt: null
+  };
+  const window = { $gte: args.windowStart, $lt: args.windowEnd };
+  const runsStarted = await em.count(WorkflowInstance, {
+    ...baseScope,
+    startedAt: window
+  });
+  const terminalInstances = await em.find(
+    WorkflowInstance,
+    {
+      ...baseScope,
+      status: { $in: [...WORKFLOW_TERMINAL_STATUSES] },
+      $or: [{ completedAt: window }, { cancelledAt: window }]
+    },
+    {
+      orderBy: { startedAt: "DESC" },
+      limit: ROLLUP_DURATION_SAMPLE_LIMIT,
+      fields: ["id", "status", "outcome", "startedAt", "completedAt", "cancelledAt"]
+    }
+  );
+  const terminalRuns = terminalInstances.map((instance) => ({
+    status: instance.status,
+    outcome: instance.outcome ?? null,
+    startedAt: instance.startedAt ?? null,
+    terminalAt: instance.completedAt ?? instance.cancelledAt ?? null
+  }));
+  const instanceIds = terminalInstances.map((instance) => instance.id);
+  const completedTasks = instanceIds.length ? await em.find(
+    UserTask,
+    {
+      tenantId: scope.tenantId,
+      ...organizationFilter(scope),
+      workflowInstanceId: { $in: instanceIds },
+      status: "COMPLETED",
+      dueDate: { $ne: null },
+      completedAt: window
+    },
+    { limit: ROLLUP_TASK_SAMPLE_LIMIT, fields: ["dueDate", "completedAt"] }
+  ) : [];
+  return buildDefinitionMetrics({
+    runsStarted,
+    terminalRuns,
+    completedTasks: completedTasks.map((task) => ({
+      dueDate: task.dueDate ?? null,
+      completedAt: task.completedAt ?? null
+    }))
+  });
+}
+async function upsertRollup(em, scope, args) {
+  const key = {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    workflowId: args.workflowId,
+    windowKey: args.bounds.windowKey,
+    windowStart: args.bounds.windowStart
+  };
+  const existing = await em.findOne(WorkflowDefinitionMetricRollup, key);
+  if (existing) {
+    existing.windowEnd = args.bounds.windowEnd;
+    existing.computedAt = args.now;
+    existing.metrics = { ...args.metrics };
+    em.persist(existing);
+    return;
+  }
+  em.persist(
+    em.create(WorkflowDefinitionMetricRollup, {
+      ...key,
+      windowEnd: args.bounds.windowEnd,
+      computedAt: args.now,
+      metrics: { ...args.metrics },
+      createdAt: args.now
+    })
+  );
+}
+async function writeRollupsForScope(em, scope, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const bounds = resolveWindowBounds(now.getTime());
+  const widest = bounds.reduce(
+    (oldest, candidate) => candidate.windowStart < oldest.windowStart ? candidate : oldest
+  );
+  const workflowIds = await listActiveWorkflowIds(em, scope, widest.windowStart);
+  let written = 0;
+  const readScope = {
+    tenantId: scope.tenantId,
+    organizationIds: [scope.organizationId]
+  };
+  for (const workflowId of workflowIds) {
+    for (const windowBounds of bounds) {
+      const metrics = await computeDefinitionMetrics(em, readScope, {
+        workflowId,
+        windowStart: windowBounds.windowStart,
+        windowEnd: windowBounds.windowEnd
+      });
+      await upsertRollup(em, scope, { workflowId, bounds: windowBounds, metrics, now });
+      written += 1;
+    }
+  }
+  await em.flush();
+  logger.debug("Wrote workflow definition metric rollups", {
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    workflowIds: workflowIds.length,
+    written
+  });
+  return { workflowIds: workflowIds.length, written };
+}
+export {
+  ROLLUP_DURATION_SAMPLE_LIMIT,
+  ROLLUP_TASK_SAMPLE_LIMIT,
+  computeDefinitionMetrics,
+  listActiveWorkflowIds,
+  resolveWindowBounds,
+  writeRollupsForScope
+};
+//# sourceMappingURL=rollup-service.js.map

package/dist/modules/workflows/lib/metrics/rollup-service.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/modules/workflows/lib/metrics/rollup-service.ts"],
+  "sourcesContent": ["/**\n * Per-definition KPI rollup (spec \u00A78.5) \u2014 the data-access half.\n *\n * The arithmetic lives in `./definition-metrics` and is pure; everything here is\n * about reading the right rows and writing the bucket exactly once.\n *\n * **Idempotency contract.** A pass never increments anything. It snaps the\n * window boundaries to `WORKFLOW_ROLLUP_BUCKET_MS`, RECOMPUTES the whole window\n * from the source rows, and writes the result at\n * `(tenantId, organizationId, workflowId, windowKey, windowStart)` \u2014 a key the\n * database enforces as unique. Running the same pass twice inside one bucket\n * therefore produces byte-identical rows and never a duplicate; running it after\n * the bucket rolls over produces a NEW row for the new bucket rather than\n * mutating history.\n *\n * **Scoping contract.** Every query below carries `tenantId` AND\n * `organizationId`. The worker enumerates scopes and calls this per scope; it\n * never widens a query to \"all tenants\" and then partitions in JS.\n *\n * **Dry-run contract.** `isDryRun: false` is on every instance query, and the\n * task query reaches tasks only through the ids of those instances \u2014 so a dry\n * run cannot contribute a run, a duration or an SLA sample by any path.\n */\n\nimport type { EntityManager } from '@mikro-orm/postgresql'\nimport { createLogger } from '@open-mercato/shared/lib/logger'\nimport { UserTask, WorkflowDefinitionMetricRollup, WorkflowInstance } from '../../data/entities'\nimport {\n  WORKFLOW_ROLLUP_WINDOW_KEYS,\n  WORKFLOW_ROLLUP_WINDOW_MS,\n  WORKFLOW_TERMINAL_STATUSES,\n  buildDefinitionMetrics,\n  floorToRollupBucket,\n  type DefinitionMetrics,\n  type WorkflowRollupWindowKey,\n} from './definition-metrics'\n\nconst logger = createLogger('workflows')\n\nexport type RollupScope = {\n  tenantId: string\n  organizationId: string\n}\n\n/**\n * Read-side scope.\n *\n * A rollup ROW is always per-organization, but a reader's organization scope can\n * legitimately cover several organizations (`filterIds`) or every organization in\n * the tenant (an unrestricted scope). Counts across organizations would sum, but\n * a percentile would not \u2014 a p95 cannot be recovered from three stored p95s \u2014 so\n * a multi-organization read is answered by live compute over the resolved set\n * rather than by pretending the rollup covers it. `organizationIds: undefined`\n * means \"every organization in this tenant\"; `tenantId` is never optional, so no\n * shape of this type can escape the tenant.\n */\nexport type MetricsReadScope = {\n  tenantId: string\n  organizationIds?: string[]\n}\n\nfunction organizationFilter(scope: MetricsReadScope): { organizationId?: { $in: string[] } } {\n  return scope.organizationIds ? { organizationId: { $in: scope.organizationIds } } : {}\n}\n\nexport type RollupWindowBounds = {\n  windowKey: WorkflowRollupWindowKey\n  windowStart: Date\n  windowEnd: Date\n}\n\n/**\n * How many instances one window's duration sample may draw from. A percentile\n * needs the values, not a count, so this is the one query that cannot be a\n * `COUNT(*)`; the cap keeps a pathological definition from pulling a month of\n * rows into memory. Exceeding it biases the sample toward the NEWEST runs,\n * which is the least misleading truncation available and is reported to the\n * reader through `durationSampleCount` sitting beside the percentile.\n */\nexport const ROLLUP_DURATION_SAMPLE_LIMIT = 5000\n\n/** How many tasks one window's SLA hit-rate may draw from, for the same reason. */\nexport const ROLLUP_TASK_SAMPLE_LIMIT = 5000\n\n/** Resolve the bucket-aligned bounds of every rollup window at `nowMs`. */\nexport function resolveWindowBounds(nowMs: number): RollupWindowBounds[] {\n  const windowEndMs = floorToRollupBucket(nowMs)\n  return WORKFLOW_ROLLUP_WINDOW_KEYS.map((windowKey) => ({\n    windowKey,\n    windowStart: new Date(windowEndMs - WORKFLOW_ROLLUP_WINDOW_MS[windowKey]),\n    windowEnd: new Date(windowEndMs),\n  }))\n}\n\n/**\n * Logical workflow ids that have any non-dry-run activity in the widest window.\n *\n * Bounded by the widest window rather than by all history so a workflow retired\n * a year ago stops costing a row every quarter of an hour.\n */\nexport async function listActiveWorkflowIds(\n  em: EntityManager,\n  scope: RollupScope,\n  since: Date,\n): Promise<string[]> {\n  const rows = await em.find(\n    WorkflowInstance,\n    {\n      tenantId: scope.tenantId,\n      organizationId: scope.organizationId,\n      isDryRun: false,\n      deletedAt: null,\n      startedAt: { $gte: since },\n    },\n    { fields: ['workflowId'] },\n  )\n  return Array.from(new Set(rows.map((row) => row.workflowId))).sort((left, right) =>\n    left.localeCompare(right),\n  )\n}\n\n/**\n * Compute one workflow's metrics for one window, straight from the source rows.\n *\n * Also the live-compute fallback the read route uses when no fresh rollup row\n * exists, which is what keeps the two paths from disagreeing: there is one\n * implementation of \"what do these numbers mean\", not two.\n */\nexport async function computeDefinitionMetrics(\n  em: EntityManager,\n  scope: MetricsReadScope,\n  args: { workflowId: string; windowStart: Date; windowEnd: Date },\n): Promise<DefinitionMetrics> {\n  const baseScope = {\n    tenantId: scope.tenantId,\n    ...organizationFilter(scope),\n    workflowId: args.workflowId,\n    isDryRun: false,\n    deletedAt: null,\n  } as const\n  const window = { $gte: args.windowStart, $lt: args.windowEnd }\n\n  const runsStarted = await em.count(WorkflowInstance, {\n    ...baseScope,\n    startedAt: window,\n  })\n\n  // A run is \"terminal in this window\" by its terminal TIMESTAMP, never by its\n  // status alone \u2014 a run that failed last month is not this week's failure.\n  // `completedAt` covers COMPLETED, FAILED and COMPENSATED, `cancelledAt`\n  // covers CANCELLED. A run compensated before the engine started stamping a\n  // terminal timestamp has neither, so it matches nothing here and falls into\n  // no window \u2014 unchanged, and deliberately not backfilled.\n  const terminalInstances = await em.find(\n    WorkflowInstance,\n    {\n      ...baseScope,\n      status: { $in: [...WORKFLOW_TERMINAL_STATUSES] },\n      $or: [{ completedAt: window }, { cancelledAt: window }],\n    },\n    {\n      orderBy: { startedAt: 'DESC' },\n      limit: ROLLUP_DURATION_SAMPLE_LIMIT,\n      fields: ['id', 'status', 'outcome', 'startedAt', 'completedAt', 'cancelledAt'],\n    },\n  )\n\n  const terminalRuns = terminalInstances.map((instance) => ({\n    status: instance.status,\n    outcome: instance.outcome ?? null,\n    startedAt: instance.startedAt ?? null,\n    terminalAt: instance.completedAt ?? instance.cancelledAt ?? null,\n  }))\n\n  // Tasks carry no workflow id of their own, so they are reached through the\n  // instances above. That indirection is also what excludes dry runs from the\n  // SLA metric structurally rather than by a second flag: a dry run creates no\n  // task row at all, and the instance ids fed in here are already dry-run free.\n  const instanceIds = terminalInstances.map((instance) => instance.id)\n  const completedTasks = instanceIds.length\n    ? await em.find(\n        UserTask,\n        {\n          tenantId: scope.tenantId,\n          ...organizationFilter(scope),\n          workflowInstanceId: { $in: instanceIds },\n          status: 'COMPLETED',\n          dueDate: { $ne: null },\n          completedAt: window,\n        },\n        { limit: ROLLUP_TASK_SAMPLE_LIMIT, fields: ['dueDate', 'completedAt'] },\n      )\n    : []\n\n  return buildDefinitionMetrics({\n    runsStarted,\n    terminalRuns,\n    completedTasks: completedTasks.map((task) => ({\n      dueDate: task.dueDate ?? null,\n      completedAt: task.completedAt ?? null,\n    })),\n  })\n}\n\n/**\n * Write (or overwrite) one bucket's row.\n *\n * Read-then-write against the unique key. The constraint is the real guarantee;\n * this lookup only avoids the round trip through a conflict in the common case.\n */\nasync function upsertRollup(\n  em: EntityManager,\n  scope: RollupScope,\n  args: { workflowId: string; bounds: RollupWindowBounds; metrics: DefinitionMetrics; now: Date },\n): Promise<void> {\n  const key = {\n    tenantId: scope.tenantId,\n    organizationId: scope.organizationId,\n    workflowId: args.workflowId,\n    windowKey: args.bounds.windowKey,\n    windowStart: args.bounds.windowStart,\n  }\n  const existing = await em.findOne(WorkflowDefinitionMetricRollup, key)\n  if (existing) {\n    existing.windowEnd = args.bounds.windowEnd\n    existing.computedAt = args.now\n    existing.metrics = { ...args.metrics }\n    em.persist(existing)\n    return\n  }\n  em.persist(\n    em.create(WorkflowDefinitionMetricRollup, {\n      ...key,\n      windowEnd: args.bounds.windowEnd,\n      computedAt: args.now,\n      metrics: { ...args.metrics },\n      createdAt: args.now,\n    }),\n  )\n}\n\nexport type RollupPassResult = {\n  workflowIds: number\n  written: number\n}\n\n/**\n * One rollup pass for one tenant + organization.\n *\n * Returns counts rather than rows so the worker can log a one-line summary\n * without holding the whole result set.\n */\nexport async function writeRollupsForScope(\n  em: EntityManager,\n  scope: RollupScope,\n  options: { now?: Date } = {},\n): Promise<RollupPassResult> {\n  const now = options.now ?? new Date()\n  const bounds = resolveWindowBounds(now.getTime())\n  const widest = bounds.reduce((oldest, candidate) =>\n    candidate.windowStart < oldest.windowStart ? candidate : oldest,\n  )\n\n  const workflowIds = await listActiveWorkflowIds(em, scope, widest.windowStart)\n  let written = 0\n\n  const readScope: MetricsReadScope = {\n    tenantId: scope.tenantId,\n    organizationIds: [scope.organizationId],\n  }\n\n  for (const workflowId of workflowIds) {\n    for (const windowBounds of bounds) {\n      const metrics = await computeDefinitionMetrics(em, readScope, {\n        workflowId,\n        windowStart: windowBounds.windowStart,\n        windowEnd: windowBounds.windowEnd,\n      })\n      await upsertRollup(em, scope, { workflowId, bounds: windowBounds, metrics, now })\n      written += 1\n    }\n  }\n\n  await em.flush()\n  logger.debug('Wrote workflow definition metric rollups', {\n    tenantId: scope.tenantId,\n    organizationId: scope.organizationId,\n    workflowIds: workflowIds.length,\n    written,\n  })\n  return { workflowIds: workflowIds.length, written }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/workflows/lib/node-config-summary.js

@@ -0,0 +1,128 @@
+const NODE_CONFIG_SUMMARY_SEPARATOR = " \xB7 ";
+function text(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function firstActivityConfig(data, activityType) {
+  const match = (data.activities ?? []).find(
+    (activity) => activity && activity.activityType === activityType
+  );
+  if (match?.config) return match.config;
+  if (data.activityType === activityType && data.activityConfig) return data.activityConfig;
+  return null;
+}
+function retrySegment(data) {
+  const attempts = data.retryPolicy?.maxAttempts;
+  if (typeof attempts !== "number" || attempts <= 1) return null;
+  return {
+    translationKey: "workflows.nodeSummary.retries",
+    translationParams: { count: attempts }
+  };
+}
+function automatedSummary(data) {
+  const segments = [];
+  const updateEntity = firstActivityConfig(data, "UPDATE_ENTITY");
+  const commandId = text(updateEntity?.commandId);
+  const executeFunction = firstActivityConfig(data, "EXECUTE_FUNCTION");
+  const functionName = text(executeFunction?.functionName);
+  const emitEvent = firstActivityConfig(data, "EMIT_EVENT");
+  const eventId = text(emitEvent?.eventId) ?? text(emitEvent?.event);
+  const identifier = commandId ?? functionName ?? eventId;
+  if (identifier) {
+    segments.push({ text: identifier, mono: true });
+  } else {
+    const activityType = text(data.activityType) ?? text((data.activities ?? []).find((activity) => activity?.activityType)?.activityType);
+    if (activityType) segments.push({ text: activityType, mono: true });
+  }
+  const retries = retrySegment(data);
+  if (retries) segments.push(retries);
+  return segments;
+}
+function invokeAgentSummary(data) {
+  const agentConfig = firstActivityConfig(data, "INVOKE_AGENT");
+  const agentId = text(data.agentId) ?? text(agentConfig?.agentId);
+  const segments = [];
+  if (agentId) segments.push({ text: agentId, mono: true });
+  const onResult = agentConfig?.onResult;
+  if (onResult?.alwaysAsk === true) {
+    segments.push({ translationKey: "workflows.nodeSummary.alwaysAsk" });
+  } else if (typeof onResult?.autoApproveThreshold === "number") {
+    segments.push({
+      translationKey: "workflows.nodeSummary.autoApproveThreshold",
+      translationParams: { threshold: onResult.autoApproveThreshold }
+    });
+  }
+  return segments;
+}
+function userTaskSummary(data) {
+  const segments = [];
+  const roles = (data.assignedToRoles ?? []).filter((role) => !!text(role));
+  if (roles.length > 0) {
+    segments.push({
+      translationKey: "workflows.nodeSummary.role",
+      translationParams: { roles: roles.join(", ") }
+    });
+  } else if (text(data.assignedTo)) {
+    segments.push({ translationKey: "workflows.nodeSummary.assigned" });
+  }
+  const bindings = data.entityBindings ?? [];
+  if (bindings.length > 0) {
+    segments.push({
+      translationKey: "workflows.nodeSummary.bound",
+      translationParams: { count: bindings.length }
+    });
+  }
+  const decisions = (data.decisions ?? []).length;
+  if (decisions > 0) {
+    segments.push({
+      translationKey: "workflows.nodeSummary.decisions",
+      translationParams: { count: decisions }
+    });
+  }
+  return segments;
+}
+function waitForSignalSummary(data) {
+  const signalName = text(data.signalName) ?? text(data.config?.signalName) ?? text(data.signalConfig?.signalName);
+  return signalName ? [{ text: signalName, mono: true }] : [];
+}
+function waitForTimerSummary(data) {
+  const duration = text(data.duration) ?? text(data.config?.duration);
+  if (duration) return [{ text: duration }];
+  const until = text(data.until) ?? text(data.config?.until);
+  return until ? [{
+    translationKey: "workflows.nodeSummary.until",
+    translationParams: { value: until }
+  }] : [];
+}
+function subWorkflowSummary(data) {
+  const subWorkflowId = text(data.subWorkflowId) ?? text(data.config?.subWorkflowId);
+  return subWorkflowId ? [{ text: subWorkflowId, mono: true }] : [];
+}
+const SUMMARY_BUILDERS = {
+  automated: automatedSummary,
+  invokeAgent: invokeAgentSummary,
+  userTask: userTaskSummary,
+  waitForSignal: waitForSignalSummary,
+  waitForTimer: waitForTimerSummary,
+  subWorkflow: subWorkflowSummary
+};
+function buildNodeConfigSummary(nodeType, data) {
+  const builder = SUMMARY_BUILDERS[nodeType];
+  if (!builder || !data) return [];
+  return builder(data);
+}
+function resolveNodeConfigSummarySegment(segment, translate) {
+  if (segment.translationKey) {
+    return translate(segment.translationKey, segment.translationParams);
+  }
+  return segment.text;
+}
+function formatNodeConfigSummary(segments, translate) {
+  return segments.map((segment) => resolveNodeConfigSummarySegment(segment, translate)).join(NODE_CONFIG_SUMMARY_SEPARATOR);
+}
+export {
+  NODE_CONFIG_SUMMARY_SEPARATOR,
+  buildNodeConfigSummary,
+  formatNodeConfigSummary,
+  resolveNodeConfigSummarySegment
+};
+//# sourceMappingURL=node-config-summary.js.map

package/dist/modules/workflows/lib/node-config-summary.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/node-config-summary.ts"],
+  "sourcesContent": ["/**\n * Workflows Module - One-line node config summary (pure)\n *\n * Fidelity gap #6. The design's nodes are not bigger than ours \u2014 measured, ours\n * are WIDER \u2014 they are more informative, because the body line states the step's\n * CONFIGURATION (`customers.deals.update \u00B7 retries 3\u00D7`) instead of two clamped\n * lines of the author's prose, which truncate mid-word and cannot tell you which\n * command runs, which agent is invoked, or what the threshold is.\n *\n * The summary is derived, never authored: everything below already sits on the\n * step. `description` is not lost \u2014 it becomes the card's tooltip.\n *\n * PURE: no React, no `@xyflow/react`, no ORM, so the rule is testable without a\n * canvas and `graph-utils` could consume it if the layout ever needs to.\n */\n\nimport type { TranslateFn, TranslateParams } from '@open-mercato/shared/lib/i18n/context'\n\nexport type NodeConfigSummaryTranslationKey =\n  | 'workflows.nodeSummary.alwaysAsk'\n  | 'workflows.nodeSummary.assigned'\n  | 'workflows.nodeSummary.autoApproveThreshold'\n  | 'workflows.nodeSummary.bound'\n  | 'workflows.nodeSummary.decisions'\n  | 'workflows.nodeSummary.retries'\n  | 'workflows.nodeSummary.role'\n  | 'workflows.nodeSummary.until'\n\n/** A summary is segments so command ids can render monospaced and labels can be translated. */\nexport type NodeConfigSummarySegment =\n  | {\n      text: string\n      translationKey?: never\n      translationParams?: never\n      mono?: boolean\n    }\n  | {\n      text?: never\n      translationKey: NodeConfigSummaryTranslationKey\n      translationParams?: TranslateParams\n      mono?: boolean\n    }\n\nexport const NODE_CONFIG_SUMMARY_SEPARATOR = ' \u00B7 '\n\nexport interface NodeConfigSummarySource {\n  activities?: Array<{ activityType?: string; config?: Record<string, unknown> } | null> | null\n  activityType?: string\n  activityId?: string\n  activityConfig?: Record<string, unknown> | null\n  retryPolicy?: { maxAttempts?: number } | null\n  agentId?: string\n  assignedTo?: string\n  assignedToRoles?: string[] | null\n  entityBindings?: Array<unknown> | null\n  decisions?: Array<unknown> | null\n  signalName?: string\n  duration?: string\n  until?: string\n  config?: Record<string, unknown> | null\n  subWorkflowId?: string\n  [key: string]: unknown\n}\n\nfunction text(value: unknown): string | null {\n  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null\n}\n\nfunction firstActivityConfig(\n  data: NodeConfigSummarySource,\n  activityType: string,\n): Record<string, unknown> | null {\n  const match = (data.activities ?? []).find(\n    (activity) => activity && activity.activityType === activityType,\n  )\n  if (match?.config) return match.config\n  if (data.activityType === activityType && data.activityConfig) return data.activityConfig\n  return null\n}\n\nfunction retrySegment(data: NodeConfigSummarySource): NodeConfigSummarySegment | null {\n  const attempts = data.retryPolicy?.maxAttempts\n  if (typeof attempts !== 'number' || attempts <= 1) return null\n  return {\n    translationKey: 'workflows.nodeSummary.retries',\n    translationParams: { count: attempts },\n  }\n}\n\nfunction automatedSummary(data: NodeConfigSummarySource): NodeConfigSummarySegment[] {\n  const segments: NodeConfigSummarySegment[] = []\n\n  const updateEntity = firstActivityConfig(data, 'UPDATE_ENTITY')\n  const commandId = text(updateEntity?.commandId)\n  const executeFunction = firstActivityConfig(data, 'EXECUTE_FUNCTION')\n  const functionName = text(executeFunction?.functionName)\n  const emitEvent = firstActivityConfig(data, 'EMIT_EVENT')\n  const eventId = text(emitEvent?.eventId) ?? text(emitEvent?.event)\n\n  const identifier = commandId ?? functionName ?? eventId\n  if (identifier) {\n    segments.push({ text: identifier, mono: true })\n  } else {\n    const activityType =\n      text(data.activityType) ??\n      text((data.activities ?? []).find((activity) => activity?.activityType)?.activityType)\n    if (activityType) segments.push({ text: activityType, mono: true })\n  }\n\n  const retries = retrySegment(data)\n  if (retries) segments.push(retries)\n  return segments\n}\n\nfunction invokeAgentSummary(data: NodeConfigSummarySource): NodeConfigSummarySegment[] {\n  const agentConfig = firstActivityConfig(data, 'INVOKE_AGENT')\n  const agentId = text(data.agentId) ?? text(agentConfig?.agentId)\n  const segments: NodeConfigSummarySegment[] = []\n  if (agentId) segments.push({ text: agentId, mono: true })\n\n  // The threshold is the single most consequential thing about an agent step \u2014\n  // it decides whether a human ever sees the proposal \u2014 so it belongs on the\n  // face rather than three clicks into the inspector.\n  const onResult = agentConfig?.onResult as\n    | { autoApproveThreshold?: unknown; alwaysAsk?: unknown }\n    | undefined\n  if (onResult?.alwaysAsk === true) {\n    segments.push({ translationKey: 'workflows.nodeSummary.alwaysAsk' })\n  } else if (typeof onResult?.autoApproveThreshold === 'number') {\n    segments.push({\n      translationKey: 'workflows.nodeSummary.autoApproveThreshold',\n      translationParams: { threshold: onResult.autoApproveThreshold },\n    })\n  }\n  return segments\n}\n\nfunction userTaskSummary(data: NodeConfigSummarySource): NodeConfigSummarySegment[] {\n  const segments: NodeConfigSummarySegment[] = []\n  const roles = (data.assignedToRoles ?? []).filter((role): role is string => !!text(role))\n  if (roles.length > 0) {\n    segments.push({\n      translationKey: 'workflows.nodeSummary.role',\n      translationParams: { roles: roles.join(', ') },\n    })\n  } else if (text(data.assignedTo)) {\n    segments.push({ translationKey: 'workflows.nodeSummary.assigned' })\n  }\n\n  const bindings = data.entityBindings ?? []\n  if (bindings.length > 0) {\n    segments.push({\n      translationKey: 'workflows.nodeSummary.bound',\n      translationParams: { count: bindings.length },\n    })\n  }\n\n  const decisions = (data.decisions ?? []).length\n  if (decisions > 0) {\n    segments.push({\n      translationKey: 'workflows.nodeSummary.decisions',\n      translationParams: { count: decisions },\n    })\n  }\n  return segments\n}\n\nfunction waitForSignalSummary(data: NodeConfigSummarySource): NodeConfigSummarySegment[] {\n  const signalName =\n    text(data.signalName) ??\n    text((data.config as { signalName?: unknown } | null)?.signalName) ??\n    text((data as { signalConfig?: { signalName?: unknown } }).signalConfig?.signalName)\n  return signalName ? [{ text: signalName, mono: true }] : []\n}\n\nfunction waitForTimerSummary(data: NodeConfigSummarySource): NodeConfigSummarySegment[] {\n  const duration = text(data.duration) ?? text((data.config as { duration?: unknown } | null)?.duration)\n  if (duration) return [{ text: duration }]\n  const until = text(data.until) ?? text((data.config as { until?: unknown } | null)?.until)\n  return until\n    ? [{\n        translationKey: 'workflows.nodeSummary.until',\n        translationParams: { value: until },\n      }]\n    : []\n}\n\nfunction subWorkflowSummary(data: NodeConfigSummarySource): NodeConfigSummarySegment[] {\n  const subWorkflowId =\n    text(data.subWorkflowId) ?? text((data.config as { subWorkflowId?: unknown } | null)?.subWorkflowId)\n  return subWorkflowId ? [{ text: subWorkflowId, mono: true }] : []\n}\n\nconst SUMMARY_BUILDERS: Record<string, (data: NodeConfigSummarySource) => NodeConfigSummarySegment[]> = {\n  automated: automatedSummary,\n  invokeAgent: invokeAgentSummary,\n  userTask: userTaskSummary,\n  waitForSignal: waitForSignalSummary,\n  waitForTimer: waitForTimerSummary,\n  subWorkflow: subWorkflowSummary,\n}\n\n/**\n * The card's body line for a node type, or an empty list when the step carries\n * nothing worth stating \u2014 in which case the card falls back to the author's\n * description exactly as it did before, so an unconfigured node never gets\n * emptier than it was.\n */\nexport function buildNodeConfigSummary(\n  nodeType: string,\n  data: NodeConfigSummarySource | null | undefined,\n): NodeConfigSummarySegment[] {\n  const builder = SUMMARY_BUILDERS[nodeType]\n  if (!builder || !data) return []\n  return builder(data)\n}\n\nexport function resolveNodeConfigSummarySegment(\n  segment: NodeConfigSummarySegment,\n  translate: TranslateFn,\n): string {\n  if (segment.translationKey) {\n    return translate(segment.translationKey, segment.translationParams)\n  }\n  return segment.text\n}\n\nexport function formatNodeConfigSummary(\n  segments: NodeConfigSummarySegment[],\n  translate: TranslateFn,\n): string {\n  return segments\n    .map((segment) => resolveNodeConfigSummarySegment(segment, translate))\n    .join(NODE_CONFIG_SUMMARY_SEPARATOR)\n}\n"],
+  "mappings": "AA2CO,MAAM,gCAAgC;AAqB7C,SAAS,KAAK,OAA+B;AAC3C,SAAO,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,SAAS,IAAI,MAAM,KAAK,IAAI;AAC/E;AAEA,SAAS,oBACP,MACA,cACgC;AAChC,QAAM,SAAS,KAAK,cAAc,CAAC,GAAG;AAAA,IACpC,CAAC,aAAa,YAAY,SAAS,iBAAiB;AAAA,EACtD;AACA,MAAI,OAAO,OAAQ,QAAO,MAAM;AAChC,MAAI,KAAK,iBAAiB,gBAAgB,KAAK,eAAgB,QAAO,KAAK;AAC3E,SAAO;AACT;AAEA,SAAS,aAAa,MAAgE;AACpF,QAAM,WAAW,KAAK,aAAa;AACnC,MAAI,OAAO,aAAa,YAAY,YAAY,EAAG,QAAO;AAC1D,SAAO;AAAA,IACL,gBAAgB;AAAA,IAChB,mBAAmB,EAAE,OAAO,SAAS;AAAA,EACvC;AACF;AAEA,SAAS,iBAAiB,MAA2D;AACnF,QAAM,WAAuC,CAAC;AAE9C,QAAM,eAAe,oBAAoB,MAAM,eAAe;AAC9D,QAAM,YAAY,KAAK,cAAc,SAAS;AAC9C,QAAM,kBAAkB,oBAAoB,MAAM,kBAAkB;AACpE,QAAM,eAAe,KAAK,iBAAiB,YAAY;AACvD,QAAM,YAAY,oBAAoB,MAAM,YAAY;AACxD,QAAM,UAAU,KAAK,WAAW,OAAO,KAAK,KAAK,WAAW,KAAK;AAEjE,QAAM,aAAa,aAAa,gBAAgB;AAChD,MAAI,YAAY;AACd,aAAS,KAAK,EAAE,MAAM,YAAY,MAAM,KAAK,CAAC;AAAA,EAChD,OAAO;AACL,UAAM,eACJ,KAAK,KAAK,YAAY,KACtB,MAAM,KAAK,cAAc,CAAC,GAAG,KAAK,CAAC,aAAa,UAAU,YAAY,GAAG,YAAY;AACvF,QAAI,aAAc,UAAS,KAAK,EAAE,MAAM,cAAc,MAAM,KAAK,CAAC;AAAA,EACpE;AAEA,QAAM,UAAU,aAAa,IAAI;AACjC,MAAI,QAAS,UAAS,KAAK,OAAO;AAClC,SAAO;AACT;AAEA,SAAS,mBAAmB,MAA2D;AACrF,QAAM,cAAc,oBAAoB,MAAM,cAAc;AAC5D,QAAM,UAAU,KAAK,KAAK,OAAO,KAAK,KAAK,aAAa,OAAO;AAC/D,QAAM,WAAuC,CAAC;AAC9C,MAAI,QAAS,UAAS,KAAK,EAAE,MAAM,SAAS,MAAM,KAAK,CAAC;AAKxD,QAAM,WAAW,aAAa;AAG9B,MAAI,UAAU,cAAc,MAAM;AAChC,aAAS,KAAK,EAAE,gBAAgB,kCAAkC,CAAC;AAAA,EACrE,WAAW,OAAO,UAAU,yBAAyB,UAAU;AAC7D,aAAS,KAAK;AAAA,MACZ,gBAAgB;AAAA,MAChB,mBAAmB,EAAE,WAAW,SAAS,qBAAqB;AAAA,IAChE,CAAC;AAAA,EACH;AACA,SAAO;AACT;AAEA,SAAS,gBAAgB,MAA2D;AAClF,QAAM,WAAuC,CAAC;AAC9C,QAAM,SAAS,KAAK,mBAAmB,CAAC,GAAG,OAAO,CAAC,SAAyB,CAAC,CAAC,KAAK,IAAI,CAAC;AACxF,MAAI,MAAM,SAAS,GAAG;AACpB,aAAS,KAAK;AAAA,MACZ,gBAAgB;AAAA,MAChB,mBAAmB,EAAE,OAAO,MAAM,KAAK,IAAI,EAAE;AAAA,IAC/C,CAAC;AAAA,EACH,WAAW,KAAK,KAAK,UAAU,GAAG;AAChC,aAAS,KAAK,EAAE,gBAAgB,iCAAiC,CAAC;AAAA,EACpE;AAEA,QAAM,WAAW,KAAK,kBAAkB,CAAC;AACzC,MAAI,SAAS,SAAS,GAAG;AACvB,aAAS,KAAK;AAAA,MACZ,gBAAgB;AAAA,MAChB,mBAAmB,EAAE,OAAO,SAAS,OAAO;AAAA,IAC9C,CAAC;AAAA,EACH;AAEA,QAAM,aAAa,KAAK,aAAa,CAAC,GAAG;AACzC,MAAI,YAAY,GAAG;AACjB,aAAS,KAAK;AAAA,MACZ,gBAAgB;AAAA,MAChB,mBAAmB,EAAE,OAAO,UAAU;AAAA,IACxC,CAAC;AAAA,EACH;AACA,SAAO;AACT;AAEA,SAAS,qBAAqB,MAA2D;AACvF,QAAM,aACJ,KAAK,KAAK,UAAU,KACpB,KAAM,KAAK,QAA4C,UAAU,KACjE,KAAM,KAAqD,cAAc,UAAU;AACrF,SAAO,aAAa,CAAC,EAAE,MAAM,YAAY,MAAM,KAAK,CAAC,IAAI,CAAC;AAC5D;AAEA,SAAS,oBAAoB,MAA2D;AACtF,QAAM,WAAW,KAAK,KAAK,QAAQ,KAAK,KAAM,KAAK,QAA0C,QAAQ;AACrG,MAAI,SAAU,QAAO,CAAC,EAAE,MAAM,SAAS,CAAC;AACxC,QAAM,QAAQ,KAAK,KAAK,KAAK,KAAK,KAAM,KAAK,QAAuC,KAAK;AACzF,SAAO,QACH,CAAC;AAAA,IACC,gBAAgB;AAAA,IAChB,mBAAmB,EAAE,OAAO,MAAM;AAAA,EACpC,CAAC,IACD,CAAC;AACP;AAEA,SAAS,mBAAmB,MAA2D;AACrF,QAAM,gBACJ,KAAK,KAAK,aAAa,KAAK,KAAM,KAAK,QAA+C,aAAa;AACrG,SAAO,gBAAgB,CAAC,EAAE,MAAM,eAAe,MAAM,KAAK,CAAC,IAAI,CAAC;AAClE;AAEA,MAAM,mBAAkG;AAAA,EACtG,WAAW;AAAA,EACX,aAAa;AAAA,EACb,UAAU;AAAA,EACV,eAAe;AAAA,EACf,cAAc;AAAA,EACd,aAAa;AACf;AAQO,SAAS,uBACd,UACA,MAC4B;AAC5B,QAAM,UAAU,iBAAiB,QAAQ;AACzC,MAAI,CAAC,WAAW,CAAC,KAAM,QAAO,CAAC;AAC/B,SAAO,QAAQ,IAAI;AACrB;AAEO,SAAS,gCACd,SACA,WACQ;AACR,MAAI,QAAQ,gBAAgB;AAC1B,WAAO,UAAU,QAAQ,gBAAgB,QAAQ,iBAAiB;AAAA,EACpE;AACA,SAAO,QAAQ;AACjB;AAEO,SAAS,wBACd,UACA,WACQ;AACR,SAAO,SACJ,IAAI,CAAC,YAAY,gCAAgC,SAAS,SAAS,CAAC,EACpE,KAAK,6BAA6B;AACvC;",
+  "names": []
+}

package/dist/modules/workflows/lib/node-geometry.js

@@ -0,0 +1,53 @@
+const NODE_MIN_WIDTH = 180;
+const NODE_MAX_WIDTH = 280;
+const NODE_HEIGHT = 88;
+const NODE_DESCRIPTION_HEIGHT = 24;
+const NODE_OUTCOME_ROW_HEIGHT = 18;
+const NODE_OUTCOME_FOOTER_CHROME_HEIGHT = 22;
+const TERMINAL_NODE_MIN_WIDTH = 96;
+const TERMINAL_NODE_HEIGHT = 36;
+const TRIGGER_NODE_WIDTH = 200;
+const TRIGGER_NODE_HEADER_HEIGHT = 32;
+const TRIGGER_NODE_ROW_HEIGHT = 22;
+const TRIGGER_NODE_GAP = 80;
+const NODE_HANDLE_SIZE = 12;
+const NODE_HANDLE_SIZE_CLASS = "!h-3 !w-3";
+const NODE_HANDLE_BORDER_CLASS = "!border-2 !border-background";
+const NODE_HANDLE_CLASS = `${NODE_HANDLE_SIZE_CLASS} ${NODE_HANDLE_BORDER_CLASS}`;
+const NODE_HANDLE_EDGE_OFFSET = -(NODE_HANDLE_SIZE / 2);
+const NODE_PORT_HANDLE_SIZE_CLASS = "!h-2.5 !w-2.5";
+const NODE_PORT_HANDLE_CLASS = `${NODE_PORT_HANDLE_SIZE_CLASS} !border !border-background`;
+const ROUTE_CHIP_ICON_SIZE = 20;
+const ROUTE_CHIP_ICON_CLASS = "size-5";
+const ROUTE_CHIP_LABEL_ICON_CLASS = "size-3.5";
+const ROUTE_CHIP_PADDING_CLASS = "px-2 py-1";
+const ROUTE_CHIP_HEIGHT = ROUTE_CHIP_ICON_SIZE + 8 + 2;
+const ROUTE_CHIP_CLASS = `inline-flex items-center gap-1 rounded-md border bg-card ${ROUTE_CHIP_PADDING_CLASS} text-xs font-medium`;
+export {
+  NODE_DESCRIPTION_HEIGHT,
+  NODE_HANDLE_BORDER_CLASS,
+  NODE_HANDLE_CLASS,
+  NODE_HANDLE_EDGE_OFFSET,
+  NODE_HANDLE_SIZE,
+  NODE_HANDLE_SIZE_CLASS,
+  NODE_HEIGHT,
+  NODE_MAX_WIDTH,
+  NODE_MIN_WIDTH,
+  NODE_OUTCOME_FOOTER_CHROME_HEIGHT,
+  NODE_OUTCOME_ROW_HEIGHT,
+  NODE_PORT_HANDLE_CLASS,
+  NODE_PORT_HANDLE_SIZE_CLASS,
+  ROUTE_CHIP_CLASS,
+  ROUTE_CHIP_HEIGHT,
+  ROUTE_CHIP_ICON_CLASS,
+  ROUTE_CHIP_ICON_SIZE,
+  ROUTE_CHIP_LABEL_ICON_CLASS,
+  ROUTE_CHIP_PADDING_CLASS,
+  TERMINAL_NODE_HEIGHT,
+  TERMINAL_NODE_MIN_WIDTH,
+  TRIGGER_NODE_GAP,
+  TRIGGER_NODE_HEADER_HEIGHT,
+  TRIGGER_NODE_ROW_HEIGHT,
+  TRIGGER_NODE_WIDTH
+};
+//# sourceMappingURL=node-geometry.js.map

package/dist/modules/workflows/lib/node-geometry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/node-geometry.ts"],
+  "sourcesContent": ["/**\n * Rendered node geometry \u2014 the SINGLE source of truth for how much space a\n * workflow node occupies AND for how big its connection handles are.\n *\n * Two consumers need the same numbers and used to keep private copies in sync\n * behind a comment: `components/WorkflowNodeCard.tsx` (which renders the card)\n * and `lib/graph-utils.ts` (which reserves the footprint dagre lays out). Drift\n * between them is invisible until ranks silently overlap, so the numbers live\n * here instead. This module stays PURE \u2014 no React, no `lucide-react`, no\n * `@xyflow/react` \u2014 so the layout transform can import it in node and jest\n * contexts without pulling in the editor's render chain.\n *\n * The handle constants below joined it for the same reason: every node\n * component spelled its own `!w-3 !h-3 !border-2 !border-background` and the\n * outcome-row footer spelled a smaller one, so a footer dot and the source\n * handle floating beside it rendered at different diameters on the same card.\n * Tailwind scans this file (`@source \".../@open-mercato/core/src/**\\/*.{ts,tsx}\"`),\n * so the literals here are real utilities, not dead strings.\n */\n\n/** Narrowest a `w-fit` card may render. */\nexport const NODE_MIN_WIDTH = 180\n/** Widest a `w-fit` card may render before its content wraps. */\nexport const NODE_MAX_WIDTH = 280\n/**\n * Height of a title-only card: the type row plus the title row, plus the 4px\n * node-type accent cap (`border-t-4`) that replaced the card's 1px top border.\n * Under-estimating here is what makes dagre pack ranks tight enough to overlap,\n * so this errs toward the real footprint.\n */\nexport const NODE_HEIGHT = 88\n/** Extra height the two-line `line-clamp-2` description adds to a card. */\nexport const NODE_DESCRIPTION_HEIGHT = 24\n\n/**\n * Height one outcome row adds to a card's footer (fidelity gap #4): a 16px row\n * plus the 2px grid gap. An agent node with four wired outcomes is materially\n * taller than a bare one, and dagre reserves boxes from these numbers \u2014 under-\n * estimating is exactly what makes ranks overlap.\n */\nexport const NODE_OUTCOME_ROW_HEIGHT = 18\n\n/**\n * Fixed chrome the footer costs once it exists at all: the hairline rule plus\n * its 4px vertical padding, and the inheritance note an agent node states.\n */\nexport const NODE_OUTCOME_FOOTER_CHROME_HEIGHT = 22\n\n/**\n * Footprint of a terminal (START / END) node. Terminals render as compact\n * auto-width pills rather than full step cards, so reserving a card-sized box\n * for them would push the first and last rank apart for nothing.\n */\nexport const TERMINAL_NODE_MIN_WIDTH = 96\nexport const TERMINAL_NODE_HEIGHT = 36\n\n/**\n * Footprint of the canvas trigger node (fidelity gap #5) \u2014 the pill that states\n * how a definition is entered, drawn in the gutter BEFORE the START terminal.\n *\n * It is derived rather than measured for the same reason the outcome-row footer\n * is: the node is minted at render time from the definition's triggers and has\n * to be placed before React Flow has laid a single card out. It is never handed\n * to dagre (it is not a step and has no rank), so these numbers do not reserve a\n * box \u2014 they position one, and `TRIGGER_NODE_GAP` matches dagre's own `ranksep`\n * so the pill sits one rank-gap ahead of START rather than at some second\n * spacing nothing else on the canvas uses.\n */\nexport const TRIGGER_NODE_WIDTH = 200\n/** The pill itself: icon + label, at the terminal pills' vertical rhythm. */\nexport const TRIGGER_NODE_HEADER_HEIGHT = 32\n/** One dashed event tag (or the manual-start / overflow line) plus its gap. */\nexport const TRIGGER_NODE_ROW_HEIGHT = 22\n/** Horizontal clearance between the trigger pill and the START terminal. */\nexport const TRIGGER_NODE_GAP = 80\n\n/**\n * Diameter, in px, of a connection handle. One number for the target handle,\n * every source handle, the error handle and the terminal pills' handles: a\n * canvas where the dots differ in size reads as a rendering bug, and the\n * maintainer's report of \"different sizes\" was exactly a 10px footer dot next\n * to a 12px floating one.\n */\nexport const NODE_HANDLE_SIZE = 12\n\n/** Tailwind form of {@link NODE_HANDLE_SIZE}. */\nexport const NODE_HANDLE_SIZE_CLASS = '!h-3 !w-3'\n\n/**\n * The ring that lifts a handle off whatever it overlaps. Kept with the size so\n * a handle can never be resized without its border following.\n */\nexport const NODE_HANDLE_BORDER_CLASS = '!border-2 !border-background'\n\n/** Size + ring. Callers add only the DS colour token the handle speaks with. */\nexport const NODE_HANDLE_CLASS = `${NODE_HANDLE_SIZE_CLASS} ${NODE_HANDLE_BORDER_CLASS}`\n\n/**\n * How far a handle overhangs the edge it sits on \u2014 half its diameter, so it\n * straddles the border rather than floating beside it. React Flow positions\n * edge-anchored handles itself; this is for handles placed by a row's own\n * layout (the outcome footer), which have to reproduce the same overhang.\n */\nexport const NODE_HANDLE_EDGE_OFFSET = -(NODE_HANDLE_SIZE / 2)\n\n/**\n * Sub-workflow IO ports are deliberately smaller than a control-flow handle:\n * a sub-workflow fans out one per declared input/output along an edge a\n * control-flow handle owns alone. Registered here anyway so the two sizes are\n * a decision made in one file rather than a drift discovered on a card.\n */\nexport const NODE_PORT_HANDLE_SIZE_CLASS = '!h-2.5 !w-2.5'\nexport const NODE_PORT_HANDLE_CLASS = `${NODE_PORT_HANDLE_SIZE_CLASS} !border !border-background`\n\n/**\n * Geometry of the chips a route renders at its midpoint (`WorkflowRouteChips`,\n * #4244) \u2014 the condition summary, the activity icons and the `+N` overflow.\n *\n * They live here for the reason the handle constants do: a canvas element whose\n * size is spelled inline in the component that draws it drifts. The activity\n * chip was the drift's first casualty \u2014 an icon at `size-3` in `px-1.5 py-0.5`\n * padding rendered an ~18px box carrying a 12px glyph, which is the size of a\n * connection handle and unreadable at any canvas zoom below 1. A route chip is\n * something the author reads, not a dot they aim at, so it is sized against the\n * card it sits between rather than against the handle it sits near: the icon is\n * {@link ROUTE_CHIP_ICON_SIZE}px and the box lands near {@link ROUTE_CHIP_HEIGHT}px,\n * comfortably under half of {@link NODE_HEIGHT} so a chip never competes with the\n * steps it connects.\n *\n * The label stays `text-xs` \u2014 the DS floor the node config summaries already\n * hold \u2014 so a chip grows by its glyph and its padding, never by inventing a\n * type size the design system does not have.\n */\nexport const ROUTE_CHIP_ICON_SIZE = 20\n\n/**\n * Tailwind form of {@link ROUTE_CHIP_ICON_SIZE}. For the ICON-ONLY activity\n * chip, where the glyph is the whole chip and has to carry it alone.\n */\nexport const ROUTE_CHIP_ICON_CLASS = 'size-5'\n\n/**\n * The glyph on a chip that also carries text (the condition summary, the\n * `otherwise` marker). It sits on the label's optical line, so it is sized\n * against the `text-xs` next to it rather than against the canvas \u2014 at\n * {@link ROUTE_CHIP_ICON_SIZE} it would tower over its own label.\n */\nexport const ROUTE_CHIP_LABEL_ICON_CLASS = 'size-3.5'\n\n/** Breathing room around a chip's glyph, on the DS spacing scale. */\nexport const ROUTE_CHIP_PADDING_CLASS = 'px-2 py-1'\n\n/**\n * Rendered height of a chip: the glyph plus {@link ROUTE_CHIP_PADDING_CLASS}'s\n * 4px vertical padding on each side plus the 1px border on each side. Derived\n * so the ratio to the node card stays checkable.\n */\nexport const ROUTE_CHIP_HEIGHT = ROUTE_CHIP_ICON_SIZE + 8 + 2\n\n/**\n * Everything a chip shares regardless of what it says. Callers add only the DS\n * colour tokens and the interaction states their own chip speaks with.\n *\n * On the radius: the DS scale has no 4px step for a chip \u2014 it is either\n * `rounded-full` (pill) or `rounded-md`. Bare `rounded` was neither, and read as\n * a slightly squared-off box next to every other chip in the product.\n */\nexport const ROUTE_CHIP_CLASS = `inline-flex items-center gap-1 rounded-md border bg-card ${ROUTE_CHIP_PADDING_CLASS} text-xs font-medium`\n"],
+  "mappings": "AAqBO,MAAM,iBAAiB;AAEvB,MAAM,iBAAiB;AAOvB,MAAM,cAAc;AAEpB,MAAM,0BAA0B;AAQhC,MAAM,0BAA0B;AAMhC,MAAM,oCAAoC;AAO1C,MAAM,0BAA0B;AAChC,MAAM,uBAAuB;AAc7B,MAAM,qBAAqB;AAE3B,MAAM,6BAA6B;AAEnC,MAAM,0BAA0B;AAEhC,MAAM,mBAAmB;AASzB,MAAM,mBAAmB;AAGzB,MAAM,yBAAyB;AAM/B,MAAM,2BAA2B;AAGjC,MAAM,oBAAoB,GAAG,sBAAsB,IAAI,wBAAwB;AAQ/E,MAAM,0BAA0B,EAAE,mBAAmB;AAQrD,MAAM,8BAA8B;AACpC,MAAM,yBAAyB,GAAG,2BAA2B;AAqB7D,MAAM,uBAAuB;AAM7B,MAAM,wBAAwB;AAQ9B,MAAM,8BAA8B;AAGpC,MAAM,2BAA2B;AAOjC,MAAM,oBAAoB,uBAAuB,IAAI;AAUrD,MAAM,mBAAmB,4DAA4D,wBAAwB;",
+  "names": []
+}

package/dist/modules/workflows/lib/node-nudge.js

@@ -0,0 +1,44 @@
+const NUDGE_STEP = 1;
+const NUDGE_STEP_COARSE = 10;
+const NUDGE_COMMIT_DELAY_MS = 400;
+const NUDGE_KEYS = {
+  ArrowUp: "up",
+  ArrowDown: "down",
+  ArrowLeft: "left",
+  ArrowRight: "right"
+};
+function resolveNudgeDirection(key) {
+  return NUDGE_KEYS[key] ?? null;
+}
+function nudgeOffset(direction, coarse) {
+  const distance = coarse ? NUDGE_STEP_COARSE : NUDGE_STEP;
+  switch (direction) {
+    case "up":
+      return { x: 0, y: -distance };
+    case "down":
+      return { x: 0, y: distance };
+    case "left":
+      return { x: -distance, y: 0 };
+    default:
+      return { x: distance, y: 0 };
+  }
+}
+function nudgeSelectedNodes(nodes, offset) {
+  if (!nodes.some((node) => node.selected)) return nodes;
+  return nodes.map(
+    (node) => node.selected ? { ...node, position: { x: node.position.x + offset.x, y: node.position.y + offset.y } } : node
+  );
+}
+function selectedNodeIds(nodes) {
+  return nodes.filter((node) => node.selected).map((node) => node.id);
+}
+export {
+  NUDGE_COMMIT_DELAY_MS,
+  NUDGE_STEP,
+  NUDGE_STEP_COARSE,
+  nudgeOffset,
+  nudgeSelectedNodes,
+  resolveNudgeDirection,
+  selectedNodeIds
+};
+//# sourceMappingURL=node-nudge.js.map

package/dist/modules/workflows/lib/node-nudge.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/node-nudge.ts"],
+  "sourcesContent": ["/**\n * Arrow-key positioning for selected cards (spec section 4.6: \"arrows nudge\").\n *\n * Nudging is the keyboard's answer to dragging, so it obeys the same rule the\n * drag path does (#4248): many keystrokes are ONE arrangement. The page captures\n * the document before the first nudge of a burst and commits a single undo entry\n * plus a single autosave once the burst settles.\n *\n * PURE: nodes in, nodes out.\n */\n\nimport type { Node } from '@xyflow/react'\n\n/** One press moves a card a hair; Shift moves it a visible step. */\nexport const NUDGE_STEP = 1\nexport const NUDGE_STEP_COARSE = 10\n\n/** Milliseconds of no arrow key before a nudge burst counts as finished. */\nexport const NUDGE_COMMIT_DELAY_MS = 400\n\nexport type NudgeDirection = 'up' | 'down' | 'left' | 'right'\n\nconst NUDGE_KEYS: Record<string, NudgeDirection> = {\n  ArrowUp: 'up',\n  ArrowDown: 'down',\n  ArrowLeft: 'left',\n  ArrowRight: 'right',\n}\n\nexport function resolveNudgeDirection(key: string): NudgeDirection | null {\n  return NUDGE_KEYS[key] ?? null\n}\n\nexport function nudgeOffset(direction: NudgeDirection, coarse: boolean): { x: number; y: number } {\n  const distance = coarse ? NUDGE_STEP_COARSE : NUDGE_STEP\n  switch (direction) {\n    case 'up':\n      return { x: 0, y: -distance }\n    case 'down':\n      return { x: 0, y: distance }\n    case 'left':\n      return { x: -distance, y: 0 }\n    default:\n      return { x: distance, y: 0 }\n  }\n}\n\n/**\n * Move every selected node by the offset. Returns the SAME array when nothing is\n * selected so the caller can skip the commit and the autosave entirely.\n */\nexport function nudgeSelectedNodes(nodes: Node[], offset: { x: number; y: number }): Node[] {\n  if (!nodes.some((node) => node.selected)) return nodes\n  return nodes.map((node) =>\n    node.selected\n      ? { ...node, position: { x: node.position.x + offset.x, y: node.position.y + offset.y } }\n      : node,\n  )\n}\n\nexport function selectedNodeIds(nodes: Node[]): string[] {\n  return nodes.filter((node) => node.selected).map((node) => node.id)\n}\n"],
+  "mappings": "AAcO,MAAM,aAAa;AACnB,MAAM,oBAAoB;AAG1B,MAAM,wBAAwB;AAIrC,MAAM,aAA6C;AAAA,EACjD,SAAS;AAAA,EACT,WAAW;AAAA,EACX,WAAW;AAAA,EACX,YAAY;AACd;AAEO,SAAS,sBAAsB,KAAoC;AACxE,SAAO,WAAW,GAAG,KAAK;AAC5B;AAEO,SAAS,YAAY,WAA2B,QAA2C;AAChG,QAAM,WAAW,SAAS,oBAAoB;AAC9C,UAAQ,WAAW;AAAA,IACjB,KAAK;AACH,aAAO,EAAE,GAAG,GAAG,GAAG,CAAC,SAAS;AAAA,IAC9B,KAAK;AACH,aAAO,EAAE,GAAG,GAAG,GAAG,SAAS;AAAA,IAC7B,KAAK;AACH,aAAO,EAAE,GAAG,CAAC,UAAU,GAAG,EAAE;AAAA,IAC9B;AACE,aAAO,EAAE,GAAG,UAAU,GAAG,EAAE;AAAA,EAC/B;AACF;AAMO,SAAS,mBAAmB,OAAe,QAA0C;AAC1F,MAAI,CAAC,MAAM,KAAK,CAAC,SAAS,KAAK,QAAQ,EAAG,QAAO;AACjD,SAAO,MAAM;AAAA,IAAI,CAAC,SAChB,KAAK,WACD,EAAE,GAAG,MAAM,UAAU,EAAE,GAAG,KAAK,SAAS,IAAI,OAAO,GAAG,GAAG,KAAK,SAAS,IAAI,OAAO,EAAE,EAAE,IACtF;AAAA,EACN;AACF;AAEO,SAAS,gBAAgB,OAAyB;AACvD,SAAO,MAAM,OAAO,CAAC,SAAS,KAAK,QAAQ,EAAE,IAAI,CAAC,SAAS,KAAK,EAAE;AACpE;",
+  "names": []
+}