@fluidgrids/workflows 2026.1027.1 → 2026.1028.1

package/dist/chunk-DJYMDLV5.js

@@ -0,0 +1,227 @@
+// 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);
+}
+
+export { ACTIVITY_CANCELLATION_TYPES, BUILT_IN_QUERIES, CHILD_CANCELLATION_TYPES, COMMAND_EVENTS, COMMAND_EVENT_TYPES, COMMAND_TYPES, CONTINUE_AS_NEW_SUGGESTED_RATIO, DEFAULT_HISTORY_LIMIT, ERROR_TYPES, EVENT_TYPES, EXECUTION_KINDS, HISTORY_LIMIT_EXCEEDED_RATIO, HISTORY_PROTOCOL, INPUT_EVENTS, PARENT_CLOSE_POLICIES, PHASE_B_CORE_COMMANDS, PHASE_B_PARITY_COMMANDS, PHASE_C_COMMANDS, TASK_FAILURE_CAUSES, TERMINAL_COMMANDS, TERMINAL_EVENTS, isCommandEvent, isInputEvent };

package/dist/{chunk-IHKXLG6I.js → chunk-E2VK7J2C.js}

@@ -1,4 +1,4 @@
-import { setOwn } from './chunk-UJNHTS6D.js';
+import { setOwn } from './chunk-PMCM2OH4.js';
 
 // src/ir/canonical-json.ts
 var CanonicalJsonError = class extends Error {

package/dist/chunk-FMSW2HDF.cjs

@@ -0,0 +1,267 @@
+'use strict';
+
+var chunkFR7KYWRO_cjs = require('./chunk-FR7KYWRO.cjs');
+
+// src/durable/definitions.ts
+function checkName(name, what) {
+  if (typeof name !== "string" || name === "" || name.startsWith("__"))
+    throw new TypeError(`${what} needs a name that does not start with "__"`);
+}
+function defineSignal(name, options = {}) {
+  checkName(name, "defineSignal");
+  return {
+    kind: "signal",
+    name,
+    ...options.description !== void 0 ? { description: options.description } : {},
+    ...options.schema !== void 0 ? { schema: options.schema } : {}
+  };
+}
+function defineQuery(name, options = {}) {
+  checkName(name, "defineQuery");
+  return {
+    kind: "query",
+    name,
+    ...options.description !== void 0 ? { description: options.description } : {}
+  };
+}
+function defineUpdate(name, options = {}) {
+  checkName(name, "defineUpdate");
+  return {
+    kind: "update",
+    name,
+    ...options.description !== void 0 ? { description: options.description } : {}
+  };
+}
+function signalName(signal) {
+  return typeof signal === "string" ? signal : signal.name;
+}
+
+// src/durable/errors.ts
+var ERROR_TYPE_VALUES = /* @__PURE__ */ new Set([
+  "TIMEOUT",
+  "TRANSIENT",
+  "DEPENDENCY",
+  "AUTHORIZATION",
+  "VALIDATION",
+  "PERMANENT",
+  "UNKNOWN"
+]);
+function isErrorType(value) {
+  return typeof value === "string" && ERROR_TYPE_VALUES.has(value);
+}
+var WorkflowFailure = class extends Error {
+  /** The shared error type the engine classifies this failure as. */
+  errorType;
+  constructor(message, errorType, options = {}) {
+    super(message);
+    this.name = "WorkflowFailure";
+    this.errorType = errorType;
+    if (options.cause !== void 0)
+      Object.defineProperty(this, "cause", {
+        value: options.cause,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+  }
+};
+var ApplicationError = class extends WorkflowFailure {
+  type;
+  nonRetryable;
+  details;
+  nextRetryDelayMs;
+  category;
+  constructor(message, options = {}) {
+    super(
+      message,
+      options.errorType ?? (isErrorType(options.type) ? options.type : "UNKNOWN"),
+      options.cause !== void 0 ? { cause: options.cause } : {}
+    );
+    this.name = "ApplicationError";
+    this.type = options.type;
+    this.nonRetryable = options.nonRetryable === true;
+    this.details = options.details;
+    this.nextRetryDelayMs = options.nextRetryDelay;
+    this.category = options.category;
+  }
+};
+var ActivityFailure = class extends WorkflowFailure {
+  constructor(message, activityId, nodeType, operation, cause) {
+    super(message, cause instanceof WorkflowFailure ? cause.errorType : "UNKNOWN", { cause });
+    this.activityId = activityId;
+    this.nodeType = nodeType;
+    this.operation = operation;
+    this.name = "ActivityFailure";
+  }
+  activityId;
+  nodeType;
+  operation;
+};
+var ChildRunFailure = class extends WorkflowFailure {
+  constructor(message, childId, childRunId, cause) {
+    super(message, cause instanceof WorkflowFailure ? cause.errorType : "UNKNOWN", { cause });
+    this.childId = childId;
+    this.childRunId = childRunId;
+    this.name = "ChildRunFailure";
+  }
+  childId;
+  childRunId;
+};
+var TerminatedFailure = class extends WorkflowFailure {
+  constructor(message = "Terminated") {
+    super(message, "PERMANENT");
+    this.name = "TerminatedFailure";
+  }
+};
+var ServerFailure = class extends WorkflowFailure {
+  constructor(message, nonRetryable = false, errorType = "DEPENDENCY") {
+    super(message, errorType);
+    this.nonRetryable = nonRetryable;
+    this.name = "ServerFailure";
+  }
+  nonRetryable;
+};
+var CancelledFailure = class extends WorkflowFailure {
+  constructor(message = "Cancelled") {
+    super(message, "PERMANENT");
+    this.name = "CancelledFailure";
+  }
+};
+var TimeoutFailure = class extends WorkflowFailure {
+  constructor(message, timeoutType) {
+    super(message, "TIMEOUT");
+    this.timeoutType = timeoutType;
+    this.name = "TimeoutFailure";
+  }
+  timeoutType;
+};
+var DeterminismViolation = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DeterminismViolation";
+  }
+};
+var HistoryLimitExceeded = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HistoryLimitExceeded";
+  }
+};
+var PhaseCFeatureError = class extends Error {
+  code = "durable.phaseC";
+  constructor(feature) {
+    super(
+      `${feature} is not available yet (Phase C); durable functions in this release cannot use it`
+    );
+    this.name = "PhaseCFeatureError";
+  }
+};
+function isCancellation(error) {
+  let current = error;
+  for (let depth = 0; depth < 16 && current instanceof Error; depth++) {
+    if (current instanceof CancelledFailure || current.name === "CancelledFailure") return true;
+    if (!(current instanceof ActivityFailure || current instanceof ChildRunFailure)) return false;
+    current = current.cause;
+  }
+  return false;
+}
+function isRunFailure(error) {
+  return error instanceof WorkflowFailure;
+}
+function stackOf(error) {
+  return typeof error.stack === "string" && error.stack !== "" ? error.stack : void 0;
+}
+function errorToFailure(error, source = "sdk-ts", depth = 0) {
+  if (!(error instanceof Error)) return { errorType: "UNKNOWN", message: String(error), source };
+  const failure = {
+    errorType: error instanceof WorkflowFailure ? error.errorType : "UNKNOWN",
+    message: error.message,
+    type: error instanceof ApplicationError && error.type !== void 0 ? error.type : error.name,
+    source
+  };
+  const stack = stackOf(error);
+  if (stack !== void 0) failure.stackTrace = stack;
+  if (error instanceof ApplicationError) {
+    if (error.nonRetryable) failure.nonRetryable = true;
+    if (error.details !== void 0) failure.details = error.details;
+    if (error.nextRetryDelayMs !== void 0) failure.nextRetryDelayMs = error.nextRetryDelayMs;
+    if (error.category !== void 0) failure.category = error.category;
+  }
+  if (error instanceof TimeoutFailure) failure.timeoutType = error.timeoutType;
+  if (error instanceof ServerFailure && error.nonRetryable) failure.nonRetryable = true;
+  const cause = error.cause;
+  if (cause !== void 0 && depth < 16) failure.cause = errorToFailure(cause, source, depth + 1);
+  return failure;
+}
+function failureToError(failure, depth = 0) {
+  const cause = failure.cause && depth < 16 ? failureToError(failure.cause, depth + 1) : void 0;
+  let error;
+  switch (failure.type) {
+    case "CancelledFailure":
+      error = new CancelledFailure(failure.message);
+      break;
+    case "TerminatedFailure":
+      error = new TerminatedFailure(failure.message);
+      break;
+    case "TimeoutFailure":
+      error = new TimeoutFailure(failure.message, failure.timeoutType ?? "UNKNOWN");
+      break;
+    case "ServerFailure":
+      error = new ServerFailure(failure.message, failure.nonRetryable === true, failure.errorType);
+      break;
+    default:
+      if (failure.timeoutType !== void 0 && failure.errorType === "TIMEOUT" && !failure.type)
+        error = new TimeoutFailure(failure.message, failure.timeoutType);
+      else
+        error = new ApplicationError(failure.message, {
+          errorType: failure.errorType,
+          ...failure.type !== void 0 ? { type: failure.type } : {},
+          ...failure.nonRetryable !== void 0 ? { nonRetryable: failure.nonRetryable } : {},
+          ...failure.details !== void 0 ? { details: failure.details } : {},
+          ...failure.nextRetryDelayMs !== void 0 ? { nextRetryDelay: failure.nextRetryDelayMs } : {},
+          ...failure.category !== void 0 ? { category: failure.category } : {},
+          ...cause !== void 0 ? { cause } : {}
+        });
+  }
+  if (cause !== void 0 && !(error instanceof ApplicationError))
+    Object.defineProperty(error, "cause", {
+      value: cause,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  if (failure.stackTrace !== void 0) error.stack = failure.stackTrace;
+  return error;
+}
+
+// src/durable/durations.ts
+function toMs(value, what = "duration") {
+  const ms = chunkFR7KYWRO_cjs.durationMs(value, "ms");
+  if (ms === void 0) throw new TypeError(`${what} "${String(value)}" is not a duration`);
+  return Math.round(ms);
+}
+function optionalMs(value, what) {
+  return value === void 0 ? void 0 : toMs(value, what);
+}
+
+exports.ActivityFailure = ActivityFailure;
+exports.ApplicationError = ApplicationError;
+exports.CancelledFailure = CancelledFailure;
+exports.ChildRunFailure = ChildRunFailure;
+exports.DeterminismViolation = DeterminismViolation;
+exports.HistoryLimitExceeded = HistoryLimitExceeded;
+exports.PhaseCFeatureError = PhaseCFeatureError;
+exports.ServerFailure = ServerFailure;
+exports.TerminatedFailure = TerminatedFailure;
+exports.TimeoutFailure = TimeoutFailure;
+exports.WorkflowFailure = WorkflowFailure;
+exports.defineQuery = defineQuery;
+exports.defineSignal = defineSignal;
+exports.defineUpdate = defineUpdate;
+exports.errorToFailure = errorToFailure;
+exports.failureToError = failureToError;
+exports.isCancellation = isCancellation;
+exports.isRunFailure = isRunFailure;
+exports.optionalMs = optionalMs;
+exports.signalName = signalName;
+exports.toMs = toMs;

package/dist/chunk-FQIHX7YI.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+// 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";
+
+exports.DURABLE_MARKER = DURABLE_MARKER;
+exports.SDK_VERSION = SDK_VERSION;
+exports.interfaceOf = interfaceOf;
+exports.isDurableWorkflow = isDurableWorkflow;
+exports.jsonSchemaOf = jsonSchemaOf;
+exports.workflow = workflow;

package/dist/chunk-FR7KYWRO.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+// src/ir/duration.ts
+var SHORT = /^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)$/;
+var ISO = /^P(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
+var SECOND_MS = 1e3;
+var MINUTE_MS = 60 * SECOND_MS;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+var WEEK_MS = 7 * DAY_MS;
+var UNIT_MS = {
+  ms: 1,
+  s: SECOND_MS,
+  m: MINUTE_MS,
+  h: HOUR_MS,
+  d: DAY_MS,
+  w: WEEK_MS
+};
+function durationMs(value, numberUnit) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) return void 0;
+    return numberUnit === "s" ? value * 1e3 : value;
+  }
+  if (typeof value !== "string") return void 0;
+  const text = value.trim();
+  const short = SHORT.exec(text);
+  if (short?.[1] !== void 0 && short[2] !== void 0) {
+    const unit = UNIT_MS[short[2]];
+    return unit === void 0 ? void 0 : Number(short[1]) * unit;
+  }
+  const iso = ISO.exec(text);
+  if (iso && text !== "P" && text !== "PT") {
+    const [, weeks, days, hours, minutes, seconds] = iso;
+    const parts = [weeks, days, hours, minutes, seconds];
+    if (parts.every((part) => part === void 0)) return void 0;
+    return Number(weeks ?? 0) * WEEK_MS + Number(days ?? 0) * DAY_MS + Number(hours ?? 0) * HOUR_MS + Number(minutes ?? 0) * MINUTE_MS + Number(seconds ?? 0) * SECOND_MS;
+  }
+  return void 0;
+}
+
+exports.durationMs = durationMs;