@fluidgrids/workflows 2026.1027.0 → 2026.1028.1

package/dist/chunk-BO6OVILK.js

@@ -0,0 +1,79 @@
+// src/history/allowlist.ts
+var ACTIVITY_INTERNAL_ALLOWLIST = /* @__PURE__ */ new Set([
+  "internal:http",
+  "internal:datatable",
+  "internal:set",
+  "internal:code"
+]);
+var ACTIVITY_NODE_DENYLIST = /* @__PURE__ */ new Set([
+  "internal:end",
+  "internal:if",
+  "internal:switch",
+  "internal:loop",
+  "internal:merge",
+  "internal:wait",
+  "internal:subworkflow",
+  "internal:code-workflow",
+  "internal:wait-for-signal",
+  "internal:send-and-wait",
+  "internal:respond-to-webhook",
+  "internal:failure-triage"
+]);
+var ACTIVITY_NODE_ALLOWLIST = {
+  internal: ACTIVITY_INTERNAL_ALLOWLIST,
+  refused: ACTIVITY_NODE_DENYLIST,
+  /** Non-built-in node types (store and registry nodes) are allowed. */
+  external: "allowed"
+};
+var LEGACY_SHORT_NAMES = /* @__PURE__ */ new Set([
+  "if",
+  "switch",
+  "loop",
+  "merge",
+  "set",
+  "filter",
+  "aggregate",
+  "wait",
+  "noop",
+  "code",
+  "http",
+  "transform",
+  "validate",
+  "log",
+  "error",
+  "subworkflow",
+  "end",
+  "trigger",
+  "webhook",
+  "schedule",
+  "manual",
+  "api"
+]);
+function canonicalType(nodeType) {
+  const lower = nodeType.trim().toLowerCase();
+  return LEGACY_SHORT_NAMES.has(lower) ? `internal:${lower}` : lower;
+}
+function isActivityNodeTypeAllowed(nodeType) {
+  if (typeof nodeType !== "string" || nodeType.trim() === "") return false;
+  const type = canonicalType(nodeType);
+  if (!type.startsWith("internal:")) return true;
+  return ACTIVITY_INTERNAL_ALLOWLIST.has(type);
+}
+var ActivityNodeTypeNotAllowedError = class extends Error {
+  constructor(nodeType) {
+    super(
+      `${nodeType} cannot run as a durable activity: only store and registry nodes and internal:http, internal:datatable, internal:set and internal:code can`
+    );
+    this.nodeType = nodeType;
+    this.name = "ActivityNodeTypeNotAllowedError";
+  }
+  nodeType;
+  code = "durable.activityTypeNotAllowed";
+  errorType = "VALIDATION";
+  nonRetryable = true;
+};
+function assertActivityNodeType(nodeType) {
+  if (!isActivityNodeTypeAllowed(nodeType)) throw new ActivityNodeTypeNotAllowedError(nodeType);
+}
+
+export { ACTIVITY_INTERNAL_ALLOWLIST, ACTIVITY_NODE_ALLOWLIST, ACTIVITY_NODE_DENYLIST, ActivityNodeTypeNotAllowedError, assertActivityNodeType, isActivityNodeTypeAllowed };

package/dist/chunk-C5OLWZ42.js

@@ -0,0 +1,245 @@
+import { durationMs } from './chunk-LNUQE6D6.js';
+
+// 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 = 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);
+}
+
+export { ActivityFailure, ApplicationError, CancelledFailure, ChildRunFailure, DeterminismViolation, HistoryLimitExceeded, PhaseCFeatureError, ServerFailure, TerminatedFailure, TimeoutFailure, WorkflowFailure, defineQuery, defineSignal, defineUpdate, errorToFailure, failureToError, isCancellation, isRunFailure, optionalMs, signalName, toMs };

package/dist/chunk-CBL5JSCC.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var chunk57MSZ24T_cjs = require('./chunk-57MSZ24T.cjs');
+var chunkGVTZMA5C_cjs = require('./chunk-GVTZMA5C.cjs');
+var chunkSAENRNBJ_cjs = require('./chunk-SAENRNBJ.cjs');
+var chunkFQIHX7YI_cjs = require('./chunk-FQIHX7YI.cjs');
+
+// src/builder/collect.ts
+var COLLECTION_FORMAT = "fluidgrids.tier1-collection";
+function triggerOf(spec, where) {
+  if (spec === void 0) return void 0;
+  const operation = chunk57MSZ24T_cjs.isOperation(spec) ? spec : chunkSAENRNBJ_cjs.isRecord(spec) ? spec.operation : void 0;
+  if (!chunk57MSZ24T_cjs.isOperation(operation))
+    throw new chunkGVTZMA5C_cjs.BuilderError(`${where}: trigger must be a trigger operation`);
+  const out = { nodeType: operation.nodeType };
+  if (operation.version !== void 0) out.version = operation.version;
+  if (operation.operation !== void 0) out.operation = operation.operation;
+  if (!chunk57MSZ24T_cjs.isOperation(spec)) {
+    if (spec.args !== void 0) out.args = spec.args;
+    if (spec.id !== void 0) out.id = spec.id;
+  }
+  return out;
+}
+function collectWorkflowExports(modules) {
+  const exportNames = /* @__PURE__ */ new Map();
+  const durable = [];
+  for (const [module, namespace] of modules) {
+    for (const exportName of Object.keys(namespace).sort()) {
+      const value = namespace[exportName];
+      if (!chunkFQIHX7YI_cjs.isDurableWorkflow(value) || exportNames.has(value)) continue;
+      exportNames.set(value, exportName);
+      const options = value.options;
+      const entry = {
+        module,
+        exportName,
+        name: value.name,
+        taskQueue: options.taskQueue ?? "managed",
+        interface: chunkFQIHX7YI_cjs.interfaceOf(value)
+      };
+      if (options.title !== void 0) entry.title = options.title;
+      if (options.description !== void 0) entry.description = options.description;
+      if (options.standalone !== void 0) entry.standalone = options.standalone;
+      const trigger = triggerOf(options.trigger, `workflow("${value.name}")`);
+      if (trigger) entry.trigger = trigger;
+      durable.push(entry);
+    }
+  }
+  const workflows = [];
+  for (const [module, namespace] of modules) {
+    for (const exportName of Object.keys(namespace).sort()) {
+      const value = namespace[exportName];
+      if (!chunk57MSZ24T_cjs.isTier1Workflow(value)) continue;
+      for (const ref of value.durableRefs ?? []) {
+        const resolved = exportNames.get(ref.definition);
+        if (resolved === void 0)
+          throw new chunkGVTZMA5C_cjs.BuilderError(
+            `${value.key}: wf.codeWorkflow node "${ref.nodeId}" uses workflow("${ref.definition.name}"), which no module exports`
+          );
+        const recorded = value.recording.nodes.find((entry) => entry.node.id === ref.nodeId);
+        const state = recorded?.node.args?.state;
+        if (chunkSAENRNBJ_cjs.isRecord(state)) chunkSAENRNBJ_cjs.setOwn(state, "workflowFn", resolved);
+      }
+      workflows.push({ module, exportName, recording: value.recording });
+    }
+  }
+  const collection = {
+    format: COLLECTION_FORMAT,
+    workflows,
+    ...durable.length > 0 ? { durable } : {}
+  };
+  return JSON.stringify(collection);
+}
+
+exports.COLLECTION_FORMAT = COLLECTION_FORMAT;
+exports.collectWorkflowExports = collectWorkflowExports;

package/dist/{chunk-LSKSBVL4.cjs → chunk-CPDK3K5N.cjs}

@@ -1,11 +1,11 @@
 'use strict';
 
-var chunkLRM6JXJA_cjs = require('./chunk-LRM6JXJA.cjs');
+var chunkSAENRNBJ_cjs = require('./chunk-SAENRNBJ.cjs');
 
 // src/ir/manifest.ts
 function operationsOf(manifest) {
   const operations = Array.isArray(manifest.operations) ? manifest.operations : manifest.operations.operations;
-  return Array.isArray(operations) ? operations.filter((operation) => chunkLRM6JXJA_cjs.isRecord(operation) && typeof operation.name === "string") : [];
+  return Array.isArray(operations) ? operations.filter((operation) => chunkSAENRNBJ_cjs.isRecord(operation) && typeof operation.name === "string") : [];
 }
 function isTriggerOperation(operation) {
   if (typeof operation.role === "string") return operation.role.toLowerCase() === "trigger";
@@ -13,7 +13,7 @@ function isTriggerOperation(operation) {
 }
 function fieldOf(value) {
   if (typeof value === "string") return { type: value };
-  return chunkLRM6JXJA_cjs.isRecord(value) ? value : {};
+  return chunkSAENRNBJ_cjs.isRecord(value) ? value : {};
 }
 function fieldSchema(value) {
   const field = fieldOf(value);
@@ -49,10 +49,10 @@ function fieldSchema(value) {
       return { type: "array", ...items, ...description };
     }
     case "object": {
-      if (chunkLRM6JXJA_cjs.isRecord(field.properties)) {
+      if (chunkSAENRNBJ_cjs.isRecord(field.properties)) {
         const properties = {};
         for (const [name, child] of Object.entries(field.properties))
-          properties[name] = fieldSchema(child);
+          chunkSAENRNBJ_cjs.setOwn(properties, name, fieldSchema(child));
         return { type: "object", properties, ...description };
       }
       return { type: "object", ...description };
@@ -65,7 +65,7 @@ function fieldsSchema(fields) {
   const properties = {};
   const required = [];
   for (const [name, field] of Object.entries(fields ?? {})) {
-    properties[name] = fieldSchema(field);
+    chunkSAENRNBJ_cjs.setOwn(properties, name, fieldSchema(field));
     if (fieldOf(field).required === true) required.push(name);
   }
   return {