@fluidgrids/workflows 2026.1027.0 → 2026.1028.1

package/dist/{chunk-BWSLWF2E.js → chunk-5HDSBTBX.js}

@@ -1,6 +1,8 @@
 import { autoLayout } from './chunk-5LUIDMF4.js';
-import { makeRef, isPredicate, conditionTreeOf, BuilderError, refModelOf } from './chunk-PL73GJR4.js';
-import { isRecord, cloneJson, formatRefTemplate } from './chunk-REV7ZOA4.js';
+import { makeRef, isPredicate, conditionTreeOf, BuilderError, refModelOf } from './chunk-JZ4TOOLN.js';
+import { formatRefTemplate } from './chunk-7AAZGVKD.js';
+import { isRecord, setOwn, cloneJson, ownValue } from './chunk-PMCM2OH4.js';
+import { isDurableWorkflow, SDK_VERSION } from './chunk-7NQ37GZU.js';
 
 // src/builder/descriptors.ts
 function op(nodeType, version, operation) {
@@ -84,7 +86,7 @@ function isTier1Workflow(value) {
 }
 function deepMerge(base, extra, path) {
   for (const [key, value] of Object.entries(extra)) {
-    const existing = base[key];
+    const existing = ownValue(base, key);
     if (isRecord(existing) && isRecord(value)) {
       deepMerge(existing, value, `${path}.${key}`);
     } else if (existing !== void 0) {
@@ -92,7 +94,7 @@ function deepMerge(base, extra, path) {
         `extra sets ${path}.${key}, which the builder already wrote; use the typed option`
       );
     } else {
-      base[key] = lowerValue(value, `${path}.${key}`);
+      setOwn(base, key, lowerValue(value, `${path}.${key}`));
     }
   }
 }
@@ -117,7 +119,7 @@ function lowerValue(value, path) {
     const out = {};
     for (const [key, child] of Object.entries(value)) {
       if (child === void 0) continue;
-      out[key] = lowerValue(child, `${path}.${key}`);
+      setOwn(out, key, lowerValue(child, `${path}.${key}`));
     }
     return out;
   }
@@ -196,8 +198,12 @@ var WorkflowBuilder = class {
   edges = [];
   notes = [];
   ids = /* @__PURE__ */ new Set();
+  /** Ids given explicitly; a second edge with the same explicit id is an error. */
   edgeIds = /* @__PURE__ */ new Set();
+  /** Edges whose id is the default, as indices into `edges`, with the unsuffixed default id. */
+  defaultIds = [];
   edgeOrder;
+  durableRefs = [];
   /** A reference to a node by id, for nodes declared later in the source. */
   ref(id) {
     return nodeRef(id);
@@ -271,10 +277,21 @@ var WorkflowBuilder = class {
   }
   /** `internal:wait-for-signal` (IR v2). */
   waitForSignal(options) {
-    const { name, limit, ...rest } = options;
+    const { name, limit, until, consume, ...rest } = options;
+    if (limit !== void 0 && until !== void 0)
+      throw new BuilderError("wf.waitForSignal takes limit or until, not both");
+    if (consume !== void 0 && consume !== "first" && consume !== "all")
+      throw new BuilderError(`consume must be "first" or "all" (got "${String(consume)}")`);
     const sugar = {};
     if (name !== void 0) sugar["signalName"] = name;
+    if (consume !== void 0) sugar["consume"] = consume;
     if (limit !== void 0) sugar["limitWait"] = limitWait(limit);
+    if (until !== void 0) {
+      const deadline = until instanceof Date ? until.toISOString() : until;
+      if (typeof deadline !== "string" || Number.isNaN(Date.parse(deadline)))
+        throw new BuilderError(`until "${String(until)}" is not an ISO 8601 date-time`);
+      sugar["limitWaitUntil"] = deadline;
+    }
     const ref = this.add(internalNodes.waitForSignal, rest, sugar);
     return { ...ref, received: ref.handle("received"), timedOut: ref.handle("timedOut") };
   }
@@ -297,6 +314,45 @@ var WorkflowBuilder = class {
     if (input !== void 0) sugar["inputMapping"] = input;
     return this.add(internalNodes.subworkflow, rest, sugar);
   }
+  /**
+   * `internal:code-workflow`: run a tier-2 function of this project as a
+   * durable child run. `fn` is a `workflow()` value (its export name is
+   * resolved when the bundle is collected) or an export name.
+   */
+  codeWorkflow(fn, options = {}) {
+    const {
+      input,
+      taskQueue,
+      waitForCompletion,
+      timeoutSeconds,
+      failOnError,
+      parentClosePolicy,
+      ...rest
+    } = options;
+    let workflowFn;
+    let definition;
+    if (typeof fn === "string" && fn !== "") workflowFn = fn;
+    else if (isDurableWorkflow(fn)) {
+      definition = fn;
+      workflowFn = fn.name;
+    } else throw new BuilderError("wf.codeWorkflow needs a workflow() function or its export name");
+    if (parentClosePolicy !== void 0 && !["TERMINATE", "ABANDON", "REQUEST_CANCEL"].includes(parentClosePolicy))
+      throw new BuilderError(`parentClosePolicy "${String(parentClosePolicy)}" is not a policy`);
+    const sugar = { workflowFn };
+    if (input !== void 0) sugar["inputMapping"] = input;
+    if (taskQueue !== void 0) sugar["taskQueue"] = taskQueue;
+    if (waitForCompletion !== void 0) sugar["waitForCompletion"] = waitForCompletion;
+    if (timeoutSeconds !== void 0) sugar["timeout"] = timeoutSeconds;
+    if (failOnError !== void 0) sugar["failOnError"] = failOnError;
+    if (parentClosePolicy !== void 0) sugar["parentClosePolicy"] = parentClosePolicy;
+    const ref = this.add(internalNodes.codeWorkflow, rest, sugar);
+    if (definition) this.durableRefs.push({ nodeId: ref.id, definition });
+    return ref;
+  }
+  /** The `wf.codeWorkflow` calls that named a function. */
+  durableReferences() {
+    return [...this.durableRefs];
+  }
   /** `internal:validate`. */
   validate(options) {
     const ref = this.add(internalNodes.validate, options, {});
@@ -407,6 +463,7 @@ var WorkflowBuilder = class {
   }
   /** The recording, once the callback has returned. */
   finish(key, document) {
+    this.assignDefaultEdgeIds();
     return {
       format: RECORDING_FORMAT,
       formatVersion: RECORDING_FORMAT_VERSION,
@@ -433,13 +490,35 @@ var WorkflowBuilder = class {
     for (let suffix = 2; this.ids.has(candidate); suffix++) candidate = `${base}-${suffix}`;
     return candidate;
   }
+  /**
+   * Give every edge declared without an id its default id. Explicit ids are
+   * claimed first, so a default never takes an id the code names; a default that
+   * is taken gets `-2`, `-3`, … in declaration order. The result depends only on
+   * the builder calls.
+   */
+  assignDefaultEdgeIds() {
+    const taken = new Set(this.edgeIds);
+    for (const { index, base } of this.defaultIds) {
+      let id = base;
+      for (let suffix = 2; taken.has(id); suffix++) id = `${base}-${suffix}`;
+      taken.add(id);
+      const built = this.edges[index];
+      if (built) built.id = id;
+    }
+    this.defaultIds.length = 0;
+  }
   addEdge(spec, target) {
     const { source, sourceHandle } = sourceOf(spec.from);
-    const id = spec.id === false ? void 0 : spec.id ?? defaultEdgeId(source, target, sourceHandle, spec.targetHandle);
-    if (id !== void 0) {
-      if (this.edgeIds.has(id)) throw new BuilderError(`Duplicate edge id "${id}"`);
-      this.edgeIds.add(id);
+    const explicit = typeof spec.id === "string" ? spec.id : void 0;
+    if (spec.id !== void 0 && spec.id !== false && explicit === void 0)
+      throw new BuilderError("An edge id must be a string or false");
+    if (explicit !== void 0) {
+      if (this.edgeIds.has(explicit)) throw new BuilderError(`Duplicate edge id "${explicit}"`);
+      this.edgeIds.add(explicit);
     }
+    const base = spec.id === void 0 ? defaultEdgeId(source, target, sourceHandle, spec.targetHandle) : void 0;
+    const id = explicit ?? base;
+    if (base !== void 0) this.defaultIds.push({ index: this.edges.length, base });
     const built = id !== void 0 ? { id, source, target } : { source, target };
     if (sourceHandle !== void 0) built["sourceHandle"] = sourceHandle;
     if (spec.targetHandle !== void 0) built["targetHandle"] = spec.targetHandle;
@@ -554,12 +633,15 @@ function defineWorkflow(options, build) {
   if (options.extra !== void 0)
     deepMerge(document, lowerObject(options.extra, "extra"), "workflow");
   const recording = builder.finish(options.key, document);
-  return { __fluidgrids: WORKFLOW_MARKER, key: options.key, recording };
+  const durableRefs = builder.durableReferences();
+  return {
+    __fluidgrids: WORKFLOW_MARKER,
+    key: options.key,
+    recording,
+    ...durableRefs.length > 0 ? { durableRefs } : {}
+  };
 }
 
-// src/generated/version.ts
-var SDK_VERSION = "2026.1027.0";
-
 // src/builder/assemble.ts
 var LAYOUT_FORMAT = "fluidgrids.layout";
 var LAYOUT_FORMAT_VERSION = 1;
@@ -589,7 +671,7 @@ function parseLayoutSidecar(value) {
     if (!isRecord(position) || typeof position["x"] !== "number" || typeof position["y"] !== "number") {
       throw new BuilderError(`The layout position of "${id}" must be { x, y }`);
     }
-    parsed[id] = { x: position["x"], y: position["y"] };
+    setOwn(parsed, id, { x: position["x"], y: position["y"] });
   }
   const sidecar = {
     format: LAYOUT_FORMAT,
@@ -694,7 +776,7 @@ function assembleRecording(recording, options = {}) {
     document["meta"] = meta;
   }
   for (const [key, value] of Object.entries(document)) {
-    if (!Object.hasOwn(out, key) && value !== void 0) out[key] = value;
+    if (!Object.hasOwn(out, key) && value !== void 0) setOwn(out, key, value);
   }
   return out;
 }
@@ -704,19 +786,4 @@ function toIR(workflow, options = {}) {
   return assembleRecording(workflow.recording, options);
 }
 
-// src/builder/collect.ts
-var COLLECTION_FORMAT = "fluidgrids.tier1-collection";
-function collectWorkflowExports(modules) {
-  const workflows = [];
-  for (const [module, namespace] of modules) {
-    for (const exportName of Object.keys(namespace).sort()) {
-      const value = namespace[exportName];
-      if (isTier1Workflow(value))
-        workflows.push({ module, exportName, recording: value.recording });
-    }
-  }
-  const collection = { format: COLLECTION_FORMAT, workflows };
-  return JSON.stringify(collection);
-}
-
-export { COLLECTION_FORMAT, LAYOUT_FORMAT, LAYOUT_FORMAT_VERSION, RECORDING_FORMAT, RECORDING_FORMAT_VERSION, SDK_VERSION, UnresolvedConnectionsError, WorkflowBuilder, assembleRecording, collectWorkflowExports, defaultEdgeId, defineWorkflow, edge, internalNodes, isOperation, isTier1Workflow, nodes, op, parseLayoutSidecar, toIR, trigger, triggers };
+export { LAYOUT_FORMAT, LAYOUT_FORMAT_VERSION, RECORDING_FORMAT, RECORDING_FORMAT_VERSION, UnresolvedConnectionsError, WorkflowBuilder, assembleRecording, defaultEdgeId, defineWorkflow, edge, internalNodes, isOperation, isTier1Workflow, nodes, op, parseLayoutSidecar, toIR, trigger, triggers };

package/dist/chunk-623FVQSN.cjs

@@ -0,0 +1,251 @@
+'use strict';
+
+// src/history/types.ts
+var HISTORY_PROTOCOL = 1;
+var EVENT_TYPES = [
+  "WORKFLOW_STARTED",
+  "WORKFLOW_TASK_SCHEDULED",
+  "WORKFLOW_TASK_STARTED",
+  "WORKFLOW_TASK_COMPLETED",
+  "WORKFLOW_TASK_FAILED",
+  "WORKFLOW_TASK_TIMED_OUT",
+  "ACTIVITY_SCHEDULED",
+  "ACTIVITY_STARTED",
+  "ACTIVITY_HEARTBEAT",
+  "ACTIVITY_COMPLETED",
+  "ACTIVITY_FAILED",
+  "ACTIVITY_TIMED_OUT",
+  "ACTIVITY_CANCEL_REQUESTED",
+  "ACTIVITY_CANCELLED",
+  "ACTIVITY_PAUSED",
+  "ACTIVITY_UNPAUSED",
+  "ACTIVITY_RESET",
+  "ACTIVITY_OPTIONS_UPDATED",
+  "TIMER_STARTED",
+  "TIMER_FIRED",
+  "TIMER_CANCELLED",
+  "SIGNAL_RECEIVED",
+  "UPDATE_ADMITTED",
+  "UPDATE_ACCEPTED",
+  "UPDATE_COMPLETED",
+  "CHILD_RUN_INITIATED",
+  "CHILD_RUN_STARTED",
+  "CHILD_RUN_COMPLETED",
+  "CHILD_RUN_FAILED",
+  "CHILD_RUN_CANCELLED",
+  "CHILD_RUN_TERMINATED",
+  "CHILD_RUN_TIMED_OUT",
+  "EXTERNAL_RUN_CANCEL_REQUESTED",
+  "EXTERNAL_RUN_CANCEL_RESOLVED",
+  "EXTERNAL_RUN_SIGNALED",
+  "SIDE_EFFECT_RECORDED",
+  "LOCAL_ACTIVITY_COMPLETED",
+  "LOCAL_ACTIVITY_FAILED",
+  "SEARCH_ATTRIBUTES_UPSERTED",
+  "CONTEXT_UPSERTED",
+  "MARKER_RECORDED",
+  "WORKFLOW_CANCEL_REQUESTED",
+  "WORKFLOW_RESET",
+  "VERSIONING_OVERRIDE_SET",
+  "WORKFLOW_COMPLETED",
+  "WORKFLOW_FAILED",
+  "WORKFLOW_CANCELLED",
+  "WORKFLOW_TERMINATED",
+  "WORKFLOW_TIMED_OUT",
+  "WORKFLOW_CONTINUED_AS_NEW"
+];
+var COMMAND_TYPES = [
+  "SCHEDULE_ACTIVITY",
+  "REQUEST_CANCEL_ACTIVITY",
+  "START_TIMER",
+  "CANCEL_TIMER",
+  "START_CHILD_RUN",
+  "SIGNAL_RUN",
+  "RECORD_SIDE_EFFECT",
+  "RECORD_MARKER",
+  "COMPLETE_WORKFLOW",
+  "FAIL_WORKFLOW",
+  "CANCEL_WORKFLOW",
+  "UPSERT_CONTEXT",
+  "RECORD_LOCAL_ACTIVITY",
+  "CONTINUE_AS_NEW",
+  "REQUEST_CANCEL_EXTERNAL_RUN",
+  "UPSERT_SEARCH_ATTRIBUTES",
+  "ACCEPT_UPDATE",
+  "REJECT_UPDATE",
+  "COMPLETE_UPDATE"
+];
+var PHASE_B_CORE_COMMANDS = /* @__PURE__ */ new Set([
+  "SCHEDULE_ACTIVITY",
+  "REQUEST_CANCEL_ACTIVITY",
+  "START_TIMER",
+  "CANCEL_TIMER",
+  "START_CHILD_RUN",
+  "SIGNAL_RUN",
+  "RECORD_SIDE_EFFECT",
+  "RECORD_MARKER",
+  "COMPLETE_WORKFLOW",
+  "FAIL_WORKFLOW",
+  "CANCEL_WORKFLOW"
+]);
+var PHASE_B_PARITY_COMMANDS = /* @__PURE__ */ new Set([
+  "UPSERT_CONTEXT",
+  "RECORD_LOCAL_ACTIVITY",
+  "CONTINUE_AS_NEW",
+  "REQUEST_CANCEL_EXTERNAL_RUN"
+]);
+var PHASE_C_COMMANDS = /* @__PURE__ */ new Set([
+  "UPSERT_SEARCH_ATTRIBUTES",
+  "ACCEPT_UPDATE",
+  "REJECT_UPDATE",
+  "COMPLETE_UPDATE"
+]);
+var TERMINAL_COMMANDS = /* @__PURE__ */ new Set([
+  "COMPLETE_WORKFLOW",
+  "FAIL_WORKFLOW",
+  "CANCEL_WORKFLOW",
+  "CONTINUE_AS_NEW"
+]);
+var TASK_FAILURE_CAUSES = [
+  "NON_DETERMINISM",
+  "TASK_TIMEOUT",
+  "ISOLATE_MEMORY",
+  "PROTOCOL_MISMATCH",
+  "BUNDLE_UNAVAILABLE",
+  "BUNDLE_INTEGRITY",
+  "WORKFLOW_CODE_ERROR",
+  "HISTORY_LIMIT",
+  "UNSUPPORTED_COMMAND",
+  "INVALID_REQUEST",
+  "INTERNAL"
+];
+var ERROR_TYPES = [
+  "TIMEOUT",
+  "TRANSIENT",
+  "DEPENDENCY",
+  "AUTHORIZATION",
+  "VALIDATION",
+  "PERMANENT",
+  "UNKNOWN"
+];
+var EXECUTION_KINDS = ["GRAPH", "DURABLE_FN"];
+var PARENT_CLOSE_POLICIES = ["TERMINATE", "ABANDON", "REQUEST_CANCEL"];
+var ACTIVITY_CANCELLATION_TYPES = [
+  "WAIT_CANCELLATION_COMPLETED",
+  "TRY_CANCEL",
+  "ABANDON"
+];
+var CHILD_CANCELLATION_TYPES = [
+  "WAIT_CANCELLATION_COMPLETED",
+  "WAIT_CANCELLATION_REQUESTED",
+  "TRY_CANCEL",
+  "ABANDON"
+];
+var DEFAULT_HISTORY_LIMIT = { events: 1e4, bytes: 16 * 1024 * 1024 };
+var CONTINUE_AS_NEW_SUGGESTED_RATIO = 0.8;
+var HISTORY_LIMIT_EXCEEDED_RATIO = 0.95;
+var BUILT_IN_QUERIES = [
+  "__stack_trace",
+  "__enhanced_stack_trace",
+  "__metadata"
+];
+var COMMAND_EVENT_TYPES = {
+  SCHEDULE_ACTIVITY: "ACTIVITY_SCHEDULED",
+  REQUEST_CANCEL_ACTIVITY: "ACTIVITY_CANCEL_REQUESTED",
+  START_TIMER: "TIMER_STARTED",
+  CANCEL_TIMER: "TIMER_CANCELLED",
+  START_CHILD_RUN: "CHILD_RUN_INITIATED",
+  SIGNAL_RUN: "EXTERNAL_RUN_SIGNALED",
+  RECORD_SIDE_EFFECT: "SIDE_EFFECT_RECORDED",
+  RECORD_MARKER: "MARKER_RECORDED",
+  COMPLETE_WORKFLOW: "WORKFLOW_COMPLETED",
+  FAIL_WORKFLOW: "WORKFLOW_FAILED",
+  CANCEL_WORKFLOW: "WORKFLOW_CANCELLED",
+  UPSERT_CONTEXT: "CONTEXT_UPSERTED",
+  RECORD_LOCAL_ACTIVITY: "LOCAL_ACTIVITY_COMPLETED",
+  CONTINUE_AS_NEW: "WORKFLOW_CONTINUED_AS_NEW",
+  REQUEST_CANCEL_EXTERNAL_RUN: "EXTERNAL_RUN_CANCEL_REQUESTED",
+  UPSERT_SEARCH_ATTRIBUTES: "SEARCH_ATTRIBUTES_UPSERTED",
+  ACCEPT_UPDATE: "UPDATE_ACCEPTED",
+  REJECT_UPDATE: null,
+  COMPLETE_UPDATE: "UPDATE_COMPLETED"
+};
+var COMMAND_EVENTS = /* @__PURE__ */ new Set([
+  "ACTIVITY_SCHEDULED",
+  "ACTIVITY_CANCEL_REQUESTED",
+  "TIMER_STARTED",
+  "TIMER_CANCELLED",
+  "CHILD_RUN_INITIATED",
+  "EXTERNAL_RUN_SIGNALED",
+  "SIDE_EFFECT_RECORDED",
+  "MARKER_RECORDED",
+  "WORKFLOW_COMPLETED",
+  "WORKFLOW_FAILED",
+  "WORKFLOW_CANCELLED",
+  "CONTEXT_UPSERTED",
+  "LOCAL_ACTIVITY_COMPLETED",
+  "LOCAL_ACTIVITY_FAILED",
+  "WORKFLOW_CONTINUED_AS_NEW",
+  "EXTERNAL_RUN_CANCEL_REQUESTED",
+  "SEARCH_ATTRIBUTES_UPSERTED",
+  "UPDATE_ACCEPTED",
+  "UPDATE_COMPLETED"
+]);
+var INPUT_EVENTS = /* @__PURE__ */ new Set([
+  "WORKFLOW_STARTED",
+  "ACTIVITY_COMPLETED",
+  "ACTIVITY_FAILED",
+  "ACTIVITY_TIMED_OUT",
+  "ACTIVITY_CANCELLED",
+  "TIMER_FIRED",
+  "SIGNAL_RECEIVED",
+  "UPDATE_ADMITTED",
+  "CHILD_RUN_STARTED",
+  "CHILD_RUN_COMPLETED",
+  "CHILD_RUN_FAILED",
+  "CHILD_RUN_CANCELLED",
+  "CHILD_RUN_TERMINATED",
+  "CHILD_RUN_TIMED_OUT",
+  "EXTERNAL_RUN_CANCEL_RESOLVED",
+  "WORKFLOW_CANCEL_REQUESTED"
+]);
+var TERMINAL_EVENTS = /* @__PURE__ */ new Set([
+  "WORKFLOW_COMPLETED",
+  "WORKFLOW_FAILED",
+  "WORKFLOW_CANCELLED",
+  "WORKFLOW_TERMINATED",
+  "WORKFLOW_TIMED_OUT",
+  "WORKFLOW_CONTINUED_AS_NEW"
+]);
+function isInputEvent(event) {
+  if (event.type === "EXTERNAL_RUN_SIGNALED") return event.payload["resolved"] === true;
+  return INPUT_EVENTS.has(event.type);
+}
+function isCommandEvent(event) {
+  if (event.type === "EXTERNAL_RUN_SIGNALED") return event.payload["resolved"] !== true;
+  return COMMAND_EVENTS.has(event.type);
+}
+
+exports.ACTIVITY_CANCELLATION_TYPES = ACTIVITY_CANCELLATION_TYPES;
+exports.BUILT_IN_QUERIES = BUILT_IN_QUERIES;
+exports.CHILD_CANCELLATION_TYPES = CHILD_CANCELLATION_TYPES;
+exports.COMMAND_EVENTS = COMMAND_EVENTS;
+exports.COMMAND_EVENT_TYPES = COMMAND_EVENT_TYPES;
+exports.COMMAND_TYPES = COMMAND_TYPES;
+exports.CONTINUE_AS_NEW_SUGGESTED_RATIO = CONTINUE_AS_NEW_SUGGESTED_RATIO;
+exports.DEFAULT_HISTORY_LIMIT = DEFAULT_HISTORY_LIMIT;
+exports.ERROR_TYPES = ERROR_TYPES;
+exports.EVENT_TYPES = EVENT_TYPES;
+exports.EXECUTION_KINDS = EXECUTION_KINDS;
+exports.HISTORY_LIMIT_EXCEEDED_RATIO = HISTORY_LIMIT_EXCEEDED_RATIO;
+exports.HISTORY_PROTOCOL = HISTORY_PROTOCOL;
+exports.INPUT_EVENTS = INPUT_EVENTS;
+exports.PARENT_CLOSE_POLICIES = PARENT_CLOSE_POLICIES;
+exports.PHASE_B_CORE_COMMANDS = PHASE_B_CORE_COMMANDS;
+exports.PHASE_B_PARITY_COMMANDS = PHASE_B_PARITY_COMMANDS;
+exports.PHASE_C_COMMANDS = PHASE_C_COMMANDS;
+exports.TASK_FAILURE_CAUSES = TASK_FAILURE_CAUSES;
+exports.TERMINAL_COMMANDS = TERMINAL_COMMANDS;
+exports.TERMINAL_EVENTS = TERMINAL_EVENTS;
+exports.isCommandEvent = isCommandEvent;
+exports.isInputEvent = isInputEvent;

package/dist/{chunk-4DPEGDPW.js → chunk-6FSHT5IL.js}

@@ -1,5 +1,5 @@
-import { hashedProjection } from './chunk-SS4LT2IP.js';
-import { isRecord, deepEqual } from './chunk-REV7ZOA4.js';
+import { hashedProjection } from './chunk-BD7ZPG53.js';
+import { isRecord, deepEqual, ownValue } from './chunk-PMCM2OH4.js';
 
 // src/ir/diff.ts
 function keyPath(base, key) {
@@ -10,8 +10,8 @@ function diffValues(before, after, path, out) {
   if (isRecord(before) && isRecord(after)) {
     const keys = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort();
     for (const key of keys) {
-      const left = before[key];
-      const right = after[key];
+      const left = ownValue(before, key);
+      const right = ownValue(after, key);
       if (left === void 0 && right !== void 0)
         out.push({ kind: "added", path: keyPath(path, key), after: right });
       else if (left !== void 0 && right === void 0)

package/dist/{chunk-REV7ZOA4.js → chunk-7AAZGVKD.js}

@@ -1,37 +1,3 @@
-// src/ir/json-utils.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function deepEqual(left, right) {
-  if (left === right) return true;
-  if (Array.isArray(left)) {
-    if (!Array.isArray(right) || left.length !== right.length) return false;
-    return left.every((item, index) => deepEqual(item, right[index]));
-  }
-  if (isRecord(left)) {
-    if (!isRecord(right)) return false;
-    const leftKeys = Object.keys(left).filter((key) => left[key] !== void 0);
-    const rightKeys = Object.keys(right).filter((key) => right[key] !== void 0);
-    if (leftKeys.length !== rightKeys.length) return false;
-    return leftKeys.every((key) => Object.hasOwn(right, key) && deepEqual(left[key], right[key]));
-  }
-  return false;
-}
-function cloneJson(value) {
-  return structuredCloneJson(value);
-}
-function structuredCloneJson(value) {
-  if (Array.isArray(value)) return value.map(structuredCloneJson);
-  if (isRecord(value)) {
-    const out = {};
-    for (const [key, child] of Object.entries(value)) {
-      if (child !== void 0) out[key] = structuredCloneJson(child);
-    }
-    return out;
-  }
-  return value;
-}
-
 // src/ir/expressions.ts
 var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 function segmentFromKey(key) {
@@ -167,4 +133,4 @@ function isJsIdentifier(name) {
   return IDENTIFIER.test(name);
 }
 
-export { cloneJson, deepEqual, formatRefExpression, formatRefTemplate, hasLegacyTemplate, isJsIdentifier, isRecord, parseRefExpression, parseTemplate, segmentFromKey };
+export { formatRefExpression, formatRefTemplate, hasLegacyTemplate, isJsIdentifier, parseRefExpression, parseTemplate, segmentFromKey };

package/dist/chunk-7NQ37GZU.js

@@ -0,0 +1,73 @@
+// src/durable/workflow.ts
+var DURABLE_MARKER = "fluidgrids.durable-workflow";
+var KEY = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+function workflow(name, optionsOrFn, maybeFn) {
+  if (typeof name !== "string" || !KEY.test(name))
+    throw new TypeError(
+      `workflow() needs a key of lowercase letters, digits, "-" and "_" (got "${String(name)}")`
+    );
+  const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+  const options = typeof optionsOrFn === "function" ? {} : optionsOrFn ?? {};
+  if (typeof fn !== "function") throw new TypeError(`workflow("${name}") needs a function`);
+  return Object.freeze({ __fluidgrids: DURABLE_MARKER, name, options, fn });
+}
+function isDurableWorkflow(value) {
+  return typeof value === "object" && value !== null && value.__fluidgrids === DURABLE_MARKER && typeof value.fn === "function";
+}
+function isJsonValue(value, depth = 0) {
+  if (depth > 64) return false;
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every((item) => isJsonValue(item, depth + 1));
+  if (typeof value === "object") {
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+      return false;
+    return Object.values(value).every((item) => isJsonValue(item, depth + 1));
+  }
+  return false;
+}
+function jsonSchemaOf(schema) {
+  if (schema === void 0) return void 0;
+  const method = schema.toJSONSchema;
+  if (typeof method === "function") {
+    const produced = method.call(schema);
+    return isJsonValue(produced) && typeof produced === "object" && !Array.isArray(produced) && produced !== null ? produced : void 0;
+  }
+  return isJsonValue(schema) && !Array.isArray(schema) && schema !== null && typeof schema === "object" ? schema : void 0;
+}
+function interfaceOf(definition) {
+  const out = {};
+  const input = jsonSchemaOf(definition.options.input);
+  const output = jsonSchemaOf(definition.options.output);
+  if (input) out.input = input;
+  if (output) out.output = output;
+  const signals = definition.options.signals ?? [];
+  if (signals.length > 0) {
+    out.signals = {};
+    for (const signal of signals) {
+      const entry = {};
+      const payload = jsonSchemaOf(signal.schema);
+      if (payload) entry.payload = payload;
+      if (signal.description !== void 0) entry.description = signal.description;
+      out.signals[signal.name] = entry;
+    }
+  }
+  const queries = definition.options.queries ?? [];
+  if (queries.length > 0) {
+    out.queries = {};
+    for (const query of queries)
+      out.queries[query.name] = query.description !== void 0 ? { description: query.description } : {};
+  }
+  const updates = definition.options.updates ?? [];
+  if (updates.length > 0) {
+    out.updates = {};
+    for (const update of updates)
+      out.updates[update.name] = update.description !== void 0 ? { description: update.description } : {};
+  }
+  return out;
+}
+
+// src/generated/version.ts
+var SDK_VERSION = "2026.1028.1";
+
+export { DURABLE_MARKER, SDK_VERSION, interfaceOf, isDurableWorkflow, jsonSchemaOf, workflow };