@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/runtime/index.js

@@ -1,9 +1,947 @@
-export { GeneratedExecutionContext } from "./ExecutionContext.js";
-export { CancellationError } from "./CancellationError.js";
-export { DebugController } from "./debug-controller.js";
-export { CheckpointWriter, loadCheckpoint, findLatestCheckpoint } from "./checkpoint.js";
-export * from "./events.js";
-export * from "./function-registry.js";
-export * from "./parameter-resolver.js";
-export * from "./builtin-functions.js";
-//# sourceMappingURL=index.js.map
+import {
+  GeneratedExecutionContext
+} from "../chunks/chunk-KMCAYNUM.js";
+import {
+  AmbiguousEffectError,
+  DurableExecution,
+  DurableGateYield,
+  acceptGateResolution,
+  createWorkflowRuntime
+} from "../chunks/chunk-OOQG7UPP.js";
+import {
+  EXECUTABLE_WORKFLOW_METADATA_EXPORT,
+  EXECUTABLE_WORKFLOW_MODULE_FORMAT
+} from "../chunks/chunk-QJDAVSNY.js";
+import {
+  StrictJsonError,
+  decodeContinuation,
+  parseStrictJson
+} from "../chunks/chunk-DCMGQP5V.js";
+import {
+  CancellationError
+} from "../chunks/chunk-6KMVP6AU.js";
+import {
+  CONTINUATION_FORMAT_VERSION,
+  ENGINE_VERSION,
+  ENVELOPE_KEYS,
+  GENERATOR_ABI,
+  MAX_CONTINUATION_BYTES,
+  MAX_CONTINUATION_DEPTH,
+  MAX_CONTINUATION_ENTRIES,
+  MAX_CONTINUATION_STRING_BYTES,
+  WireValidationError,
+  acceptContinuation,
+  assertAcceptedContinuation,
+  canonicalWireValue,
+  cloneAndFreezeWireValue,
+  continuationChecksum,
+  createContinuationEnvelope,
+  durableGateId,
+  executionAddressKey,
+  hasExactlyTheKeys,
+  isExecutionAddress,
+  isPlainObjectRecord,
+  operationKey,
+  sha256Hex,
+  structurallyValidEnvelope,
+  utf8ByteLength,
+  validateWireValue
+} from "../chunks/chunk-O2U2LO57.js";
+import "../chunks/chunk-QDE4Z7KW.js";
+import "../chunks/chunk-SEWDMQ6Q.js";
+
+// src/runtime/debug-controller.ts
+var DebugController = class {
+  mode;
+  breakpoints;
+  completedNodes = [];
+  completedSet = /* @__PURE__ */ new Set();
+  executionOrder = [];
+  position = 0;
+  lastCompletedNodeId = null;
+  // Execution-scoped live debugger pause state.
+  _gateResolve = null;
+  _pauseResolve = null;
+  _pausePromise;
+  // Variable modification buffer: applied before next node runs
+  pendingModifications = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.mode = config.debug ? "step" : "run";
+    this.breakpoints = new Set(config.breakpoints ?? []);
+    this.executionOrder = config.executionOrder ?? [];
+    this._pausePromise = this._createPausePromise();
+  }
+  /** Set the execution order (called by executor after compilation) */
+  setExecutionOrder(order) {
+    this.executionOrder = order;
+  }
+  // -----------------------------------------------------------------------
+  // Node boundary hooks (called by generated code)
+  // -----------------------------------------------------------------------
+  /**
+   * Called before a node executes.
+   */
+  async beforeNode(nodeId, ctx) {
+    this.applyPendingModifications(ctx);
+    const shouldPause = this.mode === "step" || this.mode === "continueToBreakpoint" && this.breakpoints.has(nodeId);
+    if (shouldPause) {
+      const action = await this.pause(nodeId, "before", ctx);
+      ctx.checkAborted(nodeId);
+      if (action.type === "abort") {
+        throw new Error(`Debug session aborted at node "${nodeId}"`);
+      }
+      this.applyAction(action);
+    }
+  }
+  /**
+   * Called after a node completes successfully.
+   */
+  async afterNode(nodeId, ctx) {
+    this.completedNodes.push(nodeId);
+    this.completedSet.add(nodeId);
+    this.lastCompletedNodeId = nodeId;
+    this.position++;
+    if (this.mode === "step") {
+      const action = await this.pause(nodeId, "after", ctx);
+      ctx.checkAborted(nodeId);
+      if (action.type === "abort") {
+        throw new Error(`Debug session aborted after node "${nodeId}"`);
+      }
+      this.applyAction(action);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Pause/resume channel
+  // -----------------------------------------------------------------------
+  /**
+   * Awaited by the executor to detect when the controller pauses.
+   * Resolves with the current debug state.
+   */
+  onPause() {
+    return this._pausePromise;
+  }
+  /**
+   * Called by MCP tools or CLI to resume execution.
+   */
+  resume(action) {
+    if (action.type !== "abort") {
+      this.applyAction(action);
+    }
+    this._gateResolve?.(action);
+    this._gateResolve = null;
+    this._pausePromise = this._createPausePromise();
+  }
+  // -----------------------------------------------------------------------
+  // Variable modification
+  // -----------------------------------------------------------------------
+  /**
+   * Queue a variable modification. Applied before the next node runs.
+   * Key format: "nodeId:portName:executionIndex"
+   */
+  setVariable(key, value) {
+    this.pendingModifications.set(key, value);
+  }
+  // -----------------------------------------------------------------------
+  // Breakpoints
+  // -----------------------------------------------------------------------
+  addBreakpoint(nodeId) {
+    this.breakpoints.add(nodeId);
+  }
+  removeBreakpoint(nodeId) {
+    this.breakpoints.delete(nodeId);
+  }
+  getBreakpoints() {
+    return [...this.breakpoints];
+  }
+  // -----------------------------------------------------------------------
+  // State inspection
+  // -----------------------------------------------------------------------
+  /** Build the current debug state for external consumers */
+  buildState(nodeId, phase, ctx) {
+    const variables = this.extractVariables(ctx);
+    const currentNodeOutputs = this.lastCompletedNodeId ? this.extractNodeOutputs(this.lastCompletedNodeId, variables) : void 0;
+    return {
+      currentNodeId: nodeId,
+      phase,
+      completedNodes: [...this.completedNodes],
+      executionOrder: [...this.executionOrder],
+      position: this.position,
+      variables,
+      currentNodeOutputs,
+      breakpoints: [...this.breakpoints]
+    };
+  }
+  /** Get completed nodes list */
+  getCompletedNodes() {
+    return [...this.completedNodes];
+  }
+  // -----------------------------------------------------------------------
+  // Internal helpers
+  // -----------------------------------------------------------------------
+  async pause(nodeId, phase, ctx) {
+    const abortSignal = ctx.getAbortSignal();
+    if (abortSignal?.aborted) {
+      throw new CancellationError(
+        `Workflow execution cancelled at debug ${phase} gate for node "${nodeId}"`,
+        0,
+        nodeId
+      );
+    }
+    const state = this.buildState(nodeId, phase, ctx);
+    this._pauseResolve?.(state);
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const cleanup = () => abortSignal?.removeEventListener("abort", onAbort);
+      const onAbort = () => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        this._gateResolve = null;
+        reject(
+          new CancellationError(
+            `Workflow execution cancelled at debug ${phase} gate for node "${nodeId}"`,
+            0,
+            nodeId
+          )
+        );
+      };
+      this._gateResolve = (action) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve(action);
+      };
+      abortSignal?.addEventListener("abort", onAbort, { once: true });
+      if (abortSignal?.aborted) onAbort();
+    });
+  }
+  /** Set the mode for the next nodes. An abort never gets here: each caller throws or skips it first. */
+  applyAction(action) {
+    switch (action.type) {
+      case "step":
+        this.mode = "step";
+        break;
+      case "continue":
+        this.mode = "continue";
+        break;
+      case "continueToBreakpoint":
+        this.mode = "continueToBreakpoint";
+        break;
+    }
+  }
+  applyPendingModifications(ctx) {
+    if (this.pendingModifications.size === 0) return;
+    for (const [key, value] of this.pendingModifications) {
+      const parts = key.split(":");
+      if (parts.length >= 3) {
+        const address = {
+          id: parts[0],
+          portName: parts[1],
+          executionIndex: parseInt(parts[2], 10)
+        };
+        void ctx.setVariable(address, value);
+      }
+    }
+    this.pendingModifications.clear();
+  }
+  extractVariables(ctx) {
+    return ctx.inspectVariables();
+  }
+  extractNodeOutputs(nodeId, allVariables) {
+    const outputs = {};
+    const prefix = `${nodeId}:`;
+    for (const [key, value] of Object.entries(allVariables)) {
+      if (key.startsWith(prefix)) {
+        const rest = key.substring(prefix.length);
+        const colonIdx = rest.lastIndexOf(":");
+        const portName = colonIdx >= 0 ? rest.substring(0, colonIdx) : rest;
+        outputs[portName] = value;
+      }
+    }
+    return outputs;
+  }
+  _createPausePromise() {
+    return new Promise((resolve) => {
+      this._pauseResolve = resolve;
+    });
+  }
+};
+
+// src/runtime/function-registry.ts
+var FunctionRegistry = class {
+  functions = /* @__PURE__ */ new Map();
+  /**
+   * Register a function with the registry
+   */
+  register(config) {
+    if (this.functions.has(config.id)) {
+      throw new Error(`Function with ID '${config.id}' is already registered`);
+    }
+    this.functions.set(config.id, config);
+  }
+  /**
+   * Get a function by ID
+   */
+  get(id) {
+    const registered = this.functions.get(id);
+    return registered?.fn;
+  }
+  /**
+   * Get function metadata without the function itself
+   */
+  getMetadata(id) {
+    const registered = this.functions.get(id);
+    if (!registered) return void 0;
+    const { fn: _, ...metadata } = registered;
+    return metadata;
+  }
+  /**
+   * List all registered functions, optionally filtered by category
+   */
+  list(category) {
+    const all = Array.from(this.functions.values());
+    const filtered = category ? all.filter((f) => f.category === category) : all;
+    return filtered.map(({ fn: _, ...metadata }) => metadata);
+  }
+  /**
+   * Check if a function is registered
+   */
+  has(id) {
+    return this.functions.has(id);
+  }
+  /**
+   * Clear all registered functions (useful for testing)
+   */
+  clear() {
+    this.functions.clear();
+  }
+  /**
+   * Get the count of registered functions
+   */
+  get size() {
+    return this.functions.size;
+  }
+};
+var functionRegistry = new FunctionRegistry();
+
+// src/runtime/parameter-resolver.ts
+function resolveFunction(param) {
+  if (typeof param === "function") {
+    return {
+      fn: param,
+      source: "direct"
+    };
+  }
+  if (typeof param === "string") {
+    const fn = functionRegistry.get(param);
+    if (!fn) {
+      throw new Error(`Function '${param}' not found in registry`);
+    }
+    return {
+      fn,
+      source: "registry",
+      registryId: param
+    };
+  }
+  if (typeof param === "object" && param !== null && "registryId" in param) {
+    const fn = functionRegistry.get(param.registryId);
+    if (!fn) {
+      throw new Error(`Function '${param.registryId}' not found in registry`);
+    }
+    if (param.partialArgs) {
+      const partialArgs = param.partialArgs;
+      const wrappedFn = (input) => {
+        const mergedInput = typeof input === "object" && input !== null ? { ...partialArgs, ...input } : input;
+        return fn(mergedInput);
+      };
+      return {
+        fn: wrappedFn,
+        source: "registry",
+        registryId: param.registryId
+      };
+    }
+    return {
+      fn,
+      source: "registry",
+      registryId: param.registryId
+    };
+  }
+  throw new Error(`Invalid function parameter: ${JSON.stringify(param)}`);
+}
+function isFunctionLike(value) {
+  if (typeof value === "function") return true;
+  if (typeof value === "string") return true;
+  if (typeof value === "object" && value !== null && "registryId" in value && typeof value.registryId === "string") {
+    return true;
+  }
+  return false;
+}
+function tryResolveFunction(param) {
+  try {
+    return resolveFunction(param);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/runtime/builtin-functions.ts
+functionRegistry.register({
+  id: "string:uppercase",
+  name: "Uppercase",
+  description: "Convert string to uppercase",
+  category: "transform",
+  fn: (input) => input.toUpperCase(),
+  inputType: "string",
+  outputType: "string",
+  examples: [{ input: "hello", output: "HELLO" }]
+});
+functionRegistry.register({
+  id: "string:lowercase",
+  name: "Lowercase",
+  description: "Convert string to lowercase",
+  category: "transform",
+  fn: (input) => input.toLowerCase(),
+  inputType: "string",
+  outputType: "string",
+  examples: [{ input: "HELLO", output: "hello" }]
+});
+functionRegistry.register({
+  id: "string:trim",
+  name: "Trim",
+  description: "Remove whitespace from both ends of a string",
+  category: "transform",
+  fn: (input) => input.trim(),
+  inputType: "string",
+  outputType: "string",
+  examples: [{ input: "  hello  ", output: "hello" }]
+});
+functionRegistry.register({
+  id: "string:truncate",
+  name: "Truncate",
+  description: "Truncate string to specified length with ellipsis",
+  category: "transform",
+  fn: (input) => {
+    const { text, maxLength, suffix = "..." } = input;
+    if (text.length <= maxLength) return text;
+    return text.slice(0, maxLength - suffix.length) + suffix;
+  },
+  inputType: "object",
+  outputType: "string",
+  inputSchema: {
+    type: "object",
+    properties: {
+      text: { type: "string" },
+      maxLength: { type: "number" },
+      suffix: { type: "string", default: "..." }
+    },
+    required: ["text", "maxLength"]
+  },
+  examples: [
+    { input: { text: "Hello World", maxLength: 8 }, output: "Hello..." }
+  ]
+});
+functionRegistry.register({
+  id: "string:split",
+  name: "Split",
+  description: "Split string by delimiter",
+  category: "transform",
+  fn: (input) => input.text.split(input.delimiter),
+  inputType: "object",
+  outputType: "array",
+  examples: [
+    { input: { text: "a,b,c", delimiter: "," }, output: ["a", "b", "c"] }
+  ]
+});
+functionRegistry.register({
+  id: "string:join",
+  name: "Join",
+  description: "Join array elements with delimiter",
+  category: "transform",
+  fn: (input) => input.items.join(input.delimiter),
+  inputType: "object",
+  outputType: "string",
+  examples: [
+    { input: { items: ["a", "b", "c"], delimiter: "," }, output: "a,b,c" }
+  ]
+});
+functionRegistry.register({
+  id: "string:prefix",
+  name: "Prefix",
+  description: "Add prefix to string",
+  category: "transform",
+  fn: (input) => input.prefix + input.text,
+  inputType: "object",
+  outputType: "string",
+  examples: [
+    { input: { text: "world", prefix: "hello " }, output: "hello world" }
+  ]
+});
+functionRegistry.register({
+  id: "string:suffix",
+  name: "Suffix",
+  description: "Add suffix to string",
+  category: "transform",
+  fn: (input) => input.text + input.suffix,
+  inputType: "object",
+  outputType: "string",
+  examples: [
+    { input: { text: "hello", suffix: " world" }, output: "hello world" }
+  ]
+});
+functionRegistry.register({
+  id: "number:double",
+  name: "Double",
+  description: "Double a number",
+  category: "transform",
+  fn: (input) => input * 2,
+  inputType: "number",
+  outputType: "number",
+  examples: [{ input: 5, output: 10 }]
+});
+functionRegistry.register({
+  id: "number:round",
+  name: "Round",
+  description: "Round a number to specified decimal places",
+  category: "transform",
+  fn: (input) => {
+    const { value, decimals = 0 } = input;
+    const factor = Math.pow(10, decimals);
+    return Math.round(value * factor) / factor;
+  },
+  inputType: "object",
+  outputType: "number",
+  examples: [
+    { input: { value: 3.14159, decimals: 2 }, output: 3.14 }
+  ]
+});
+functionRegistry.register({
+  id: "number:clamp",
+  name: "Clamp",
+  description: "Clamp a number between min and max values",
+  category: "transform",
+  fn: (input) => {
+    const { value, min, max } = input;
+    return Math.min(Math.max(value, min), max);
+  },
+  inputType: "object",
+  outputType: "number",
+  inputSchema: {
+    type: "object",
+    properties: {
+      value: { type: "number" },
+      min: { type: "number" },
+      max: { type: "number" }
+    },
+    required: ["value", "min", "max"]
+  },
+  examples: [
+    { input: { value: 150, min: 0, max: 100 }, output: 100 },
+    { input: { value: -10, min: 0, max: 100 }, output: 0 },
+    { input: { value: 50, min: 0, max: 100 }, output: 50 }
+  ]
+});
+functionRegistry.register({
+  id: "number:abs",
+  name: "Absolute",
+  description: "Get absolute value of a number",
+  category: "transform",
+  fn: (input) => Math.abs(input),
+  inputType: "number",
+  outputType: "number",
+  examples: [{ input: -5, output: 5 }]
+});
+functionRegistry.register({
+  id: "number:negate",
+  name: "Negate",
+  description: "Negate a number",
+  category: "transform",
+  fn: (input) => -input,
+  inputType: "number",
+  outputType: "number",
+  examples: [{ input: 5, output: -5 }]
+});
+functionRegistry.register({
+  id: "array:first",
+  name: "First",
+  description: "Get first element of array",
+  category: "transform",
+  fn: (input) => input[0],
+  inputType: "array",
+  outputType: "any",
+  examples: [{ input: [1, 2, 3], output: 1 }]
+});
+functionRegistry.register({
+  id: "array:last",
+  name: "Last",
+  description: "Get last element of array",
+  category: "transform",
+  fn: (input) => input[input.length - 1],
+  inputType: "array",
+  outputType: "any",
+  examples: [{ input: [1, 2, 3], output: 3 }]
+});
+functionRegistry.register({
+  id: "array:reverse",
+  name: "Reverse",
+  description: "Reverse array order",
+  category: "transform",
+  fn: (input) => [...input].reverse(),
+  inputType: "array",
+  outputType: "array",
+  examples: [{ input: [1, 2, 3], output: [3, 2, 1] }]
+});
+functionRegistry.register({
+  id: "array:unique",
+  name: "Unique",
+  description: "Remove duplicate elements from array",
+  category: "transform",
+  fn: (input) => [...new Set(input)],
+  inputType: "array",
+  outputType: "array",
+  examples: [{ input: [1, 2, 2, 3, 3, 3], output: [1, 2, 3] }]
+});
+functionRegistry.register({
+  id: "array:flatten",
+  name: "Flatten",
+  description: "Flatten nested arrays by one level",
+  category: "transform",
+  fn: (input) => input.flat(),
+  inputType: "array",
+  outputType: "array",
+  examples: [{ input: [[1, 2], [3, 4]], output: [1, 2, 3, 4] }]
+});
+functionRegistry.register({
+  id: "array:sort",
+  name: "Sort",
+  description: "Sort array elements",
+  category: "transform",
+  fn: (input) => [...input].sort(),
+  inputType: "array",
+  outputType: "array",
+  examples: [{ input: [3, 1, 2], output: [1, 2, 3] }]
+});
+functionRegistry.register({
+  id: "array:length",
+  name: "Length",
+  description: "Get array length",
+  category: "transform",
+  fn: (input) => input.length,
+  inputType: "array",
+  outputType: "number",
+  examples: [{ input: [1, 2, 3], output: 3 }]
+});
+functionRegistry.register({
+  id: "object:pick",
+  name: "Pick",
+  description: "Pick specified keys from object",
+  category: "transform",
+  fn: (input) => {
+    const { obj, keys } = input;
+    const result = {};
+    for (const key of keys) {
+      if (key in obj) {
+        result[key] = obj[key];
+      }
+    }
+    return result;
+  },
+  inputType: "object",
+  outputType: "object",
+  examples: [
+    { input: { obj: { a: 1, b: 2, c: 3 }, keys: ["a", "c"] }, output: { a: 1, c: 3 } }
+  ]
+});
+functionRegistry.register({
+  id: "object:omit",
+  name: "Omit",
+  description: "Omit specified keys from object",
+  category: "transform",
+  fn: (input) => {
+    const { obj, keys } = input;
+    const keySet = new Set(keys);
+    const result = {};
+    for (const key in obj) {
+      if (!keySet.has(key)) {
+        result[key] = obj[key];
+      }
+    }
+    return result;
+  },
+  inputType: "object",
+  outputType: "object",
+  examples: [
+    { input: { obj: { a: 1, b: 2, c: 3 }, keys: ["b"] }, output: { a: 1, c: 3 } }
+  ]
+});
+functionRegistry.register({
+  id: "object:get",
+  name: "Get",
+  description: "Get value at path from object",
+  category: "transform",
+  fn: (input) => {
+    const { obj, path } = input;
+    const keys = path.split(".");
+    let current = obj;
+    for (const key of keys) {
+      if (current === null || current === void 0) return void 0;
+      current = current[key];
+    }
+    return current;
+  },
+  inputType: "object",
+  outputType: "any",
+  examples: [
+    { input: { obj: { a: { b: { c: 42 } } }, path: "a.b.c" }, output: 42 }
+  ]
+});
+functionRegistry.register({
+  id: "object:keys",
+  name: "Keys",
+  description: "Get object keys",
+  category: "transform",
+  fn: (input) => Object.keys(input),
+  inputType: "object",
+  outputType: "array",
+  examples: [
+    { input: { a: 1, b: 2 }, output: ["a", "b"] }
+  ]
+});
+functionRegistry.register({
+  id: "object:values",
+  name: "Values",
+  description: "Get object values",
+  category: "transform",
+  fn: (input) => Object.values(input),
+  inputType: "object",
+  outputType: "array",
+  examples: [
+    { input: { a: 1, b: 2 }, output: [1, 2] }
+  ]
+});
+functionRegistry.register({
+  id: "filter:truthy",
+  name: "Truthy",
+  description: "Filter to only truthy values",
+  category: "filter",
+  fn: (input) => input.filter(Boolean),
+  inputType: "array",
+  outputType: "array",
+  examples: [{ input: [0, 1, "", "hello", null, true], output: [1, "hello", true] }]
+});
+functionRegistry.register({
+  id: "filter:nonEmpty",
+  name: "Non-Empty",
+  description: "Filter out empty strings and arrays",
+  category: "filter",
+  fn: (input) => input.filter((x) => {
+    if (typeof x === "string") return x.length > 0;
+    if (Array.isArray(x)) return x.length > 0;
+    return true;
+  }),
+  inputType: "array",
+  outputType: "array",
+  examples: [{ input: ["hello", "", "world", []], output: ["hello", "world"] }]
+});
+functionRegistry.register({
+  id: "filter:greaterThan",
+  name: "Greater Than",
+  description: "Filter numbers greater than threshold",
+  category: "filter",
+  fn: (input) => input.items.filter((n) => n > input.threshold),
+  inputType: "object",
+  outputType: "array",
+  examples: [
+    { input: { items: [1, 5, 10, 15], threshold: 7 }, output: [10, 15] }
+  ]
+});
+functionRegistry.register({
+  id: "filter:lessThan",
+  name: "Less Than",
+  description: "Filter numbers less than threshold",
+  category: "filter",
+  fn: (input) => input.items.filter((n) => n < input.threshold),
+  inputType: "object",
+  outputType: "array",
+  examples: [
+    { input: { items: [1, 5, 10, 15], threshold: 7 }, output: [1, 5] }
+  ]
+});
+functionRegistry.register({
+  id: "validate:email",
+  name: "Email",
+  description: "Validate email address format",
+  category: "validate",
+  fn: (input) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(input);
+  },
+  inputType: "string",
+  outputType: "boolean",
+  examples: [
+    { input: "test@example.com", output: true },
+    { input: "invalid", output: false }
+  ]
+});
+functionRegistry.register({
+  id: "validate:url",
+  name: "URL",
+  description: "Validate URL format",
+  category: "validate",
+  fn: (input) => {
+    try {
+      new URL(input);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  inputType: "string",
+  outputType: "boolean",
+  examples: [
+    { input: "https://example.com", output: true },
+    { input: "not-a-url", output: false }
+  ]
+});
+functionRegistry.register({
+  id: "validate:nonEmpty",
+  name: "Non-Empty",
+  description: "Validate string is not empty",
+  category: "validate",
+  fn: (input) => input.trim().length > 0,
+  inputType: "string",
+  outputType: "boolean",
+  examples: [
+    { input: "hello", output: true },
+    { input: "", output: false },
+    { input: "   ", output: false }
+  ]
+});
+functionRegistry.register({
+  id: "validate:numeric",
+  name: "Numeric",
+  description: "Validate string is numeric",
+  category: "validate",
+  fn: (input) => !isNaN(Number(input)) && input.trim() !== "",
+  inputType: "string",
+  outputType: "boolean",
+  examples: [
+    { input: "123", output: true },
+    { input: "12.34", output: true },
+    { input: "abc", output: false }
+  ]
+});
+functionRegistry.register({
+  id: "format:json",
+  name: "JSON",
+  description: "Format value as JSON string",
+  category: "format",
+  fn: (input) => JSON.stringify(input, null, 2),
+  inputType: "any",
+  outputType: "string",
+  examples: [
+    { input: { a: 1 }, output: '{\n  "a": 1\n}' }
+  ]
+});
+functionRegistry.register({
+  id: "format:jsonCompact",
+  name: "JSON Compact",
+  description: "Format value as compact JSON string",
+  category: "format",
+  fn: (input) => JSON.stringify(input),
+  inputType: "any",
+  outputType: "string",
+  examples: [
+    { input: { a: 1 }, output: '{"a":1}' }
+  ]
+});
+functionRegistry.register({
+  id: "format:date",
+  name: "Date",
+  description: "Format date to ISO string or custom format",
+  category: "format",
+  fn: (input) => {
+    const date = input instanceof Date ? input : new Date(input);
+    return date.toISOString();
+  },
+  inputType: "any",
+  outputType: "string",
+  examples: [
+    { input: "2024-01-15", output: "2024-01-15T00:00:00.000Z" }
+  ]
+});
+functionRegistry.register({
+  id: "format:currency",
+  name: "Currency",
+  description: "Format number as currency",
+  category: "format",
+  fn: (input) => {
+    const { value, currency = "USD", locale = "en-US" } = input;
+    return new Intl.NumberFormat(locale, { style: "currency", currency }).format(value);
+  },
+  inputType: "object",
+  outputType: "string",
+  examples: [
+    { input: { value: 1234.56 }, output: "$1,234.56" }
+  ]
+});
+functionRegistry.register({
+  id: "format:percentage",
+  name: "Percentage",
+  description: "Format number as percentage",
+  category: "format",
+  fn: (input) => {
+    const { value, decimals = 0 } = input;
+    return `${(value * 100).toFixed(decimals)}%`;
+  },
+  inputType: "object",
+  outputType: "string",
+  examples: [
+    { input: { value: 0.75 }, output: "75%" },
+    { input: { value: 0.756, decimals: 1 }, output: "75.6%" }
+  ]
+});
+export {
+  AmbiguousEffectError,
+  CONTINUATION_FORMAT_VERSION,
+  CancellationError,
+  DebugController,
+  DurableExecution,
+  DurableGateYield,
+  ENGINE_VERSION,
+  ENVELOPE_KEYS,
+  EXECUTABLE_WORKFLOW_METADATA_EXPORT,
+  EXECUTABLE_WORKFLOW_MODULE_FORMAT,
+  FunctionRegistry,
+  GENERATOR_ABI,
+  GeneratedExecutionContext,
+  MAX_CONTINUATION_BYTES,
+  MAX_CONTINUATION_DEPTH,
+  MAX_CONTINUATION_ENTRIES,
+  MAX_CONTINUATION_STRING_BYTES,
+  StrictJsonError,
+  WireValidationError,
+  acceptContinuation,
+  acceptGateResolution,
+  assertAcceptedContinuation,
+  canonicalWireValue,
+  cloneAndFreezeWireValue,
+  continuationChecksum,
+  createContinuationEnvelope,
+  createWorkflowRuntime,
+  decodeContinuation,
+  durableGateId,
+  executionAddressKey,
+  functionRegistry,
+  hasExactlyTheKeys,
+  isExecutionAddress,
+  isFunctionLike,
+  isPlainObjectRecord,
+  operationKey,
+  parseStrictJson,
+  resolveFunction,
+  sha256Hex,
+  structurallyValidEnvelope,
+  tryResolveFunction,
+  utf8ByteLength,
+  validateWireValue
+};