@fluidgrids/workflows 2026.1027.0 → 2026.1028.1

package/dist/chunk-PDHLTDZB.js

@@ -0,0 +1,72 @@
+import { isTier1Workflow, isOperation } from './chunk-5HDSBTBX.js';
+import { BuilderError } from './chunk-JZ4TOOLN.js';
+import { isRecord, setOwn } from './chunk-PMCM2OH4.js';
+import { isDurableWorkflow, interfaceOf } from './chunk-7NQ37GZU.js';
+
+// src/builder/collect.ts
+var COLLECTION_FORMAT = "fluidgrids.tier1-collection";
+function triggerOf(spec, where) {
+  if (spec === void 0) return void 0;
+  const operation = isOperation(spec) ? spec : isRecord(spec) ? spec.operation : void 0;
+  if (!isOperation(operation))
+    throw new 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 (!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 (!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: 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 (!isTier1Workflow(value)) continue;
+      for (const ref of value.durableRefs ?? []) {
+        const resolved = exportNames.get(ref.definition);
+        if (resolved === void 0)
+          throw new 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 (isRecord(state)) 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);
+}
+
+export { COLLECTION_FORMAT, collectWorkflowExports };

package/dist/chunk-PMCM2OH4.js

@@ -0,0 +1,46 @@
+// 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 setOwn(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true
+  });
+}
+function ownValue(record, key) {
+  return Object.hasOwn(record, key) ? record[key] : void 0;
+}
+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) setOwn(out, key, structuredCloneJson(child));
+    }
+    return out;
+  }
+  return value;
+}
+
+export { cloneJson, deepEqual, isRecord, ownValue, setOwn };