@eigenpal/cli 0.10.20 → 0.10.21

package/dist/cli.js

@@ -17080,8 +17080,143 @@ var require_picocolors = __commonJS((exports, module) => {
   module.exports.createColors = createColors;
 });
 
+// ../../node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/nanoid/index.js
+import { webcrypto as crypto } from "node:crypto";
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid3(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size;i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+var POOL_SIZE_MULTIPLIER = 128, pool, poolOffset;
+var init_nanoid = () => {};
+
+// ../types/src/core/common.ts
+function generateId(prefix) {
+  const id = nanoid3();
+  return prefix ? `${prefix}_${id}` : id;
+}
+function toJsonSchema(schema) {
+  return exports_external.toJSONSchema(schema, { target: "draft-7" });
+}
+var ID_PREFIXES, TimestampSchema, JsonSchemaSchema, BaseEntitySchema;
+var init_common = __esm(() => {
+  init_nanoid();
+  init_zod();
+  ID_PREFIXES = {
+    WORKFLOW: "wf",
+    WORKFLOW_VERSION: "wfv",
+    WORKFLOW_HISTORY: "wfh",
+    JOB: "job",
+    EXECUTION: "exec",
+    STEP_EXECUTION: "step",
+    FILE: "file",
+    TEMPLATE: "tmpl",
+    USER: "user",
+    TENANT: "org",
+    TENANT_INVITE: "inv",
+    API_KEY: "eig",
+    PROCESSOR: "proc",
+    AI_PROVIDER: "aip",
+    ACCOUNT: "acct",
+    SESSION: "sess",
+    VERIFICATION: "vrf",
+    DATASET: "ds",
+    DATASET_EXAMPLE: "dex",
+    EXPERIMENT: "exp",
+    EXPERIMENT_RUN: "exr",
+    EXPERIMENT_EVALUATION: "evl",
+    EVAL_EXAMPLE: "evx",
+    EVAL_RESULT: "evr",
+    EVAL_BATCH: "evb",
+    RUN_REVIEW: "rev",
+    RUN_REVIEW_CORRECTION: "rvc",
+    TABLE_ROW: "row",
+    FOLDER: "fldr",
+    AGENT_WORKFLOW: "awf",
+    AGENT_EXECUTION: "aex",
+    AGENT_EXAMPLE: "aeg",
+    AGENT_VERSION: "avr",
+    AGENT_TRAINING_SESSION: "ats",
+    AGENT_EXPERIMENT: "aexp",
+    AGENT_EMAIL_ALIAS: "aea",
+    AGENT_EMAIL_INVOCATION: "aei",
+    AUTOMATION_TRIGGER: "atr",
+    FILE_SOURCE_CONFIG: "fsc",
+    WEBHOOK_ENDPOINT: "whep",
+    WEBHOOK_EVENT: "whev",
+    WEBHOOK_DELIVERY: "whdl",
+    WEBHOOK_ATTEMPT: "what",
+    SANDBOX_WS_TOKEN: "sws"
+  };
+  TimestampSchema = exports_external.union([exports_external.date(), exports_external.string().datetime()]).transform((val) => {
+    return typeof val === "string" ? new Date(val) : val;
+  });
+  JsonSchemaSchema = exports_external.record(exports_external.string(), exports_external.unknown());
+  BaseEntitySchema = exports_external.object({
+    id: exports_external.string(),
+    createdAt: TimestampSchema.optional(),
+    updatedAt: TimestampSchema.optional()
+  });
+});
+
+// ../types/src/core/ids.ts
+var PROCESSOR_IDS, PARSER_IDS, INPUT_KINDS;
+var init_ids = __esm(() => {
+  PROCESSOR_IDS = {
+    MERGE: "builtin/merge",
+    DOCUMENT_PARSER: "builtin/parser",
+    EXTRACT: "builtin/extract",
+    SPLIT: "builtin/split",
+    SEGMENT: "builtin/segment",
+    CLASSIFY: "builtin/classify",
+    TEMPLATE: "builtin/template",
+    PDF_EMBEDDER: "builtin/pdf-embedder",
+    XLSX_TO_JSON: "builtin/xlsx-to-json"
+  };
+  PARSER_IDS = {
+    KREUZBERG: "builtin/kreuzberg",
+    OCR: "builtin/ocr",
+    LLM_VISION: "builtin/llm-vision"
+  };
+  INPUT_KINDS = {
+    DOCUMENT: "document",
+    PAYLOAD: "payload"
+  };
+});
+
+// ../types/src/core/pagination.ts
+var PaginationParamsSchema, DEFAULT_PAGE_SIZE = 50, MAX_PAGE_SIZE = 100;
+var init_pagination = __esm(() => {
+  init_zod();
+  PaginationParamsSchema = exports_external.object({
+    limit: exports_external.coerce.number().int().min(1).max(100).default(50),
+    offset: exports_external.coerce.number().int().min(0).default(0)
+  });
+});
+
 // ../types/src/core/index.ts
-var init_core3 = () => {};
+var init_core3 = __esm(() => {
+  init_common();
+  init_ids();
+  init_pagination();
+});
 
 // ../types/src/files/legacy-boundary.ts
 var LEGACY_FILE_REF_COMPATIBILITY;
@@ -17106,6 +17241,9 @@ var init_legacy_boundary = __esm(() => {
 function isRuntimeFileRef(input) {
   return RuntimeFileRefSchema.safeParse(input).success;
 }
+function isFilePathDescriptor(input) {
+  return FilePathDescriptorSchema.safeParse(input).success;
+}
 function isResolvedProcessorFile(input) {
   return ResolvedProcessorFileSchema.safeParse(input).success;
 }
@@ -17328,11 +17466,2411 @@ var init_scoped_file_ref = __esm(() => {
   ]);
 });
 
+// ../../node_modules/@opentelemetry/api/build/src/version.js
+var require_version = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.VERSION = undefined;
+  exports.VERSION = "1.9.1";
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/internal/semver.js
+var require_semver = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isCompatible = exports._makeCompatibilityCheck = undefined;
+  var version_1 = require_version();
+  var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+  function _makeCompatibilityCheck(ownVersion) {
+    const acceptedVersions = new Set([ownVersion]);
+    const rejectedVersions = new Set;
+    const myVersionMatch = ownVersion.match(re);
+    if (!myVersionMatch) {
+      return () => false;
+    }
+    const ownVersionParsed = {
+      major: +myVersionMatch[1],
+      minor: +myVersionMatch[2],
+      patch: +myVersionMatch[3],
+      prerelease: myVersionMatch[4]
+    };
+    if (ownVersionParsed.prerelease != null) {
+      return function isExactmatch(globalVersion) {
+        return globalVersion === ownVersion;
+      };
+    }
+    function _reject(v) {
+      rejectedVersions.add(v);
+      return false;
+    }
+    function _accept(v) {
+      acceptedVersions.add(v);
+      return true;
+    }
+    return function isCompatible(globalVersion) {
+      if (acceptedVersions.has(globalVersion)) {
+        return true;
+      }
+      if (rejectedVersions.has(globalVersion)) {
+        return false;
+      }
+      const globalVersionMatch = globalVersion.match(re);
+      if (!globalVersionMatch) {
+        return _reject(globalVersion);
+      }
+      const globalVersionParsed = {
+        major: +globalVersionMatch[1],
+        minor: +globalVersionMatch[2],
+        patch: +globalVersionMatch[3],
+        prerelease: globalVersionMatch[4]
+      };
+      if (globalVersionParsed.prerelease != null) {
+        return _reject(globalVersion);
+      }
+      if (ownVersionParsed.major !== globalVersionParsed.major) {
+        return _reject(globalVersion);
+      }
+      if (ownVersionParsed.major === 0) {
+        if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+          return _accept(globalVersion);
+        }
+        return _reject(globalVersion);
+      }
+      if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    };
+  }
+  exports._makeCompatibilityCheck = _makeCompatibilityCheck;
+  exports.isCompatible = _makeCompatibilityCheck(version_1.VERSION);
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/internal/global-utils.js
+var require_global_utils = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.unregisterGlobal = exports.getGlobal = exports.registerGlobal = undefined;
+  var version_1 = require_version();
+  var semver_1 = require_semver();
+  var major = version_1.VERSION.split(".")[0];
+  var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
+  var _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+  function registerGlobal(type, instance, diag, allowOverride = false) {
+    var _a3;
+    const api2 = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a3 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a3 !== undefined ? _a3 : {
+      version: version_1.VERSION
+    };
+    if (!allowOverride && api2[type]) {
+      const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+      diag.error(err.stack || err.message);
+      return false;
+    }
+    if (api2.version !== version_1.VERSION) {
+      const err = new Error(`@opentelemetry/api: Registration of version v${api2.version} for ${type} does not match previously registered API v${version_1.VERSION}`);
+      diag.error(err.stack || err.message);
+      return false;
+    }
+    api2[type] = instance;
+    diag.debug(`@opentelemetry/api: Registered a global for ${type} v${version_1.VERSION}.`);
+    return true;
+  }
+  exports.registerGlobal = registerGlobal;
+  function getGlobal(type) {
+    var _a3, _b;
+    const globalVersion = (_a3 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a3 === undefined ? undefined : _a3.version;
+    if (!globalVersion || !(0, semver_1.isCompatible)(globalVersion)) {
+      return;
+    }
+    return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === undefined ? undefined : _b[type];
+  }
+  exports.getGlobal = getGlobal;
+  function unregisterGlobal(type, diag) {
+    diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${version_1.VERSION}.`);
+    const api2 = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+    if (api2) {
+      delete api2[type];
+    }
+  }
+  exports.unregisterGlobal = unregisterGlobal;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js
+var require_ComponentLogger = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.DiagComponentLogger = undefined;
+  var global_utils_1 = require_global_utils();
+
+  class DiagComponentLogger {
+    constructor(props) {
+      this._namespace = props.namespace || "DiagComponentLogger";
+    }
+    debug(...args) {
+      return logProxy("debug", this._namespace, args);
+    }
+    error(...args) {
+      return logProxy("error", this._namespace, args);
+    }
+    info(...args) {
+      return logProxy("info", this._namespace, args);
+    }
+    warn(...args) {
+      return logProxy("warn", this._namespace, args);
+    }
+    verbose(...args) {
+      return logProxy("verbose", this._namespace, args);
+    }
+  }
+  exports.DiagComponentLogger = DiagComponentLogger;
+  function logProxy(funcName, namespace, args) {
+    const logger = (0, global_utils_1.getGlobal)("diag");
+    if (!logger) {
+      return;
+    }
+    return logger[funcName](namespace, ...args);
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/types.js
+var require_types = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.DiagLogLevel = undefined;
+  var DiagLogLevel;
+  (function(DiagLogLevel2) {
+    DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+    DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+    DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+    DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+    DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+    DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+    DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+  })(DiagLogLevel = exports.DiagLogLevel || (exports.DiagLogLevel = {}));
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js
+var require_logLevelLogger = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createLogLevelDiagLogger = undefined;
+  var types_1 = require_types();
+  function createLogLevelDiagLogger(maxLevel, logger) {
+    if (maxLevel < types_1.DiagLogLevel.NONE) {
+      maxLevel = types_1.DiagLogLevel.NONE;
+    } else if (maxLevel > types_1.DiagLogLevel.ALL) {
+      maxLevel = types_1.DiagLogLevel.ALL;
+    }
+    logger = logger || {};
+    function _filterFunc(funcName, theLevel) {
+      const theFunc = logger[funcName];
+      if (typeof theFunc === "function" && maxLevel >= theLevel) {
+        return theFunc.bind(logger);
+      }
+      return function() {};
+    }
+    return {
+      error: _filterFunc("error", types_1.DiagLogLevel.ERROR),
+      warn: _filterFunc("warn", types_1.DiagLogLevel.WARN),
+      info: _filterFunc("info", types_1.DiagLogLevel.INFO),
+      debug: _filterFunc("debug", types_1.DiagLogLevel.DEBUG),
+      verbose: _filterFunc("verbose", types_1.DiagLogLevel.VERBOSE)
+    };
+  }
+  exports.createLogLevelDiagLogger = createLogLevelDiagLogger;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/diag.js
+var require_diag = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.DiagAPI = undefined;
+  var ComponentLogger_1 = require_ComponentLogger();
+  var logLevelLogger_1 = require_logLevelLogger();
+  var types_1 = require_types();
+  var global_utils_1 = require_global_utils();
+  var API_NAME = "diag";
+
+  class DiagAPI {
+    static instance() {
+      if (!this._instance) {
+        this._instance = new DiagAPI;
+      }
+      return this._instance;
+    }
+    constructor() {
+      function _logProxy(funcName) {
+        return function(...args) {
+          const logger = (0, global_utils_1.getGlobal)("diag");
+          if (!logger)
+            return;
+          return logger[funcName](...args);
+        };
+      }
+      const self2 = this;
+      const setLogger = (logger, optionsOrLogLevel = { logLevel: types_1.DiagLogLevel.INFO }) => {
+        var _a3, _b, _c;
+        if (logger === self2) {
+          const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+          self2.error((_a3 = err.stack) !== null && _a3 !== undefined ? _a3 : err.message);
+          return false;
+        }
+        if (typeof optionsOrLogLevel === "number") {
+          optionsOrLogLevel = {
+            logLevel: optionsOrLogLevel
+          };
+        }
+        const oldLogger = (0, global_utils_1.getGlobal)("diag");
+        const newLogger = (0, logLevelLogger_1.createLogLevelDiagLogger)((_b = optionsOrLogLevel.logLevel) !== null && _b !== undefined ? _b : types_1.DiagLogLevel.INFO, logger);
+        if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+          const stack = (_c = new Error().stack) !== null && _c !== undefined ? _c : "<failed to generate stacktrace>";
+          oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+          newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+        }
+        return (0, global_utils_1.registerGlobal)("diag", newLogger, self2, true);
+      };
+      self2.setLogger = setLogger;
+      self2.disable = () => {
+        (0, global_utils_1.unregisterGlobal)(API_NAME, self2);
+      };
+      self2.createComponentLogger = (options) => {
+        return new ComponentLogger_1.DiagComponentLogger(options);
+      };
+      self2.verbose = _logProxy("verbose");
+      self2.debug = _logProxy("debug");
+      self2.info = _logProxy("info");
+      self2.warn = _logProxy("warn");
+      self2.error = _logProxy("error");
+    }
+  }
+  exports.DiagAPI = DiagAPI;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js
+var require_baggage_impl = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.BaggageImpl = undefined;
+
+  class BaggageImpl {
+    constructor(entries) {
+      this._entries = entries ? new Map(entries) : new Map;
+    }
+    getEntry(key) {
+      const entry = this._entries.get(key);
+      if (!entry) {
+        return;
+      }
+      return Object.assign({}, entry);
+    }
+    getAllEntries() {
+      return Array.from(this._entries.entries());
+    }
+    setEntry(key, entry) {
+      const newBaggage = new BaggageImpl(this._entries);
+      newBaggage._entries.set(key, entry);
+      return newBaggage;
+    }
+    removeEntry(key) {
+      const newBaggage = new BaggageImpl(this._entries);
+      newBaggage._entries.delete(key);
+      return newBaggage;
+    }
+    removeEntries(...keys) {
+      const newBaggage = new BaggageImpl(this._entries);
+      for (const key of keys) {
+        newBaggage._entries.delete(key);
+      }
+      return newBaggage;
+    }
+    clear() {
+      return new BaggageImpl;
+    }
+  }
+  exports.BaggageImpl = BaggageImpl;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js
+var require_symbol = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.baggageEntryMetadataSymbol = undefined;
+  exports.baggageEntryMetadataSymbol = Symbol("BaggageEntryMetadata");
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/utils.js
+var require_utils = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.baggageEntryMetadataFromString = exports.createBaggage = undefined;
+  var diag_1 = require_diag();
+  var baggage_impl_1 = require_baggage_impl();
+  var symbol_1 = require_symbol();
+  var diag = diag_1.DiagAPI.instance();
+  function createBaggage(entries = {}) {
+    return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries)));
+  }
+  exports.createBaggage = createBaggage;
+  function baggageEntryMetadataFromString(str) {
+    if (typeof str !== "string") {
+      diag.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
+      str = "";
+    }
+    return {
+      __TYPE__: symbol_1.baggageEntryMetadataSymbol,
+      toString() {
+        return str;
+      }
+    };
+  }
+  exports.baggageEntryMetadataFromString = baggageEntryMetadataFromString;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/context/context.js
+var require_context = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ROOT_CONTEXT = exports.createContextKey = undefined;
+  function createContextKey(description) {
+    return Symbol.for(description);
+  }
+  exports.createContextKey = createContextKey;
+
+  class BaseContext {
+    constructor(parentContext) {
+      const self2 = this;
+      self2._currentContext = parentContext ? new Map(parentContext) : new Map;
+      self2.getValue = (key) => self2._currentContext.get(key);
+      self2.setValue = (key, value) => {
+        const context = new BaseContext(self2._currentContext);
+        context._currentContext.set(key, value);
+        return context;
+      };
+      self2.deleteValue = (key) => {
+        const context = new BaseContext(self2._currentContext);
+        context._currentContext.delete(key);
+        return context;
+      };
+    }
+  }
+  exports.ROOT_CONTEXT = new BaseContext;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js
+var require_consoleLogger = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.DiagConsoleLogger = exports._originalConsoleMethods = undefined;
+  var consoleMap = [
+    { n: "error", c: "error" },
+    { n: "warn", c: "warn" },
+    { n: "info", c: "info" },
+    { n: "debug", c: "debug" },
+    { n: "verbose", c: "trace" }
+  ];
+  exports._originalConsoleMethods = {};
+  if (typeof console !== "undefined") {
+    const keys = [
+      "error",
+      "warn",
+      "info",
+      "debug",
+      "trace",
+      "log"
+    ];
+    for (const key of keys) {
+      if (typeof console[key] === "function") {
+        exports._originalConsoleMethods[key] = console[key];
+      }
+    }
+  }
+
+  class DiagConsoleLogger {
+    constructor() {
+      function _consoleFunc(funcName) {
+        return function(...args) {
+          let theFunc = exports._originalConsoleMethods[funcName];
+          if (typeof theFunc !== "function") {
+            theFunc = exports._originalConsoleMethods["log"];
+          }
+          if (typeof theFunc !== "function" && console) {
+            theFunc = console[funcName];
+            if (typeof theFunc !== "function") {
+              theFunc = console.log;
+            }
+          }
+          if (typeof theFunc === "function") {
+            return theFunc.apply(console, args);
+          }
+        };
+      }
+      for (let i = 0;i < consoleMap.length; i++) {
+        this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
+      }
+    }
+  }
+  exports.DiagConsoleLogger = DiagConsoleLogger;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js
+var require_NoopMeter = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createNoopMeter = exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = exports.NOOP_OBSERVABLE_GAUGE_METRIC = exports.NOOP_OBSERVABLE_COUNTER_METRIC = exports.NOOP_UP_DOWN_COUNTER_METRIC = exports.NOOP_HISTOGRAM_METRIC = exports.NOOP_GAUGE_METRIC = exports.NOOP_COUNTER_METRIC = exports.NOOP_METER = exports.NoopObservableUpDownCounterMetric = exports.NoopObservableGaugeMetric = exports.NoopObservableCounterMetric = exports.NoopObservableMetric = exports.NoopHistogramMetric = exports.NoopGaugeMetric = exports.NoopUpDownCounterMetric = exports.NoopCounterMetric = exports.NoopMetric = exports.NoopMeter = undefined;
+
+  class NoopMeter {
+    constructor() {}
+    createGauge(_name, _options) {
+      return exports.NOOP_GAUGE_METRIC;
+    }
+    createHistogram(_name, _options) {
+      return exports.NOOP_HISTOGRAM_METRIC;
+    }
+    createCounter(_name, _options) {
+      return exports.NOOP_COUNTER_METRIC;
+    }
+    createUpDownCounter(_name, _options) {
+      return exports.NOOP_UP_DOWN_COUNTER_METRIC;
+    }
+    createObservableGauge(_name, _options) {
+      return exports.NOOP_OBSERVABLE_GAUGE_METRIC;
+    }
+    createObservableCounter(_name, _options) {
+      return exports.NOOP_OBSERVABLE_COUNTER_METRIC;
+    }
+    createObservableUpDownCounter(_name, _options) {
+      return exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+    }
+    addBatchObservableCallback(_callback, _observables) {}
+    removeBatchObservableCallback(_callback) {}
+  }
+  exports.NoopMeter = NoopMeter;
+
+  class NoopMetric {
+  }
+  exports.NoopMetric = NoopMetric;
+
+  class NoopCounterMetric extends NoopMetric {
+    add(_value, _attributes) {}
+  }
+  exports.NoopCounterMetric = NoopCounterMetric;
+
+  class NoopUpDownCounterMetric extends NoopMetric {
+    add(_value, _attributes) {}
+  }
+  exports.NoopUpDownCounterMetric = NoopUpDownCounterMetric;
+
+  class NoopGaugeMetric extends NoopMetric {
+    record(_value, _attributes) {}
+  }
+  exports.NoopGaugeMetric = NoopGaugeMetric;
+
+  class NoopHistogramMetric extends NoopMetric {
+    record(_value, _attributes) {}
+  }
+  exports.NoopHistogramMetric = NoopHistogramMetric;
+
+  class NoopObservableMetric {
+    addCallback(_callback) {}
+    removeCallback(_callback) {}
+  }
+  exports.NoopObservableMetric = NoopObservableMetric;
+
+  class NoopObservableCounterMetric extends NoopObservableMetric {
+  }
+  exports.NoopObservableCounterMetric = NoopObservableCounterMetric;
+
+  class NoopObservableGaugeMetric extends NoopObservableMetric {
+  }
+  exports.NoopObservableGaugeMetric = NoopObservableGaugeMetric;
+
+  class NoopObservableUpDownCounterMetric extends NoopObservableMetric {
+  }
+  exports.NoopObservableUpDownCounterMetric = NoopObservableUpDownCounterMetric;
+  exports.NOOP_METER = new NoopMeter;
+  exports.NOOP_COUNTER_METRIC = new NoopCounterMetric;
+  exports.NOOP_GAUGE_METRIC = new NoopGaugeMetric;
+  exports.NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric;
+  exports.NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric;
+  exports.NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric;
+  exports.NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric;
+  exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric;
+  function createNoopMeter() {
+    return exports.NOOP_METER;
+  }
+  exports.createNoopMeter = createNoopMeter;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics/Metric.js
+var require_Metric = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ValueType = undefined;
+  var ValueType;
+  (function(ValueType2) {
+    ValueType2[ValueType2["INT"] = 0] = "INT";
+    ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
+  })(ValueType = exports.ValueType || (exports.ValueType = {}));
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js
+var require_TextMapPropagator = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.defaultTextMapSetter = exports.defaultTextMapGetter = undefined;
+  exports.defaultTextMapGetter = {
+    get(carrier, key) {
+      if (carrier == null) {
+        return;
+      }
+      return carrier[key];
+    },
+    keys(carrier) {
+      if (carrier == null) {
+        return [];
+      }
+      return Object.keys(carrier);
+    }
+  };
+  exports.defaultTextMapSetter = {
+    set(carrier, key, value) {
+      if (carrier == null) {
+        return;
+      }
+      carrier[key] = value;
+    }
+  };
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js
+var require_NoopContextManager = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.NoopContextManager = undefined;
+  var context_1 = require_context();
+
+  class NoopContextManager {
+    active() {
+      return context_1.ROOT_CONTEXT;
+    }
+    with(_context, fn, thisArg, ...args) {
+      return fn.call(thisArg, ...args);
+    }
+    bind(_context, target) {
+      return target;
+    }
+    enable() {
+      return this;
+    }
+    disable() {
+      return this;
+    }
+  }
+  exports.NoopContextManager = NoopContextManager;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/context.js
+var require_context2 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ContextAPI = undefined;
+  var NoopContextManager_1 = require_NoopContextManager();
+  var global_utils_1 = require_global_utils();
+  var diag_1 = require_diag();
+  var API_NAME = "context";
+  var NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager;
+
+  class ContextAPI {
+    constructor() {}
+    static getInstance() {
+      if (!this._instance) {
+        this._instance = new ContextAPI;
+      }
+      return this._instance;
+    }
+    setGlobalContextManager(contextManager) {
+      return (0, global_utils_1.registerGlobal)(API_NAME, contextManager, diag_1.DiagAPI.instance());
+    }
+    active() {
+      return this._getContextManager().active();
+    }
+    with(context, fn, thisArg, ...args) {
+      return this._getContextManager().with(context, fn, thisArg, ...args);
+    }
+    bind(context, target) {
+      return this._getContextManager().bind(context, target);
+    }
+    _getContextManager() {
+      return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_CONTEXT_MANAGER;
+    }
+    disable() {
+      this._getContextManager().disable();
+      (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+    }
+  }
+  exports.ContextAPI = ContextAPI;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/trace_flags.js
+var require_trace_flags = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.TraceFlags = undefined;
+  var TraceFlags;
+  (function(TraceFlags2) {
+    TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+    TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+  })(TraceFlags = exports.TraceFlags || (exports.TraceFlags = {}));
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js
+var require_invalid_span_constants = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = undefined;
+  var trace_flags_1 = require_trace_flags();
+  exports.INVALID_SPANID = "0000000000000000";
+  exports.INVALID_TRACEID = "00000000000000000000000000000000";
+  exports.INVALID_SPAN_CONTEXT = {
+    traceId: exports.INVALID_TRACEID,
+    spanId: exports.INVALID_SPANID,
+    traceFlags: trace_flags_1.TraceFlags.NONE
+  };
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js
+var require_NonRecordingSpan = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.NonRecordingSpan = undefined;
+  var invalid_span_constants_1 = require_invalid_span_constants();
+
+  class NonRecordingSpan {
+    constructor(spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) {
+      this._spanContext = spanContext;
+    }
+    spanContext() {
+      return this._spanContext;
+    }
+    setAttribute(_key, _value) {
+      return this;
+    }
+    setAttributes(_attributes) {
+      return this;
+    }
+    addEvent(_name, _attributes) {
+      return this;
+    }
+    addLink(_link) {
+      return this;
+    }
+    addLinks(_links) {
+      return this;
+    }
+    setStatus(_status) {
+      return this;
+    }
+    updateName(_name) {
+      return this;
+    }
+    end(_endTime) {}
+    isRecording() {
+      return false;
+    }
+    recordException(_exception, _time) {}
+  }
+  exports.NonRecordingSpan = NonRecordingSpan;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/context-utils.js
+var require_context_utils = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getSpanContext = exports.setSpanContext = exports.deleteSpan = exports.setSpan = exports.getActiveSpan = exports.getSpan = undefined;
+  var context_1 = require_context();
+  var NonRecordingSpan_1 = require_NonRecordingSpan();
+  var context_2 = require_context2();
+  var SPAN_KEY = (0, context_1.createContextKey)("OpenTelemetry Context Key SPAN");
+  function getSpan(context) {
+    return context.getValue(SPAN_KEY) || undefined;
+  }
+  exports.getSpan = getSpan;
+  function getActiveSpan() {
+    return getSpan(context_2.ContextAPI.getInstance().active());
+  }
+  exports.getActiveSpan = getActiveSpan;
+  function setSpan(context, span) {
+    return context.setValue(SPAN_KEY, span);
+  }
+  exports.setSpan = setSpan;
+  function deleteSpan(context) {
+    return context.deleteValue(SPAN_KEY);
+  }
+  exports.deleteSpan = deleteSpan;
+  function setSpanContext(context, spanContext) {
+    return setSpan(context, new NonRecordingSpan_1.NonRecordingSpan(spanContext));
+  }
+  exports.setSpanContext = setSpanContext;
+  function getSpanContext(context) {
+    var _a3;
+    return (_a3 = getSpan(context)) === null || _a3 === undefined ? undefined : _a3.spanContext();
+  }
+  exports.getSpanContext = getSpanContext;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js
+var require_spancontext_utils = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.wrapSpanContext = exports.isSpanContextValid = exports.isValidSpanId = exports.isValidTraceId = undefined;
+  var invalid_span_constants_1 = require_invalid_span_constants();
+  var NonRecordingSpan_1 = require_NonRecordingSpan();
+  var isHex = new Uint8Array([
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1
+  ]);
+  function isValidHex(id, length) {
+    if (typeof id !== "string" || id.length !== length)
+      return false;
+    let r = 0;
+    for (let i = 0;i < id.length; i += 4) {
+      r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
+    }
+    return r === length;
+  }
+  function isValidTraceId(traceId) {
+    return isValidHex(traceId, 32) && traceId !== invalid_span_constants_1.INVALID_TRACEID;
+  }
+  exports.isValidTraceId = isValidTraceId;
+  function isValidSpanId(spanId) {
+    return isValidHex(spanId, 16) && spanId !== invalid_span_constants_1.INVALID_SPANID;
+  }
+  exports.isValidSpanId = isValidSpanId;
+  function isSpanContextValid(spanContext) {
+    return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+  }
+  exports.isSpanContextValid = isSpanContextValid;
+  function wrapSpanContext(spanContext) {
+    return new NonRecordingSpan_1.NonRecordingSpan(spanContext);
+  }
+  exports.wrapSpanContext = wrapSpanContext;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js
+var require_NoopTracer = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.NoopTracer = undefined;
+  var context_1 = require_context2();
+  var context_utils_1 = require_context_utils();
+  var NonRecordingSpan_1 = require_NonRecordingSpan();
+  var spancontext_utils_1 = require_spancontext_utils();
+  var contextApi = context_1.ContextAPI.getInstance();
+
+  class NoopTracer {
+    startSpan(name, options, context = contextApi.active()) {
+      const root = Boolean(options === null || options === undefined ? undefined : options.root);
+      if (root) {
+        return new NonRecordingSpan_1.NonRecordingSpan;
+      }
+      const parentFromContext = context && (0, context_utils_1.getSpanContext)(context);
+      if (isSpanContext(parentFromContext) && (0, spancontext_utils_1.isSpanContextValid)(parentFromContext)) {
+        return new NonRecordingSpan_1.NonRecordingSpan(parentFromContext);
+      } else {
+        return new NonRecordingSpan_1.NonRecordingSpan;
+      }
+    }
+    startActiveSpan(name, arg2, arg3, arg4) {
+      let opts;
+      let ctx;
+      let fn;
+      if (arguments.length < 2) {
+        return;
+      } else if (arguments.length === 2) {
+        fn = arg2;
+      } else if (arguments.length === 3) {
+        opts = arg2;
+        fn = arg3;
+      } else {
+        opts = arg2;
+        ctx = arg3;
+        fn = arg4;
+      }
+      const parentContext = ctx !== null && ctx !== undefined ? ctx : contextApi.active();
+      const span = this.startSpan(name, opts, parentContext);
+      const contextWithSpanSet = (0, context_utils_1.setSpan)(parentContext, span);
+      return contextApi.with(contextWithSpanSet, fn, undefined, span);
+    }
+  }
+  exports.NoopTracer = NoopTracer;
+  function isSpanContext(spanContext) {
+    return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
+  }
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js
+var require_ProxyTracer = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ProxyTracer = undefined;
+  var NoopTracer_1 = require_NoopTracer();
+  var NOOP_TRACER = new NoopTracer_1.NoopTracer;
+
+  class ProxyTracer {
+    constructor(provider, name, version2, options) {
+      this._provider = provider;
+      this.name = name;
+      this.version = version2;
+      this.options = options;
+    }
+    startSpan(name, options, context) {
+      return this._getTracer().startSpan(name, options, context);
+    }
+    startActiveSpan(_name, _options, _context, _fn) {
+      const tracer = this._getTracer();
+      return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+    }
+    _getTracer() {
+      if (this._delegate) {
+        return this._delegate;
+      }
+      const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+      if (!tracer) {
+        return NOOP_TRACER;
+      }
+      this._delegate = tracer;
+      return this._delegate;
+    }
+  }
+  exports.ProxyTracer = ProxyTracer;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js
+var require_NoopTracerProvider = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.NoopTracerProvider = undefined;
+  var NoopTracer_1 = require_NoopTracer();
+
+  class NoopTracerProvider {
+    getTracer(_name, _version, _options) {
+      return new NoopTracer_1.NoopTracer;
+    }
+  }
+  exports.NoopTracerProvider = NoopTracerProvider;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js
+var require_ProxyTracerProvider = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ProxyTracerProvider = undefined;
+  var ProxyTracer_1 = require_ProxyTracer();
+  var NoopTracerProvider_1 = require_NoopTracerProvider();
+  var NOOP_TRACER_PROVIDER = new NoopTracerProvider_1.NoopTracerProvider;
+
+  class ProxyTracerProvider {
+    getTracer(name, version2, options) {
+      var _a3;
+      return (_a3 = this.getDelegateTracer(name, version2, options)) !== null && _a3 !== undefined ? _a3 : new ProxyTracer_1.ProxyTracer(this, name, version2, options);
+    }
+    getDelegate() {
+      var _a3;
+      return (_a3 = this._delegate) !== null && _a3 !== undefined ? _a3 : NOOP_TRACER_PROVIDER;
+    }
+    setDelegate(delegate) {
+      this._delegate = delegate;
+    }
+    getDelegateTracer(name, version2, options) {
+      var _a3;
+      return (_a3 = this._delegate) === null || _a3 === undefined ? undefined : _a3.getTracer(name, version2, options);
+    }
+  }
+  exports.ProxyTracerProvider = ProxyTracerProvider;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js
+var require_SamplingResult = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.SamplingDecision = undefined;
+  var SamplingDecision;
+  (function(SamplingDecision2) {
+    SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD";
+    SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD";
+    SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+  })(SamplingDecision = exports.SamplingDecision || (exports.SamplingDecision = {}));
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/span_kind.js
+var require_span_kind = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.SpanKind = undefined;
+  var SpanKind;
+  (function(SpanKind2) {
+    SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
+    SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
+    SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
+    SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
+    SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
+  })(SpanKind = exports.SpanKind || (exports.SpanKind = {}));
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/status.js
+var require_status = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.SpanStatusCode = undefined;
+  var SpanStatusCode;
+  (function(SpanStatusCode2) {
+    SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+    SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+    SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+  })(SpanStatusCode = exports.SpanStatusCode || (exports.SpanStatusCode = {}));
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js
+var require_tracestate_validators = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.validateValue = exports.validateKey = undefined;
+  var VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
+  var VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
+  var VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
+  var VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
+  var VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
+  var INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
+  function validateKey(key) {
+    return VALID_KEY_REGEX.test(key);
+  }
+  exports.validateKey = validateKey;
+  function validateValue(value) {
+    return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
+  }
+  exports.validateValue = validateValue;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js
+var require_tracestate_impl = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.TraceStateImpl = undefined;
+  var tracestate_validators_1 = require_tracestate_validators();
+  var MAX_TRACE_STATE_ITEMS = 32;
+  var MAX_TRACE_STATE_LEN = 512;
+  var LIST_MEMBERS_SEPARATOR = ",";
+  var LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
+
+  class TraceStateImpl {
+    constructor(rawTraceState) {
+      this._internalState = new Map;
+      if (rawTraceState)
+        this._parse(rawTraceState);
+    }
+    set(key, value) {
+      const traceState = this._clone();
+      if (traceState._internalState.has(key)) {
+        traceState._internalState.delete(key);
+      }
+      traceState._internalState.set(key, value);
+      return traceState;
+    }
+    unset(key) {
+      const traceState = this._clone();
+      traceState._internalState.delete(key);
+      return traceState;
+    }
+    get(key) {
+      return this._internalState.get(key);
+    }
+    serialize() {
+      return Array.from(this._internalState.keys()).reduceRight((agg, key) => {
+        agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
+        return agg;
+      }, []).join(LIST_MEMBERS_SEPARATOR);
+    }
+    _parse(rawTraceState) {
+      if (rawTraceState.length > MAX_TRACE_STATE_LEN)
+        return;
+      this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reduceRight((agg, part) => {
+        const listMember = part.trim();
+        const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
+        if (i !== -1) {
+          const key = listMember.slice(0, i);
+          const value = listMember.slice(i + 1, part.length);
+          if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value)) {
+            agg.set(key, value);
+          }
+        }
+        return agg;
+      }, new Map);
+      if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
+        this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
+      }
+    }
+    _keys() {
+      return Array.from(this._internalState.keys()).reverse();
+    }
+    _clone() {
+      const traceState = new TraceStateImpl;
+      traceState._internalState = new Map(this._internalState);
+      return traceState;
+    }
+  }
+  exports.TraceStateImpl = TraceStateImpl;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace/internal/utils.js
+var require_utils2 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createTraceState = undefined;
+  var tracestate_impl_1 = require_tracestate_impl();
+  function createTraceState(rawTraceState) {
+    return new tracestate_impl_1.TraceStateImpl(rawTraceState);
+  }
+  exports.createTraceState = createTraceState;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/context-api.js
+var require_context_api = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.context = undefined;
+  var context_1 = require_context2();
+  exports.context = context_1.ContextAPI.getInstance();
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/diag-api.js
+var require_diag_api = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.diag = undefined;
+  var diag_1 = require_diag();
+  exports.diag = diag_1.DiagAPI.instance();
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js
+var require_NoopMeterProvider = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.NOOP_METER_PROVIDER = exports.NoopMeterProvider = undefined;
+  var NoopMeter_1 = require_NoopMeter();
+
+  class NoopMeterProvider {
+    getMeter(_name, _version, _options) {
+      return NoopMeter_1.NOOP_METER;
+    }
+  }
+  exports.NoopMeterProvider = NoopMeterProvider;
+  exports.NOOP_METER_PROVIDER = new NoopMeterProvider;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/metrics.js
+var require_metrics = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.MetricsAPI = undefined;
+  var NoopMeterProvider_1 = require_NoopMeterProvider();
+  var global_utils_1 = require_global_utils();
+  var diag_1 = require_diag();
+  var API_NAME = "metrics";
+
+  class MetricsAPI {
+    constructor() {}
+    static getInstance() {
+      if (!this._instance) {
+        this._instance = new MetricsAPI;
+      }
+      return this._instance;
+    }
+    setGlobalMeterProvider(provider) {
+      return (0, global_utils_1.registerGlobal)(API_NAME, provider, diag_1.DiagAPI.instance());
+    }
+    getMeterProvider() {
+      return (0, global_utils_1.getGlobal)(API_NAME) || NoopMeterProvider_1.NOOP_METER_PROVIDER;
+    }
+    getMeter(name, version2, options) {
+      return this.getMeterProvider().getMeter(name, version2, options);
+    }
+    disable() {
+      (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+    }
+  }
+  exports.MetricsAPI = MetricsAPI;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/metrics-api.js
+var require_metrics_api = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.metrics = undefined;
+  var metrics_1 = require_metrics();
+  exports.metrics = metrics_1.MetricsAPI.getInstance();
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js
+var require_NoopTextMapPropagator = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.NoopTextMapPropagator = undefined;
+
+  class NoopTextMapPropagator {
+    inject(_context, _carrier) {}
+    extract(context, _carrier) {
+      return context;
+    }
+    fields() {
+      return [];
+    }
+  }
+  exports.NoopTextMapPropagator = NoopTextMapPropagator;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js
+var require_context_helpers = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.deleteBaggage = exports.setBaggage = exports.getActiveBaggage = exports.getBaggage = undefined;
+  var context_1 = require_context2();
+  var context_2 = require_context();
+  var BAGGAGE_KEY = (0, context_2.createContextKey)("OpenTelemetry Baggage Key");
+  function getBaggage(context) {
+    return context.getValue(BAGGAGE_KEY) || undefined;
+  }
+  exports.getBaggage = getBaggage;
+  function getActiveBaggage() {
+    return getBaggage(context_1.ContextAPI.getInstance().active());
+  }
+  exports.getActiveBaggage = getActiveBaggage;
+  function setBaggage(context, baggage) {
+    return context.setValue(BAGGAGE_KEY, baggage);
+  }
+  exports.setBaggage = setBaggage;
+  function deleteBaggage(context) {
+    return context.deleteValue(BAGGAGE_KEY);
+  }
+  exports.deleteBaggage = deleteBaggage;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/propagation.js
+var require_propagation = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.PropagationAPI = undefined;
+  var global_utils_1 = require_global_utils();
+  var NoopTextMapPropagator_1 = require_NoopTextMapPropagator();
+  var TextMapPropagator_1 = require_TextMapPropagator();
+  var context_helpers_1 = require_context_helpers();
+  var utils_1 = require_utils();
+  var diag_1 = require_diag();
+  var API_NAME = "propagation";
+  var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator;
+
+  class PropagationAPI {
+    constructor() {
+      this.createBaggage = utils_1.createBaggage;
+      this.getBaggage = context_helpers_1.getBaggage;
+      this.getActiveBaggage = context_helpers_1.getActiveBaggage;
+      this.setBaggage = context_helpers_1.setBaggage;
+      this.deleteBaggage = context_helpers_1.deleteBaggage;
+    }
+    static getInstance() {
+      if (!this._instance) {
+        this._instance = new PropagationAPI;
+      }
+      return this._instance;
+    }
+    setGlobalPropagator(propagator) {
+      return (0, global_utils_1.registerGlobal)(API_NAME, propagator, diag_1.DiagAPI.instance());
+    }
+    inject(context, carrier, setter = TextMapPropagator_1.defaultTextMapSetter) {
+      return this._getGlobalPropagator().inject(context, carrier, setter);
+    }
+    extract(context, carrier, getter = TextMapPropagator_1.defaultTextMapGetter) {
+      return this._getGlobalPropagator().extract(context, carrier, getter);
+    }
+    fields() {
+      return this._getGlobalPropagator().fields();
+    }
+    disable() {
+      (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+    }
+    _getGlobalPropagator() {
+      return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;
+    }
+  }
+  exports.PropagationAPI = PropagationAPI;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/propagation-api.js
+var require_propagation_api = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.propagation = undefined;
+  var propagation_1 = require_propagation();
+  exports.propagation = propagation_1.PropagationAPI.getInstance();
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/api/trace.js
+var require_trace = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.TraceAPI = undefined;
+  var global_utils_1 = require_global_utils();
+  var ProxyTracerProvider_1 = require_ProxyTracerProvider();
+  var spancontext_utils_1 = require_spancontext_utils();
+  var context_utils_1 = require_context_utils();
+  var diag_1 = require_diag();
+  var API_NAME = "trace";
+
+  class TraceAPI {
+    constructor() {
+      this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider;
+      this.wrapSpanContext = spancontext_utils_1.wrapSpanContext;
+      this.isSpanContextValid = spancontext_utils_1.isSpanContextValid;
+      this.deleteSpan = context_utils_1.deleteSpan;
+      this.getSpan = context_utils_1.getSpan;
+      this.getActiveSpan = context_utils_1.getActiveSpan;
+      this.getSpanContext = context_utils_1.getSpanContext;
+      this.setSpan = context_utils_1.setSpan;
+      this.setSpanContext = context_utils_1.setSpanContext;
+    }
+    static getInstance() {
+      if (!this._instance) {
+        this._instance = new TraceAPI;
+      }
+      return this._instance;
+    }
+    setGlobalTracerProvider(provider) {
+      const success3 = (0, global_utils_1.registerGlobal)(API_NAME, this._proxyTracerProvider, diag_1.DiagAPI.instance());
+      if (success3) {
+        this._proxyTracerProvider.setDelegate(provider);
+      }
+      return success3;
+    }
+    getTracerProvider() {
+      return (0, global_utils_1.getGlobal)(API_NAME) || this._proxyTracerProvider;
+    }
+    getTracer(name, version2) {
+      return this.getTracerProvider().getTracer(name, version2);
+    }
+    disable() {
+      (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance());
+      this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider;
+    }
+  }
+  exports.TraceAPI = TraceAPI;
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/trace-api.js
+var require_trace_api = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.trace = undefined;
+  var trace_1 = require_trace();
+  exports.trace = trace_1.TraceAPI.getInstance();
+});
+
+// ../../node_modules/@opentelemetry/api/build/src/index.js
+var require_src = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.trace = exports.propagation = exports.metrics = exports.diag = exports.context = exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = exports.isValidSpanId = exports.isValidTraceId = exports.isSpanContextValid = exports.createTraceState = exports.TraceFlags = exports.SpanStatusCode = exports.SpanKind = exports.SamplingDecision = exports.ProxyTracerProvider = exports.ProxyTracer = exports.defaultTextMapSetter = exports.defaultTextMapGetter = exports.ValueType = exports.createNoopMeter = exports.DiagLogLevel = exports.DiagConsoleLogger = exports.ROOT_CONTEXT = exports.createContextKey = exports.baggageEntryMetadataFromString = undefined;
+  var utils_1 = require_utils();
+  Object.defineProperty(exports, "baggageEntryMetadataFromString", { enumerable: true, get: function() {
+    return utils_1.baggageEntryMetadataFromString;
+  } });
+  var context_1 = require_context();
+  Object.defineProperty(exports, "createContextKey", { enumerable: true, get: function() {
+    return context_1.createContextKey;
+  } });
+  Object.defineProperty(exports, "ROOT_CONTEXT", { enumerable: true, get: function() {
+    return context_1.ROOT_CONTEXT;
+  } });
+  var consoleLogger_1 = require_consoleLogger();
+  Object.defineProperty(exports, "DiagConsoleLogger", { enumerable: true, get: function() {
+    return consoleLogger_1.DiagConsoleLogger;
+  } });
+  var types_1 = require_types();
+  Object.defineProperty(exports, "DiagLogLevel", { enumerable: true, get: function() {
+    return types_1.DiagLogLevel;
+  } });
+  var NoopMeter_1 = require_NoopMeter();
+  Object.defineProperty(exports, "createNoopMeter", { enumerable: true, get: function() {
+    return NoopMeter_1.createNoopMeter;
+  } });
+  var Metric_1 = require_Metric();
+  Object.defineProperty(exports, "ValueType", { enumerable: true, get: function() {
+    return Metric_1.ValueType;
+  } });
+  var TextMapPropagator_1 = require_TextMapPropagator();
+  Object.defineProperty(exports, "defaultTextMapGetter", { enumerable: true, get: function() {
+    return TextMapPropagator_1.defaultTextMapGetter;
+  } });
+  Object.defineProperty(exports, "defaultTextMapSetter", { enumerable: true, get: function() {
+    return TextMapPropagator_1.defaultTextMapSetter;
+  } });
+  var ProxyTracer_1 = require_ProxyTracer();
+  Object.defineProperty(exports, "ProxyTracer", { enumerable: true, get: function() {
+    return ProxyTracer_1.ProxyTracer;
+  } });
+  var ProxyTracerProvider_1 = require_ProxyTracerProvider();
+  Object.defineProperty(exports, "ProxyTracerProvider", { enumerable: true, get: function() {
+    return ProxyTracerProvider_1.ProxyTracerProvider;
+  } });
+  var SamplingResult_1 = require_SamplingResult();
+  Object.defineProperty(exports, "SamplingDecision", { enumerable: true, get: function() {
+    return SamplingResult_1.SamplingDecision;
+  } });
+  var span_kind_1 = require_span_kind();
+  Object.defineProperty(exports, "SpanKind", { enumerable: true, get: function() {
+    return span_kind_1.SpanKind;
+  } });
+  var status_1 = require_status();
+  Object.defineProperty(exports, "SpanStatusCode", { enumerable: true, get: function() {
+    return status_1.SpanStatusCode;
+  } });
+  var trace_flags_1 = require_trace_flags();
+  Object.defineProperty(exports, "TraceFlags", { enumerable: true, get: function() {
+    return trace_flags_1.TraceFlags;
+  } });
+  var utils_2 = require_utils2();
+  Object.defineProperty(exports, "createTraceState", { enumerable: true, get: function() {
+    return utils_2.createTraceState;
+  } });
+  var spancontext_utils_1 = require_spancontext_utils();
+  Object.defineProperty(exports, "isSpanContextValid", { enumerable: true, get: function() {
+    return spancontext_utils_1.isSpanContextValid;
+  } });
+  Object.defineProperty(exports, "isValidTraceId", { enumerable: true, get: function() {
+    return spancontext_utils_1.isValidTraceId;
+  } });
+  Object.defineProperty(exports, "isValidSpanId", { enumerable: true, get: function() {
+    return spancontext_utils_1.isValidSpanId;
+  } });
+  var invalid_span_constants_1 = require_invalid_span_constants();
+  Object.defineProperty(exports, "INVALID_SPANID", { enumerable: true, get: function() {
+    return invalid_span_constants_1.INVALID_SPANID;
+  } });
+  Object.defineProperty(exports, "INVALID_TRACEID", { enumerable: true, get: function() {
+    return invalid_span_constants_1.INVALID_TRACEID;
+  } });
+  Object.defineProperty(exports, "INVALID_SPAN_CONTEXT", { enumerable: true, get: function() {
+    return invalid_span_constants_1.INVALID_SPAN_CONTEXT;
+  } });
+  var context_api_1 = require_context_api();
+  Object.defineProperty(exports, "context", { enumerable: true, get: function() {
+    return context_api_1.context;
+  } });
+  var diag_api_1 = require_diag_api();
+  Object.defineProperty(exports, "diag", { enumerable: true, get: function() {
+    return diag_api_1.diag;
+  } });
+  var metrics_api_1 = require_metrics_api();
+  Object.defineProperty(exports, "metrics", { enumerable: true, get: function() {
+    return metrics_api_1.metrics;
+  } });
+  var propagation_api_1 = require_propagation_api();
+  Object.defineProperty(exports, "propagation", { enumerable: true, get: function() {
+    return propagation_api_1.propagation;
+  } });
+  var trace_api_1 = require_trace_api();
+  Object.defineProperty(exports, "trace", { enumerable: true, get: function() {
+    return trace_api_1.trace;
+  } });
+  exports.default = {
+    context: context_api_1.context,
+    diag: diag_api_1.diag,
+    metrics: metrics_api_1.metrics,
+    propagation: propagation_api_1.propagation,
+    trace: trace_api_1.trace
+  };
+});
+
+// ../types/src/processor/processor.ts
+var import_api, noopTracingContext, ProcessorPortSchema, ProcessorDefinitionSchema, ProcessorExecutionContextSchema, TraceStatus;
+var init_processor = __esm(() => {
+  init_zod();
+  init_common();
+  import_api = __toESM(require_src(), 1);
+  noopTracingContext = {
+    traceId: "",
+    getActiveSpan() {
+      return;
+    },
+    async withSpan(_name, _options, fn) {
+      const noopSpan = {
+        spanContext: () => ({
+          traceId: "",
+          spanId: "",
+          traceFlags: 0
+        }),
+        setAttribute: () => noopSpan,
+        setAttributes: () => noopSpan,
+        addEvent: () => noopSpan,
+        addLink: () => noopSpan,
+        addLinks: () => noopSpan,
+        setStatus: () => noopSpan,
+        updateName: () => noopSpan,
+        end: () => {},
+        isRecording: () => false,
+        recordException: () => {}
+      };
+      return fn(noopSpan);
+    }
+  };
+  ProcessorPortSchema = exports_external.object({
+    name: exports_external.string(),
+    schema: JsonSchemaSchema,
+    required: exports_external.boolean().default(true)
+  });
+  ProcessorDefinitionSchema = exports_external.object({
+    id: exports_external.string(),
+    name: exports_external.string(),
+    description: exports_external.string().optional(),
+    inputSchema: JsonSchemaSchema,
+    outputSchema: JsonSchemaSchema,
+    configSchema: JsonSchemaSchema.optional(),
+    inputPorts: exports_external.array(ProcessorPortSchema).optional(),
+    outputPorts: exports_external.array(ProcessorPortSchema).optional(),
+    isBuiltin: exports_external.boolean().default(true),
+    pluginName: exports_external.string().optional()
+  });
+  ProcessorExecutionContextSchema = exports_external.object({
+    jobId: exports_external.string(),
+    stepId: exports_external.string(),
+    tenantId: exports_external.string(),
+    automationId: exports_external.string().optional(),
+    workflowId: exports_external.string(),
+    workerId: exports_external.string().optional()
+  });
+  ((TraceStatus2) => {
+    TraceStatus2["PENDING"] = "pending";
+    TraceStatus2["RUNNING"] = "running";
+    TraceStatus2["COMPLETED"] = "completed";
+    TraceStatus2["FAILED"] = "failed";
+  })(TraceStatus ||= {});
+});
+
+// ../types/src/processor/execution.ts
+function asTuple(values) {
+  return values;
+}
+var WorkflowExecutionStatusValue, WorkflowExecutionStatusSchema, StepExecutionStatusValue, StepExecutionStatusSchema, TriggerTypeValue, TriggerTypeSchema, ExecutionTypeValue, ExecutionTypeSchema, WORKFLOW_EXECUTION_STATUSES, STEP_EXECUTION_STATUSES, TRIGGER_TYPES, EXECUTION_TYPES;
+var init_execution = __esm(() => {
+  init_zod();
+  WorkflowExecutionStatusValue = {
+    CREATED: "created",
+    PENDING: "pending",
+    RUNNING: "running",
+    WAITING: "waiting",
+    COMPLETED: "completed",
+    FAILED: "failed",
+    CANCELLED: "cancelled"
+  };
+  WorkflowExecutionStatusSchema = exports_external.enum([
+    WorkflowExecutionStatusValue.CREATED,
+    WorkflowExecutionStatusValue.PENDING,
+    WorkflowExecutionStatusValue.RUNNING,
+    WorkflowExecutionStatusValue.WAITING,
+    WorkflowExecutionStatusValue.COMPLETED,
+    WorkflowExecutionStatusValue.FAILED,
+    WorkflowExecutionStatusValue.CANCELLED
+  ]);
+  StepExecutionStatusValue = {
+    PENDING: "pending",
+    RUNNING: "running",
+    SUCCESS: "success",
+    FAILURE: "failure",
+    WAITING: "waiting",
+    SKIPPED: "skipped"
+  };
+  StepExecutionStatusSchema = exports_external.enum([
+    StepExecutionStatusValue.PENDING,
+    StepExecutionStatusValue.RUNNING,
+    StepExecutionStatusValue.SUCCESS,
+    StepExecutionStatusValue.FAILURE,
+    StepExecutionStatusValue.WAITING,
+    StepExecutionStatusValue.SKIPPED
+  ]);
+  TriggerTypeValue = {
+    MANUAL: "manual",
+    API: "api",
+    WEBHOOK: "webhook",
+    SCHEDULE: "schedule",
+    EMAIL: "email",
+    EVAL: "eval",
+    CLI: "cli"
+  };
+  TriggerTypeSchema = exports_external.enum([
+    TriggerTypeValue.MANUAL,
+    TriggerTypeValue.API,
+    TriggerTypeValue.WEBHOOK,
+    TriggerTypeValue.SCHEDULE,
+    TriggerTypeValue.EMAIL,
+    TriggerTypeValue.EVAL,
+    TriggerTypeValue.CLI
+  ]);
+  ExecutionTypeValue = {
+    PROD: "prod",
+    EVAL: "eval",
+    PLAYGROUND: "playground"
+  };
+  ExecutionTypeSchema = exports_external.enum([
+    ExecutionTypeValue.PROD,
+    ExecutionTypeValue.EVAL,
+    ExecutionTypeValue.PLAYGROUND
+  ]);
+  WORKFLOW_EXECUTION_STATUSES = asTuple(WorkflowExecutionStatusSchema.options);
+  STEP_EXECUTION_STATUSES = asTuple(StepExecutionStatusSchema.options);
+  TRIGGER_TYPES = TriggerTypeSchema.options;
+  EXECUTION_TYPES = ExecutionTypeSchema.options;
+});
+
+// ../types/src/processor/configs/classify.ts
+var ClassifyInputSchema, ClassifyLabelSchema, ClassifyConfigSchema, ClassifyOutputSchema;
+var init_classify = __esm(() => {
+  init_zod();
+  ClassifyInputSchema = exports_external.object({
+    content: exports_external.string().optional().describe("Text content to classify"),
+    text: exports_external.string().optional().describe("Text content (alternative to content)")
+  }).refine((data) => !!(data.content || data.text), {
+    message: "Either content or text must be provided"
+  });
+  ClassifyLabelSchema = exports_external.object({
+    name: exports_external.string().min(1).describe("Label value returned in output.label"),
+    description: exports_external.string().optional().describe("What documents fall into this label. Fed to the LLM as guidance.")
+  });
+  ClassifyConfigSchema = exports_external.object({
+    labels: exports_external.array(ClassifyLabelSchema).min(2).describe("Allowed labels. The LLM is constrained to pick exactly one of these names."),
+    prompt: exports_external.string().optional().describe("Optional classification instructions appended to the system prompt. Use to clarify edge cases or emphasize evidence the model should weigh."),
+    provider: exports_external.string().optional().describe('Provider ID (e.g., "openai-gpt4o-mini")'),
+    model: exports_external.string().optional().describe("Model override"),
+    maxInputTokens: exports_external.number().int().optional().describe("Max input tokens. Truncates input text when exceeded. Omit for no limit.")
+  });
+  ClassifyOutputSchema = exports_external.object({
+    label: exports_external.string().describe("The selected label name"),
+    confidence: exports_external.enum(["low", "medium", "high"]).describe("Coarse confidence in the classification"),
+    reason: exports_external.string().describe("Short justification for the chosen label")
+  });
+});
+
+// ../types/src/parser/parser.ts
+function resolveEffectiveMimeType(filename, declaredMimeType) {
+  const ext = filename.split(".").pop()?.toLowerCase();
+  if (!ext)
+    return declaredMimeType;
+  const extensionMime = EXTENSION_TO_MIME[ext];
+  return extensionMime ?? declaredMimeType;
+}
+function mimeTypeForExtension(extension) {
+  return EXTENSION_TO_MIME[extension.replace(/^\./, "").toLowerCase()];
+}
+function extensionForMimeType(mimeType) {
+  const base = mimeType.split(";")[0]?.trim().toLowerCase();
+  return base ? MIME_TO_EXTENSION[base] : undefined;
+}
+function getParserCategory(mimeType) {
+  const normalized = mimeType.toLowerCase().trim();
+  if (ParserCategory.PLAINTEXT.includes(normalized)) {
+    return "plaintext";
+  }
+  if (ParserCategory.OFFICE.includes(normalized)) {
+    return "office";
+  }
+  if (ParserCategory.DOCUMENT.includes(normalized)) {
+    return "document";
+  }
+  return null;
+}
+function requiresSpecializedParser(mimeType) {
+  return getParserCategory(mimeType) === "document";
+}
+function getAllSupportedMimeTypes() {
+  return [...ParserCategory.PLAINTEXT, ...ParserCategory.OFFICE, ...ParserCategory.DOCUMENT];
+}
+function getSupportedFormatsLabel() {
+  const allMimes = getAllSupportedMimeTypes();
+  const labels = [...new Set(allMimes.map((m) => MIME_TO_LABEL[m] ?? m))];
+  return labels.join(", ");
+}
+var OFFICE_MIME_TYPES, ParserCategory, ParserTypeSchema, DocumentMetadataSchema, ParseUsageSchema, CoordinateUnitSchema, PointSchema, BoundingRegionSchema, PositionedTextSchema, TableCellSchema, ExtractedTableSchema, LayoutElementTypeSchema, LayoutElementSchema, PageResultSchema, ParseResultSchema, ParseOptionsSchema, ParserInputSchema, EXTENSION_TO_MIME, MIME_TO_EXTENSION, MIME_TO_LABEL;
+var init_parser = __esm(() => {
+  init_zod();
+  OFFICE_MIME_TYPES = [
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/msword",
+    "application/vnd.oasis.opendocument.text",
+    "application/rtf",
+    "text/rtf",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.ms-excel",
+    "application/vnd.ms-excel.sheet.macroenabled.12",
+    "application/vnd.ms-excel.sheet.binary.macroenabled.12",
+    "application/vnd.oasis.opendocument.spreadsheet",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
+    "application/vnd.ms-powerpoint.presentation.macroenabled.12",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.oasis.opendocument.presentation",
+    "message/rfc822",
+    "application/vnd.ms-outlook",
+    "application/epub+zip"
+  ];
+  ParserCategory = {
+    PLAINTEXT: [
+      "text/plain",
+      "text/markdown",
+      "text/csv",
+      "text/tab-separated-values",
+      "text/html",
+      "text/xml",
+      "application/json",
+      "application/x-yaml",
+      "application/toml",
+      "image/svg+xml",
+      "text/x-rst",
+      "text/x-org",
+      "application/x-latex",
+      "application/x-ipynb+json",
+      "application/x-bibtex",
+      "application/docbook+xml",
+      "application/x-fictionbook+xml"
+    ],
+    OFFICE: [...OFFICE_MIME_TYPES],
+    DOCUMENT: [
+      "application/pdf",
+      "image/png",
+      "image/jpeg",
+      "image/webp",
+      "image/tiff",
+      "image/gif",
+      "image/bmp"
+    ]
+  };
+  ParserTypeSchema = exports_external.enum([
+    "plaintext",
+    "office",
+    "llm-vision",
+    "ocr"
+  ]);
+  DocumentMetadataSchema = exports_external.object({
+    filename: exports_external.string(),
+    mimeType: exports_external.string(),
+    size: exports_external.number().describe("File size in bytes"),
+    storageRef: exports_external.string().optional().describe("Storage reference for the original file")
+  });
+  ParseUsageSchema = exports_external.object({
+    pageCount: exports_external.number(),
+    processingTimeMs: exports_external.number().optional()
+  });
+  CoordinateUnitSchema = exports_external.enum(["pixel", "inch", "point", "normalized"]);
+  PointSchema = exports_external.object({
+    x: exports_external.number(),
+    y: exports_external.number()
+  });
+  BoundingRegionSchema = exports_external.object({
+    polygon: exports_external.array(PointSchema).min(3),
+    unit: CoordinateUnitSchema,
+    pageIndex: exports_external.number()
+  });
+  PositionedTextSchema = exports_external.object({
+    text: exports_external.string(),
+    confidence: exports_external.number().min(0).max(1).optional(),
+    boundingRegion: BoundingRegionSchema.optional()
+  });
+  TableCellSchema = exports_external.object({
+    content: exports_external.string(),
+    rowIndex: exports_external.number(),
+    columnIndex: exports_external.number(),
+    rowSpan: exports_external.number().default(1),
+    columnSpan: exports_external.number().default(1),
+    boundingRegion: BoundingRegionSchema.optional()
+  });
+  ExtractedTableSchema = exports_external.object({
+    cells: exports_external.array(TableCellSchema),
+    rowCount: exports_external.number(),
+    columnCount: exports_external.number(),
+    boundingRegion: BoundingRegionSchema.optional()
+  });
+  LayoutElementTypeSchema = exports_external.enum([
+    "paragraph",
+    "title",
+    "sectionHeading",
+    "pageHeader",
+    "pageFooter",
+    "pageNumber",
+    "footnote",
+    "table",
+    "figure",
+    "formulaBlock"
+  ]);
+  LayoutElementSchema = exports_external.object({
+    type: LayoutElementTypeSchema,
+    content: exports_external.string(),
+    table: ExtractedTableSchema.optional(),
+    caption: exports_external.string().optional(),
+    figureId: exports_external.string().optional(),
+    boundingRegion: BoundingRegionSchema.optional()
+  });
+  PageResultSchema = exports_external.object({
+    pageIndex: exports_external.number().describe("0-based page index"),
+    text: exports_external.string().describe("Extracted text content (markdown/HTML)"),
+    pageName: exports_external.string().optional().describe("Page/sheet name (e.g., Excel sheet name)"),
+    layoutElements: exports_external.array(LayoutElementSchema).optional().describe("Semantic layout elements in reading order"),
+    words: exports_external.array(PositionedTextSchema).optional().describe("Word-level positions"),
+    lines: exports_external.array(PositionedTextSchema).optional().describe("Line-level positions"),
+    tables: exports_external.array(ExtractedTableSchema).optional().describe("Extracted tables"),
+    width: exports_external.number().optional().describe("Page width"),
+    height: exports_external.number().optional().describe("Page height"),
+    unit: CoordinateUnitSchema.optional().describe("Unit for width/height and bounding regions"),
+    confidence: exports_external.number().min(0).max(1).optional().describe("Overall page confidence")
+  });
+  ParseResultSchema = exports_external.object({
+    document: DocumentMetadataSchema,
+    usage: ParseUsageSchema,
+    pages: exports_external.array(PageResultSchema),
+    text: exports_external.string().describe("Combined text from all pages"),
+    parserType: ParserTypeSchema,
+    parserVersion: exports_external.string().optional(),
+    model: exports_external.string().optional().describe("Model used (for LLM/OCR parsers)"),
+    rawResponse: exports_external.unknown().optional()
+  });
+  ParseOptionsSchema = exports_external.object({
+    outputFormat: exports_external.enum(["plain", "markdown", "djot", "html"]).default("markdown"),
+    ocrProvider: exports_external.string().optional().describe("OCR provider ID to use"),
+    includeWordPositions: exports_external.boolean().default(false),
+    includeLinePositions: exports_external.boolean().default(false),
+    extractTables: exports_external.boolean().default(true),
+    provider: exports_external.string().optional().describe("LLM provider ID to use"),
+    model: exports_external.string().optional(),
+    maxConcurrency: exports_external.number().min(1).max(30).default(3),
+    pagesPerBatch: exports_external.number().min(1).max(20).default(5),
+    pdfRenderScale: exports_external.number().min(1).max(4).default(1).describe("Scale factor used when rendering PDF pages for VLM parsing"),
+    imageQuality: exports_external.number().int().min(1).max(100).default(85).describe("JPEG quality used for PDF page images sent to VLM parsing"),
+    prompt: exports_external.string().optional().describe("Custom prompt for LLM-based parsing"),
+    languages: exports_external.array(exports_external.string()).optional().describe("OCR language hints"),
+    tenantId: exports_external.string().optional()
+  });
+  ParserInputSchema = exports_external.object({
+    data: exports_external.instanceof(Buffer).or(exports_external.instanceof(Uint8Array)),
+    filename: exports_external.string(),
+    mimeType: exports_external.string(),
+    options: ParseOptionsSchema.optional()
+  });
+  EXTENSION_TO_MIME = {
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    doc: "application/msword",
+    odt: "application/vnd.oasis.opendocument.text",
+    rtf: "application/rtf",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    xls: "application/vnd.ms-excel",
+    xlsm: "application/vnd.ms-excel.sheet.macroenabled.12",
+    xlsb: "application/vnd.ms-excel.sheet.binary.macroenabled.12",
+    ods: "application/vnd.oasis.opendocument.spreadsheet",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ppsx: "application/vnd.openxmlformats-officedocument.presentationml.slideshow",
+    pptm: "application/vnd.ms-powerpoint.presentation.macroenabled.12",
+    ppt: "application/vnd.ms-powerpoint",
+    odp: "application/vnd.oasis.opendocument.presentation",
+    eml: "message/rfc822",
+    msg: "application/vnd.ms-outlook",
+    epub: "application/epub+zip",
+    pdf: "application/pdf",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    tiff: "image/tiff",
+    tif: "image/tiff",
+    gif: "image/gif",
+    bmp: "image/bmp",
+    svg: "image/svg+xml",
+    txt: "text/plain",
+    md: "text/markdown",
+    markdown: "text/markdown",
+    csv: "text/csv",
+    tsv: "text/tab-separated-values",
+    html: "text/html",
+    htm: "text/html",
+    xml: "text/xml",
+    json: "application/json",
+    yaml: "application/x-yaml",
+    yml: "application/x-yaml",
+    toml: "application/toml",
+    rst: "text/x-rst",
+    org: "text/x-org",
+    tex: "application/x-latex",
+    latex: "application/x-latex",
+    ipynb: "application/x-ipynb+json",
+    bib: "application/x-bibtex",
+    dbk: "application/docbook+xml",
+    docbook: "application/docbook+xml",
+    fb2: "application/x-fictionbook+xml"
+  };
+  MIME_TO_EXTENSION = Object.entries(EXTENSION_TO_MIME).reduce((acc, [ext, mime]) => {
+    if (!(mime in acc))
+      acc[mime] = ext;
+    return acc;
+  }, {});
+  MIME_TO_LABEL = {
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "DOCX",
+    "application/msword": "DOC",
+    "application/vnd.oasis.opendocument.text": "ODT",
+    "application/rtf": "RTF",
+    "text/rtf": "RTF",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "XLSX",
+    "application/vnd.ms-excel": "XLS",
+    "application/vnd.ms-excel.sheet.macroenabled.12": "XLSM",
+    "application/vnd.ms-excel.sheet.binary.macroenabled.12": "XLSB",
+    "application/vnd.oasis.opendocument.spreadsheet": "ODS",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": "PPTX",
+    "application/vnd.openxmlformats-officedocument.presentationml.slideshow": "PPSX",
+    "application/vnd.ms-powerpoint.presentation.macroenabled.12": "PPTM",
+    "application/vnd.ms-powerpoint": "PPT",
+    "application/vnd.oasis.opendocument.presentation": "ODP",
+    "message/rfc822": "EML",
+    "application/vnd.ms-outlook": "MSG",
+    "application/epub+zip": "EPUB",
+    "application/pdf": "PDF",
+    "image/png": "PNG",
+    "image/jpeg": "JPEG",
+    "image/webp": "WebP",
+    "image/tiff": "TIFF",
+    "image/gif": "GIF",
+    "image/bmp": "BMP",
+    "image/svg+xml": "SVG",
+    "text/plain": "TXT",
+    "text/markdown": "Markdown",
+    "text/csv": "CSV",
+    "text/tab-separated-values": "TSV",
+    "text/html": "HTML",
+    "text/xml": "XML",
+    "application/json": "JSON",
+    "application/x-yaml": "YAML",
+    "application/toml": "TOML",
+    "text/x-rst": "RST",
+    "text/x-org": "Org",
+    "application/x-latex": "LaTeX",
+    "application/x-ipynb+json": "Jupyter",
+    "application/x-bibtex": "BibTeX",
+    "application/docbook+xml": "DocBook",
+    "application/x-fictionbook+xml": "FB2"
+  };
+});
+
+// ../types/src/processor/configs/document-parser.ts
+var DocumentParserInputSchema, DocumentParserOutputSchema, DocumentParserConfigSchema;
+var init_document_parser = __esm(() => {
+  init_zod();
+  init_runtime_file_ref();
+  init_parser();
+  DocumentParserInputSchema = ResolvedProcessorFileSchema;
+  DocumentParserOutputSchema = ParseResultSchema;
+  DocumentParserConfigSchema = exports_external.object({
+    ocrModel: exports_external.string().optional().describe("OCR provider ID for PDF/image parsing"),
+    llmModel: exports_external.string().optional().describe("LLM provider ID for vision-based parsing"),
+    maxConcurrency: exports_external.number().min(1).max(10).default(3).describe("Max concurrent VLM batch requests"),
+    pagesPerBatch: exports_external.number().min(1).max(20).default(5).describe("Number of page images per VLM request"),
+    pdfRenderScale: exports_external.number().min(1).max(4).default(1).optional().describe("Scale factor used when rendering PDF pages for VLM parsing"),
+    imageQuality: exports_external.number().int().min(1).max(100).default(85).optional().describe("JPEG quality used for PDF page images sent to VLM parsing"),
+    prompt: exports_external.string().optional().describe("Custom extraction prompt"),
+    nativeText: exports_external.boolean().default(false).optional().describe("Use native text extraction for PDFs with embedded text (no OCR/VLM)"),
+    languages: exports_external.array(exports_external.string()).optional().describe('OCR language hints (e.g., ["en", "de"])'),
+    outputFormat: exports_external.enum(["plain", "markdown", "djot", "html"]).default("markdown").optional().describe("Format for extracted text. Only the native (Kreuzberg) parser uses this — OCR/VLM always emit markdown.")
+  }).prefault({});
+});
+
+// ../types/src/processor/configs/extract.ts
+var ExtractInputSchema, ExtractOutputSchema, ExtractConfigSchema;
+var init_extract = __esm(() => {
+  init_zod();
+  ExtractInputSchema = exports_external.object({
+    content: exports_external.string().optional().describe("Text content to extract from"),
+    text: exports_external.string().optional().describe("Text content (alternative to content, e.g., from document parser)"),
+    contentType: exports_external.enum(["text", "image"]).default("text"),
+    imageData: exports_external.string().optional(),
+    imageMimeType: exports_external.string().optional()
+  }).refine((data) => data.content || data.text, {
+    message: "Either content or text must be provided"
+  });
+  ExtractOutputSchema = exports_external.record(exports_external.string(), exports_external.unknown()).describe("Extracted structured data matching the provided schema");
+  ExtractConfigSchema = exports_external.object({
+    schema: exports_external.record(exports_external.string(), exports_external.unknown()).describe("JSON Schema defining the structure to extract"),
+    prompt: exports_external.string().optional().describe("Custom prompt template for extraction"),
+    provider: exports_external.string().optional().describe('Provider ID to use (e.g., "openai-gpt4o", "anthropic-claude")'),
+    model: exports_external.string().optional().describe("Model to use (overrides provider default)"),
+    maxInputTokens: exports_external.number().int().optional().describe("Max input tokens. Truncates input text and logs a warning when exceeded. Omit for no limit."),
+    grounded: exports_external.boolean().optional().describe("When true, run a grounding pass over the schema fields and attach per-field source spans + confidence under a `_grounding` key, flagging ungrounded/fuzzy fields for human review. Grounding always calls OpenAI directly (independent of the extract provider) and requires OPENAI_API_KEY."),
+    groundingModel: exports_external.string().optional().describe("Provider/model for the grounding pass. Defaults to the workspace default LLM; grounding runs against OpenAI, so pick an OpenAI-compatible model."),
+    groundingExamples: exports_external.array(exports_external.object({
+      text: exports_external.string(),
+      extractions: exports_external.array(exports_external.object({ field: exports_external.string(), text: exports_external.string() }))
+    })).optional().describe("Few-shot examples for grounding (verbatim source text per field). Optional."),
+    reviewOn: exports_external.enum(["medium_or_low", "low_only"]).optional().describe("Which grounding confidences flag a field for review. Default: medium_or_low.")
+  });
+});
+
+// ../types/src/processor/configs/merge.ts
+var MergeConfigSchema, MergeInputSchema, MergeOutputSchema;
+var init_merge = __esm(() => {
+  init_zod();
+  MergeConfigSchema = exports_external.object({
+    preservePortNames: exports_external.boolean().default(true),
+    outputKey: exports_external.string().optional()
+  });
+  MergeInputSchema = exports_external.record(exports_external.string(), exports_external.unknown());
+  MergeOutputSchema = exports_external.object({
+    items: exports_external.array(exports_external.unknown()),
+    count: exports_external.number(),
+    merged: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+  });
+});
+
+// ../types/src/processor/configs/pdf-embedder.ts
+var PdfEmbedderInputSchema, PdfEmbedderOutputSchema, PdfEmbedderConfigSchema;
+var init_pdf_embedder = __esm(() => {
+  init_zod();
+  init_runtime_file_ref();
+  init_parser();
+  PdfEmbedderInputSchema = exports_external.object({
+    file: ResolvedProcessorFileSchema.describe("Resolved source file handle"),
+    parseResult: exports_external.object({
+      pages: exports_external.array(PageResultSchema),
+      text: exports_external.string().optional()
+    }).describe("Parse result from ai.parse step (must include word positions)")
+  });
+  PdfEmbedderOutputSchema = exports_external.object({
+    fileId: exports_external.string().describe("File ID from files table"),
+    pageCount: exports_external.number().describe("Number of pages in the output PDF"),
+    wordCount: exports_external.number().describe("Number of words embedded"),
+    text: exports_external.string().describe("Extracted text (from parse step)")
+  });
+  PdfEmbedderConfigSchema = exports_external.object({
+    outputFilename: exports_external.string().optional().describe('Output filename - supports LiquidJS syntax e.g. "{{filename}}-searchable.pdf"'),
+    confidenceThreshold: exports_external.number().min(0).max(1).default(0.7).describe("Minimum OCR confidence (0-1) to include a word. Lower = more words but more errors")
+  }).prefault({});
+});
+
+// ../types/src/processor/configs/segment.ts
+var SegmentInputSchema, SEGMENT_UNKNOWN_TYPE = "unknown", SegmentConfigSchema, ConfidenceLevelSchema, SegmentSummarySchema, SegmentOutputSchema;
+var init_segment = __esm(() => {
+  init_zod();
+  SegmentInputSchema = exports_external.object({
+    pages: exports_external.array(exports_external.object({
+      pageIndex: exports_external.number().describe("0-based page index"),
+      text: exports_external.string().describe("Extracted text for this page"),
+      pageName: exports_external.string().optional()
+    })).min(1).describe("Per-page parsed content from a document parser")
+  }).passthrough().describe("Document-parser-shaped input. Pass {{ steps.parse.output }} directly — extra fields like text/metadata are ignored.");
+  SegmentConfigSchema = exports_external.object({
+    documentTypes: exports_external.array(exports_external.object({
+      name: exports_external.string().min(1).describe('Type label returned in documents[].type (e.g. "timesheet", "deal-memo").'),
+      description: exports_external.string().optional().describe("What this document type looks like — headings, layout, vocabulary, and the visual cues that mark its FIRST page. Fed to the LLM as guidance for both boundary detection and typing.")
+    })).min(1).describe('The document-type taxonomy. The LLM tags each detected document with one of these names, or the reserved "unknown" type when none fit.'),
+    rules: exports_external.string().optional().describe("Optional natural-language rules appended to the system prompt"),
+    provider: exports_external.string().optional().describe('Provider ID from eigenpal.config.yaml (e.g. "openai-gpt5.4-mini"). Falls back to the tenant default LLM provider when omitted.'),
+    windowTokenBudget: exports_external.number().int().positive().optional().describe("Per-window token ceiling. Defaults to env SPLIT_WINDOW_TOKEN_BUDGET or 20000. Smaller windows give sharper boundaries on dense batches; larger windows when documents routinely exceed the per-window page count.")
+  });
+  ConfidenceLevelSchema = exports_external.enum(["low", "medium", "high"]).describe("LLM confidence as a coarse enum. Numeric (0..1) confidences cluster at 0.85–0.95 and gradations are noise; low/medium/high is reliable.");
+  SegmentSummarySchema = exports_external.object({
+    total: exports_external.number().int().describe("Total documents discovered in the batch."),
+    labelled: exports_external.number().int().describe('Documents assigned a known taxonomy type (type !== "unknown").'),
+    unlabelled: exports_external.number().int().describe('Documents the segmenter could not label (type === "unknown") — escalate to a human.'),
+    lowConfidence: exports_external.number().int().describe('Documents whose boundary/type confidence is "low" — also worth human review.'),
+    byType: exports_external.record(exports_external.string(), exports_external.number().int()).describe('Per-type document counts, keyed by type name (includes "unknown").'),
+    needsReview: exports_external.array(exports_external.object({
+      index: exports_external.number().int(),
+      type: exports_external.string(),
+      page_range: exports_external.tuple([exports_external.number().int(), exports_external.number().int()]),
+      reason: exports_external.enum(["unlabelled", "low_confidence"]).describe("Why this document should be escalated to a human operator."),
+      notes: exports_external.string()
+    })).describe("The exact documents to escalate to a human operator, with the reason for each.")
+  });
+  SegmentOutputSchema = exports_external.object({
+    summary: SegmentSummarySchema.describe("Batch-level escalation summary: labelled vs unlabelled counts and the documents needing human review."),
+    documents: exports_external.array(exports_external.object({
+      index: exports_external.number().int().describe("0-based position of this document in the batch, in page order."),
+      type: exports_external.string().describe('Chosen type name from the taxonomy, or "unknown" when none fit.'),
+      page_range: exports_external.tuple([exports_external.number().int(), exports_external.number().int()]).describe("Inclusive [startPage, endPage], 0-based, matching input pageIndex."),
+      confidence: ConfidenceLevelSchema.describe("LLM confidence at the document boundary + type: low | medium | high."),
+      notes: exports_external.string().describe("Short prose citing what marked this page as a new document."),
+      evidence: exports_external.object({
+        start_heading_text: exports_external.string().nullable().optional().describe("Verbatim heading/title text the LLM cited as the document start"),
+        start_page: exports_external.number().int().nullable().optional().describe("Page where the start appears")
+      }).optional().describe("Structured start evidence — for downstream parsing without regex over `notes`."),
+      text: exports_external.string().describe("Joined per-page text for this document, ready for ai.extract"),
+      pages: exports_external.array(exports_external.object({
+        pageIndex: exports_external.number().int(),
+        text: exports_external.string(),
+        pageName: exports_external.string().optional(),
+        source: exports_external.enum(["anchored", "inferred"]).describe("Whether this page was the LLM boundary (direct evidence) or filled in by continuity")
+      })).describe("Raw per-page records covered by this document, in page order."),
+      pages_anchored: exports_external.array(exports_external.number().int()),
+      pages_inferred: exports_external.array(exports_external.number().int())
+    }))
+  });
+});
+
+// ../types/src/processor/configs/split.ts
+var SplitInputSchema, SplitConfigSchema, ConfidenceLevelSchema2, SplitOutputSchema;
+var init_split = __esm(() => {
+  init_zod();
+  SplitInputSchema = exports_external.object({
+    pages: exports_external.array(exports_external.object({
+      pageIndex: exports_external.number().describe("0-based page index"),
+      text: exports_external.string().describe("Extracted text for this page"),
+      pageName: exports_external.string().optional()
+    })).min(1).describe("Per-page parsed content from a document parser")
+  }).passthrough().describe("Document-parser-shaped input. Pass {{ steps.parse.output }} directly — extra fields like text/metadata are ignored.");
+  SplitConfigSchema = exports_external.object({
+    sections: exports_external.array(exports_external.object({
+      name: exports_external.string().min(1).describe("Stable id for the section"),
+      description: exports_external.string().min(1).describe("What this section looks like in the document. Use the document's own terminology (e.g. 'Príloha 2 / Anlage 2') and visual cues."),
+      required: exports_external.boolean().optional().describe('If true, log a warn when this section is not found, and lean the LLM toward expecting it. Default: false (Reducto-style "may be absent").'),
+      endHints: exports_external.array(exports_external.string()).optional().describe('Natural-language hints fed to the LLM about what marks the END of this section (e.g. ["PRÍPAD PORUŠENIA ZMLUVY", "*Koniec prílohy*", "the next chapter heading"]). The LLM uses these as guidance — not a regex match — so casing variants, missing diacritics, and multilingual phrasings still close the section correctly. The LLM emits a structured end_anchor per section it judges closed; deterministic merge applies it.')
+    })).min(1),
+    rules: exports_external.string().optional().describe("Optional natural-language rules appended to the system prompt"),
+    provider: exports_external.string().optional().describe('Provider ID from eigenpal.config.yaml (e.g. "openai-gpt5.4-mini"). Falls back to the tenant default LLM provider when omitted.'),
+    windowTokenBudget: exports_external.number().int().positive().optional().describe("Per-window token ceiling. Defaults to env SPLIT_WINDOW_TOKEN_BUDGET or 20000. Smaller windows give sharper anchors on contract-style documents (less competing context for the LLM to mis-anchor on); 50k–100k when sections routinely exceed per-window page count.")
+  });
+  ConfidenceLevelSchema2 = exports_external.enum(["low", "medium", "high"]).describe("LLM confidence as a coarse enum. Numeric (0..1) confidences cluster at 0.85–0.95 and gradations are noise; low/medium/high is reliable.");
+  SplitOutputSchema = exports_external.object({
+    splits: exports_external.array(exports_external.object({
+      name: exports_external.string(),
+      page_range: exports_external.tuple([exports_external.number().int(), exports_external.number().int()]),
+      confidence: ConfidenceLevelSchema2.describe("LLM confidence at the start anchor: low | medium | high."),
+      notes: exports_external.string(),
+      evidence: exports_external.object({
+        start_heading_text: exports_external.string().nullable().optional().describe("Verbatim heading text the LLM cited as the section start"),
+        start_page: exports_external.number().int().nullable().optional().describe("Page where start_heading_text appears")
+      }).optional().describe("Structured start-anchor evidence the LLM cited — for downstream parsing without regex over `notes`."),
+      end_evidence: exports_external.object({
+        end_page: exports_external.number().int().describe("LAST page of the section (inclusive)"),
+        confidence: ConfidenceLevelSchema2,
+        notes: exports_external.string().describe("LLM justification for the end. Pairs with start-anchor `notes` so a reconciliation pass can judge whether the section is correctly bounded.")
+      }).optional().describe("Set when the LLM flagged a section close (matched against `endHints` or detected end-of-section markers). Absent when the section was closed by deterministic continuity-fill (next section start - 1)."),
+      text: exports_external.string().describe("Joined per-page text for this section, ready for ai.extract"),
+      pages: exports_external.array(exports_external.object({
+        pageIndex: exports_external.number().int(),
+        text: exports_external.string(),
+        pageName: exports_external.string().optional(),
+        source: exports_external.enum(["anchored", "inferred"]).describe("Whether this page was the LLM anchor (direct evidence) or filled in by continuity")
+      })).describe("Raw per-page records covered by this split (in page order). Use when downstream needs to iterate page-by-page rather than treating the section as one blob."),
+      pages_anchored: exports_external.array(exports_external.number().int()),
+      pages_inferred: exports_external.array(exports_external.number().int())
+    }))
+  });
+});
+
+// ../types/src/processor/configs/template.ts
+var TemplateInputSchema, TemplateOutputSchema, TemplateConfigSchema;
+var init_template = __esm(() => {
+  init_zod();
+  TemplateInputSchema = exports_external.object({
+    data: exports_external.record(exports_external.string(), exports_external.unknown()).describe("Data to merge into the template")
+  });
+  TemplateOutputSchema = exports_external.object({
+    fileId: exports_external.string().describe("File ID from files table")
+  });
+  TemplateConfigSchema = exports_external.object({
+    templateId: exports_external.string().describe("ID of the template from templates table"),
+    outputFilename: exports_external.string().optional().describe('Output filename - supports LiquidJS syntax e.g. "{{invoice_id}}-report.docx"'),
+    highlightNotFound: exports_external.boolean().default(true).optional().describe("Highlight missing variables with red-colored text in the output document"),
+    notFoundText: exports_external.string().default("NOT FOUND").optional().describe("Text to display for missing variables when highlightNotFound is enabled")
+  });
+});
+
+// ../types/src/processor/configs/xlsx-to-json.ts
+var XlsxToJsonInputSchema, XlsxToJsonOutputSchema, XlsxToJsonConfigSchema;
+var init_xlsx_to_json = __esm(() => {
+  init_zod();
+  init_runtime_file_ref();
+  XlsxToJsonInputSchema = ResolvedProcessorFileSchema;
+  XlsxToJsonOutputSchema = exports_external.object({
+    rows: exports_external.array(exports_external.record(exports_external.string(), exports_external.unknown())).describe("Array of row objects (header row = keys)"),
+    fileId: exports_external.string().optional().describe("File ID of stored CSV when outputCsv is true")
+  });
+  XlsxToJsonConfigSchema = exports_external.object({
+    sheet: exports_external.union([exports_external.number().int().min(0), exports_external.string()]).optional().describe("Sheet to read: 0-based index or sheet name"),
+    outputCsv: exports_external.boolean().default(false).optional(),
+    outputFilename: exports_external.string().optional().describe("Output CSV filename when outputCsv is true")
+  });
+});
+
+// ../types/src/processor/configs/react-hook-form.ts
+function extractFieldMetadata(schema) {
+  const fields = [];
+  let inner = schema;
+  while (inner instanceof exports_external.ZodDefault || inner instanceof exports_external.ZodPrefault) {
+    inner = inner.unwrap();
+  }
+  if (inner instanceof exports_external.ZodObject) {
+    for (const [name, fieldSchema] of Object.entries(inner.shape)) {
+      fields.push(extractSingleFieldMetadata(name, fieldSchema));
+    }
+  }
+  return fields;
+}
+function extractSingleFieldMetadata(name, schema) {
+  let current = schema;
+  let required2 = true;
+  let defaultValue = undefined;
+  let description = current.description;
+  while (true) {
+    if (current instanceof exports_external.ZodOptional) {
+      required2 = false;
+      current = current.unwrap();
+    } else if (current instanceof exports_external.ZodDefault || current instanceof exports_external.ZodPrefault) {
+      defaultValue = current._def.defaultValue;
+      current = current.unwrap();
+    } else {
+      break;
+    }
+    description ??= current.description;
+  }
+  const base = { name, type: "unknown", required: required2, description, defaultValue };
+  if (current instanceof exports_external.ZodString)
+    return { ...base, type: "string" };
+  if (current instanceof exports_external.ZodNumber) {
+    let min;
+    let max;
+    for (const c of current._def.checks ?? []) {
+      const def = c._zod.def;
+      if (def.check === "greater_than")
+        min = def.value;
+      if (def.check === "less_than")
+        max = def.value;
+    }
+    return { ...base, type: "number", min, max };
+  }
+  if (current instanceof exports_external.ZodBoolean)
+    return { ...base, type: "boolean" };
+  if (current instanceof exports_external.ZodEnum) {
+    return { ...base, type: "enum", enumValues: current.options };
+  }
+  if (current instanceof exports_external.ZodArray)
+    return { ...base, type: "array" };
+  if (current instanceof exports_external.ZodObject || current instanceof exports_external.ZodRecord) {
+    return { ...base, type: "object" };
+  }
+  return base;
+}
+function getConfigFieldMetadata(processorId) {
+  const schema = getConfigSchema(processorId);
+  if (!schema)
+    return;
+  return extractFieldMetadata(schema);
+}
+function getConfigDefaults(processorId) {
+  const schema = PROCESSOR_SCHEMAS[processorId]?.configSchema;
+  if (!schema)
+    return {};
+  try {
+    const result = schema.safeParse({});
+    if (result.success) {
+      return result.data;
+    }
+  } catch {}
+  const fields = extractFieldMetadata(schema);
+  const defaults = {};
+  for (const field of fields) {
+    if (field.defaultValue !== undefined) {
+      defaults[field.name] = field.defaultValue;
+    }
+  }
+  return defaults;
+}
+function validateConfig(processorId, config2) {
+  const schema = getConfigSchema(processorId);
+  if (!schema) {
+    return { valid: true, errors: {} };
+  }
+  const result = schema.safeParse(config2);
+  if (result.success) {
+    return { valid: true, errors: {} };
+  }
+  const errors3 = {};
+  for (const issue2 of result.error.issues) {
+    const path = issue2.path.join(".");
+    errors3[path] = issue2.message;
+  }
+  return { valid: false, errors: errors3 };
+}
+var init_react_hook_form = __esm(() => {
+  init_zod();
+  init_configs();
+});
+
+// ../types/src/processor/configs/index.ts
+function getProcessorSchemas(processorId) {
+  return PROCESSOR_SCHEMAS[processorId];
+}
+function getConfigSchema(processorId) {
+  return PROCESSOR_SCHEMAS[processorId]?.configSchema;
+}
+function getAllProcessorJsonSchemas() {
+  return Object.values(PROCESSOR_SCHEMAS).map((p) => ({
+    id: p.id,
+    inputSchema: toJsonSchema(p.inputSchema),
+    outputSchema: toJsonSchema(p.outputSchema),
+    configSchema: toJsonSchema(p.configSchema)
+  }));
+}
+function listProcessorIds() {
+  return Object.keys(PROCESSOR_SCHEMAS);
+}
+var PROCESSOR_SCHEMAS;
+var init_configs = __esm(() => {
+  init_common();
+  init_ids();
+  init_classify();
+  init_document_parser();
+  init_extract();
+  init_merge();
+  init_pdf_embedder();
+  init_segment();
+  init_split();
+  init_template();
+  init_xlsx_to_json();
+  init_react_hook_form();
+  init_classify();
+  init_document_parser();
+  init_extract();
+  init_merge();
+  init_pdf_embedder();
+  init_segment();
+  init_split();
+  init_template();
+  init_xlsx_to_json();
+  PROCESSOR_SCHEMAS = {
+    [PROCESSOR_IDS.EXTRACT]: {
+      id: PROCESSOR_IDS.EXTRACT,
+      inputSchema: ExtractInputSchema,
+      outputSchema: ExtractOutputSchema,
+      configSchema: ExtractConfigSchema
+    },
+    [PROCESSOR_IDS.DOCUMENT_PARSER]: {
+      id: PROCESSOR_IDS.DOCUMENT_PARSER,
+      inputSchema: DocumentParserInputSchema,
+      outputSchema: DocumentParserOutputSchema,
+      configSchema: DocumentParserConfigSchema
+    },
+    [PROCESSOR_IDS.MERGE]: {
+      id: PROCESSOR_IDS.MERGE,
+      inputSchema: MergeInputSchema,
+      outputSchema: MergeOutputSchema,
+      configSchema: MergeConfigSchema
+    },
+    [PROCESSOR_IDS.TEMPLATE]: {
+      id: PROCESSOR_IDS.TEMPLATE,
+      inputSchema: TemplateInputSchema,
+      outputSchema: TemplateOutputSchema,
+      configSchema: TemplateConfigSchema
+    },
+    [PROCESSOR_IDS.PDF_EMBEDDER]: {
+      id: PROCESSOR_IDS.PDF_EMBEDDER,
+      inputSchema: PdfEmbedderInputSchema,
+      outputSchema: PdfEmbedderOutputSchema,
+      configSchema: PdfEmbedderConfigSchema
+    },
+    [PROCESSOR_IDS.SPLIT]: {
+      id: PROCESSOR_IDS.SPLIT,
+      inputSchema: SplitInputSchema,
+      outputSchema: SplitOutputSchema,
+      configSchema: SplitConfigSchema
+    },
+    [PROCESSOR_IDS.SEGMENT]: {
+      id: PROCESSOR_IDS.SEGMENT,
+      inputSchema: SegmentInputSchema,
+      outputSchema: SegmentOutputSchema,
+      configSchema: SegmentConfigSchema
+    },
+    [PROCESSOR_IDS.CLASSIFY]: {
+      id: PROCESSOR_IDS.CLASSIFY,
+      inputSchema: ClassifyInputSchema,
+      outputSchema: ClassifyOutputSchema,
+      configSchema: ClassifyConfigSchema
+    },
+    [PROCESSOR_IDS.XLSX_TO_JSON]: {
+      id: PROCESSOR_IDS.XLSX_TO_JSON,
+      inputSchema: XlsxToJsonInputSchema,
+      outputSchema: XlsxToJsonOutputSchema,
+      configSchema: XlsxToJsonConfigSchema
+    }
+  };
+});
+
 // ../types/src/processor/index.ts
-var init_processor = () => {};
+var init_processor2 = __esm(() => {
+  init_processor();
+  init_execution();
+  init_configs();
+});
 
 // ../types/src/parser/index.ts
-var init_parser = () => {};
+var init_parser2 = __esm(() => {
+  init_parser();
+});
 
 // ../types/src/otel/semantic-conventions.ts
 function mapLLMAttributes(attrs) {
@@ -20370,9 +22908,9 @@ var require_validate = __commonJS((exports) => {
     }
     let expr = data;
     const segments = jsonPointer.split("/");
-    for (const segment of segments) {
-      if (segment) {
-        data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment))}`;
+    for (const segment2 of segments) {
+      if (segment2) {
+        data = (0, codegen_1._)`${data}${(0, codegen_1.getProperty)((0, util_1.unescapeJsonPointer)(segment2))}`;
         expr = (0, codegen_1._)`${expr} && ${data}`;
       }
     }
@@ -20652,7 +23190,7 @@ var require_data = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/fast-uri/lib/utils.js
-var require_utils = __commonJS((exports, module) => {
+var require_utils3 = __commonJS((exports, module) => {
   var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
   var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
   function stringArrayToHexStripped(input) {
@@ -20908,7 +23446,7 @@ var require_utils = __commonJS((exports, module) => {
 
 // ../../node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS((exports, module) => {
-  var { isUUID } = require_utils();
+  var { isUUID } = require_utils3();
   var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
   var supportedSchemeNames = [
     "http",
@@ -21082,7 +23620,7 @@ var require_schemes = __commonJS((exports, module) => {
 
 // ../../node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS((exports, module) => {
-  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils3();
   var { SCHEMES, getSchemeHandler } = require_schemes();
   function normalize(uri, options) {
     if (typeof uri === "string") {
@@ -23492,7 +26030,7 @@ var require_draft7 = __commonJS((exports) => {
 });
 
 // ../../node_modules/ajv/dist/vocabularies/discriminator/types.js
-var require_types = __commonJS((exports) => {
+var require_types2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.DiscrError = undefined;
   var DiscrError;
@@ -23506,7 +26044,7 @@ var require_types = __commonJS((exports) => {
 var require_discriminator = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var codegen_1 = require_codegen();
-  var types_1 = require_types();
+  var types_1 = require_types2();
   var compile_1 = require_compile();
   var ref_error_1 = require_ref_error();
   var util_1 = require_util();
@@ -24434,24 +26972,6 @@ var init_validation = __esm(() => {
   init_workspace_schema();
 });
 
-// ../types/src/core/common.ts
-function toJsonSchema2(schema) {
-  return exports_external.toJSONSchema(schema, { target: "draft-7" });
-}
-var TimestampSchema2, JsonSchemaSchema2, BaseEntitySchema2;
-var init_common = __esm(() => {
-  init_zod();
-  TimestampSchema2 = exports_external.union([exports_external.date(), exports_external.string().datetime()]).transform((val) => {
-    return typeof val === "string" ? new Date(val) : val;
-  });
-  JsonSchemaSchema2 = exports_external.record(exports_external.string(), exports_external.unknown());
-  BaseEntitySchema2 = exports_external.object({
-    id: exports_external.string(),
-    createdAt: TimestampSchema2.optional(),
-    updatedAt: TimestampSchema2.optional()
-  });
-});
-
 // ../../node_modules/@babel/parser/lib/index.js
 var require_lib = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", {
@@ -24865,12 +27385,12 @@ var require_lib = __commonJS((exports) => {
     }
     const ParseErrorConstructors = {};
     for (const reasonCode of Object.keys(argument)) {
-      const template = argument[reasonCode];
-      const _ref = typeof template === "string" ? {
-        message: () => template
-      } : typeof template === "function" ? {
-        message: template
-      } : template, {
+      const template2 = argument[reasonCode];
+      const _ref = typeof template2 === "string" ? {
+        message: () => template2
+      } : typeof template2 === "function" ? {
+        message: template2
+      } : template2, {
         message
       } = _ref, rest = _objectWithoutPropertiesLoose(_ref, _excluded);
       const toMessage = typeof message === "string" ? () => message : message;
@@ -39343,7 +41863,7 @@ var require_keywords = __commonJS((exports) => {
 });
 
 // ../../node_modules/sucrase/dist/parser/tokenizer/types.js
-var require_types2 = __commonJS((exports) => {
+var require_types3 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var TokenType;
   (function(TokenType2) {
@@ -39407,8 +41927,8 @@ var require_types2 = __commonJS((exports) => {
     TokenType2[TokenType2["questionDot"] = questionDot] = "questionDot";
     const arrow = 22528;
     TokenType2[TokenType2["arrow"] = arrow] = "arrow";
-    const template = 23552;
-    TokenType2[TokenType2["template"] = template] = "template";
+    const template2 = 23552;
+    TokenType2[TokenType2["template"] = template2] = "template";
     const ellipsis = 24576;
     TokenType2[TokenType2["ellipsis"] = ellipsis] = "ellipsis";
     const backQuote = 25600;
@@ -39827,7 +42347,7 @@ var require_types2 = __commonJS((exports) => {
 var require_state = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
 
   class Scope {
     constructor(startTokenIndex, endTokenIndex, isFunctionScope) {
@@ -40213,7 +42733,7 @@ var require_base = __commonJS((exports) => {
 var require_util2 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _index = require_tokenizer();
-  var _types = require_types2();
+  var _types = require_types3();
   var _charcodes = require_charcodes();
   var _base = require_base();
   function isContextual(contextualKeyword) {
@@ -40375,7 +42895,7 @@ var require_identifier = __commonJS((exports) => {
 var require_readWordTree = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   var READ_WORD_TREE = new Int32Array([
     -1,
     27,
@@ -49353,7 +51873,7 @@ var require_readWord = __commonJS((exports) => {
   var _identifier = require_identifier();
   var _index = require_tokenizer();
   var _readWordTree = require_readWordTree();
-  var _types = require_types2();
+  var _types = require_types3();
   function readWord() {
     let treePos = 0;
     let code = 0;
@@ -49419,7 +51939,7 @@ var require_tokenizer = __commonJS((exports) => {
   var _keywords = require_keywords();
   var _readWord = require_readWord();
   var _readWord2 = _interopRequireDefault(_readWord);
-  var _types = require_types2();
+  var _types = require_types3();
   var IdentifierRole;
   (function(IdentifierRole2) {
     const Access = 0;
@@ -50136,7 +52656,7 @@ var require_tokenizer = __commonJS((exports) => {
 // ../../node_modules/sucrase/dist/util/getImportExportSpecifierInfo.js
 var require_getImportExportSpecifierInfo = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  var _types = require_types2();
+  var _types = require_types3();
   function getImportExportSpecifierInfo(tokens, index = tokens.currentIndex()) {
     let endIndex = index + 1;
     if (isSpecifierEnd(tokens, endIndex)) {
@@ -50489,7 +53009,7 @@ var require_JSXTransformer = __commonJS((exports) => {
   var _xhtml = require_xhtml();
   var _xhtml2 = _interopRequireDefault(_xhtml);
   var _tokenizer = require_tokenizer();
-  var _types = require_types2();
+  var _types = require_types3();
   var _charcodes = require_charcodes();
   var _getJSXPragmaInfo = require_getJSXPragmaInfo();
   var _getJSXPragmaInfo2 = _interopRequireDefault(_getJSXPragmaInfo);
@@ -50993,7 +53513,7 @@ var require_getNonTypeIdentifiers = __commonJS((exports) => {
     return obj && obj.__esModule ? obj : { default: obj };
   }
   var _tokenizer = require_tokenizer();
-  var _types = require_types2();
+  var _types = require_types3();
   var _JSXTransformer = require_JSXTransformer();
   var _getJSXPragmaInfo = require_getJSXPragmaInfo();
   var _getJSXPragmaInfo2 = _interopRequireDefault(_getJSXPragmaInfo);
@@ -51032,7 +53552,7 @@ var require_CJSImportProcessor = __commonJS((exports) => {
   }
   var _tokenizer = require_tokenizer();
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   var _getImportExportSpecifierInfo = require_getImportExportSpecifierInfo();
   var _getImportExportSpecifierInfo2 = _interopRequireDefault(_getImportExportSpecifierInfo);
   var _getNonTypeIdentifiers = require_getNonTypeIdentifiers();
@@ -51803,18 +54323,18 @@ var require_sourcemap_codec_umd = __commonJS((exports, module) => {
           continue;
         let genColumn = 0;
         for (let j = 0;j < line.length; j++) {
-          const segment = line[j];
+          const segment2 = line[j];
           if (j > 0)
             writer.write(comma);
-          genColumn = encodeInteger(writer, segment[0], genColumn);
-          if (segment.length === 1)
+          genColumn = encodeInteger(writer, segment2[0], genColumn);
+          if (segment2.length === 1)
             continue;
-          sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
-          sourceLine = encodeInteger(writer, segment[2], sourceLine);
-          sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
-          if (segment.length === 4)
+          sourcesIndex = encodeInteger(writer, segment2[1], sourcesIndex);
+          sourceLine = encodeInteger(writer, segment2[2], sourceLine);
+          sourceColumn = encodeInteger(writer, segment2[3], sourceColumn);
+          if (segment2.length === 4)
             continue;
-          namesIndex = encodeInteger(writer, segment[4], namesIndex);
+          namesIndex = encodeInteger(writer, segment2[4], namesIndex);
         }
       }
       return writer.flush();
@@ -52369,11 +54889,11 @@ var require_trace_mapping_umd = __commonJS((exports, module) => {
       const index = traceSegmentInternal(segments, cast(map2)._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
       if (index === -1)
         return OMapping(null, null, null, null);
-      const segment = segments[index];
-      if (segment.length === 1)
+      const segment2 = segments[index];
+      if (segment2.length === 1)
         return OMapping(null, null, null, null);
       const { names, resolvedSources } = map2;
-      return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
+      return OMapping(resolvedSources[segment2[SOURCES_INDEX]], segment2[SOURCE_LINE] + 1, segment2[SOURCE_COLUMN], segment2.length === 5 ? names[segment2[NAMES_INDEX]] : null);
     }
     function generatedPositionFor(map2, needle) {
       const { source, line, column, bias } = needle;
@@ -52486,8 +55006,8 @@ var require_trace_mapping_umd = __commonJS((exports, module) => {
       const max = upperBound(segments, matchedColumn, min);
       const result = [];
       for (;min <= max; min++) {
-        const segment = segments[min];
-        result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
+        const segment2 = segments[min];
+        result.push(GMapping(segment2[REV_GENERATED_LINE] + 1, segment2[REV_GENERATED_COLUMN]));
       }
       return result;
     }
@@ -52515,8 +55035,8 @@ var require_trace_mapping_umd = __commonJS((exports, module) => {
       const index = traceSegmentInternal(segments, memo, line, column, bias);
       if (index === -1)
         return GMapping(null, null);
-      const segment = segments[index];
-      return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+      const segment2 = segments[index];
+      return GMapping(segment2[REV_GENERATED_LINE] + 1, segment2[REV_GENERATED_COLUMN]);
     }
   });
 });
@@ -53067,7 +55587,7 @@ var require_HelperManager = __commonJS((exports) => {
 var require_identifyShadowedGlobals = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _tokenizer = require_tokenizer();
-  var _types = require_types2();
+  var _types = require_types3();
   function identifyShadowedGlobals(tokens, scopes, globalNames) {
     if (!hasShadowedGlobals(tokens, globalNames)) {
       return;
@@ -53132,7 +55652,7 @@ var require_identifyShadowedGlobals = __commonJS((exports) => {
 // ../../node_modules/sucrase/dist/util/getIdentifierNames.js
 var require_getIdentifierNames = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  var _types = require_types2();
+  var _types = require_types3();
   function getIdentifierNames(code, tokens) {
     const names = [];
     for (const token of tokens) {
@@ -53308,7 +55828,7 @@ var require_util3 = __commonJS((exports) => {
 });
 
 // ../../node_modules/ts-interface-checker/dist/types.js
-var require_types3 = __commonJS((exports) => {
+var require_types4 = __commonJS((exports) => {
   var __extends = exports && exports.__extends || function() {
     var extendStatics = function(d, b) {
       extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
@@ -53908,9 +56428,9 @@ var require_dist2 = __commonJS((exports) => {
   };
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.Checker = exports.createCheckers = undefined;
-  var types_1 = require_types3();
+  var types_1 = require_types4();
   var util_1 = require_util3();
-  var types_2 = require_types3();
+  var types_2 = require_types4();
   Object.defineProperty(exports, "TArray", { enumerable: true, get: function() {
     return types_2.TArray;
   } });
@@ -54192,7 +56712,7 @@ var require_lval = __commonJS((exports) => {
   var _typescript = require_typescript();
   var _index = require_tokenizer();
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   var _base = require_base();
   var _expression = require_expression();
   var _util = require_util2();
@@ -54324,7 +56844,7 @@ var require_typescript = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _index = require_tokenizer();
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   var _base = require_base();
   var _expression = require_expression();
   var _lval = require_lval();
@@ -55586,7 +58106,7 @@ var require_typescript = __commonJS((exports) => {
 var require_jsx = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _index = require_tokenizer();
-  var _types = require_types2();
+  var _types = require_types3();
   var _base = require_base();
   var _expression = require_expression();
   var _util = require_util2();
@@ -55849,10 +58369,10 @@ var require_jsx = __commonJS((exports) => {
 });
 
 // ../../node_modules/sucrase/dist/parser/plugins/types.js
-var require_types4 = __commonJS((exports) => {
+var require_types5 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _index = require_tokenizer();
-  var _types = require_types2();
+  var _types = require_types3();
   var _base = require_base();
   var _expression = require_expression();
   var _flow = require_flow();
@@ -55885,12 +58405,12 @@ var require_expression = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _flow = require_flow();
   var _index = require_jsx();
-  var _types = require_types4();
+  var _types = require_types5();
   var _typescript = require_typescript();
   var _index3 = require_tokenizer();
   var _keywords = require_keywords();
   var _state = require_state();
-  var _types3 = require_types2();
+  var _types3 = require_types3();
   var _charcodes = require_charcodes();
   var _identifier = require_identifier();
   var _base = require_base();
@@ -56606,7 +59126,7 @@ var require_flow = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _index = require_tokenizer();
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   var _base = require_base();
   var _expression = require_expression();
   var _statement = require_statement();
@@ -57481,7 +60001,7 @@ var require_statement = __commonJS((exports) => {
   var _tokenizer = require_tokenizer();
   var _keywords = require_keywords();
   var _state = require_state();
-  var _types = require_types2();
+  var _types = require_types3();
   var _charcodes = require_charcodes();
   var _base = require_base();
   var _expression = require_expression();
@@ -58516,7 +61036,7 @@ var require_TokenProcessor = __commonJS((exports) => {
   function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : { default: obj };
   }
-  var _types = require_types2();
+  var _types = require_types3();
   var _isAsyncOperation = require_isAsyncOperation();
   var _isAsyncOperation2 = _interopRequireDefault(_isAsyncOperation);
 
@@ -58774,7 +61294,7 @@ var require_TokenProcessor = __commonJS((exports) => {
 var require_getClassInfo = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   function getClassInfo(rootTransformer, tokens, nameManager, disableESTransforms) {
     const snapshot = tokens.snapshot();
     const headerInfo = processClassHeader(tokens);
@@ -59012,7 +61532,7 @@ var require_getClassInfo = __commonJS((exports) => {
 // ../../node_modules/sucrase/dist/util/elideImportEquals.js
 var require_elideImportEquals = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  var _types = require_types2();
+  var _types = require_types3();
   function elideImportEquals(tokens) {
     tokens.removeInitialToken();
     tokens.removeToken();
@@ -59036,7 +61556,7 @@ var require_elideImportEquals = __commonJS((exports) => {
 var require_getDeclarationInfo = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _tokenizer = require_tokenizer();
-  var _types = require_types2();
+  var _types = require_types3();
   var EMPTY_DECLARATION_INFO = {
     typeDeclarations: new Set,
     valueDeclarations: new Set
@@ -59064,7 +61584,7 @@ var require_getDeclarationInfo = __commonJS((exports) => {
 var require_isExportFrom = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   function isExportFrom(tokens) {
     let closeBraceIndex = tokens.currentIndex();
     while (!tokens.matches1AtIndex(closeBraceIndex, _types.TokenType.braceR)) {
@@ -59079,7 +61599,7 @@ var require_isExportFrom = __commonJS((exports) => {
 var require_removeMaybeImportAttributes = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   function removeMaybeImportAttributes(tokens) {
     if (tokens.matches2(_types.TokenType._with, _types.TokenType.braceL) || tokens.matches2(_types.TokenType.name, _types.TokenType.braceL) && tokens.matchesContextual(_keywords.ContextualKeyword._assert)) {
       tokens.removeToken();
@@ -59094,7 +61614,7 @@ var require_removeMaybeImportAttributes = __commonJS((exports) => {
 // ../../node_modules/sucrase/dist/util/shouldElideDefaultExport.js
 var require_shouldElideDefaultExport = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
-  var _types = require_types2();
+  var _types = require_types3();
   function shouldElideDefaultExport(isTypeScriptTransformEnabled, keepUnusedImports, tokens, declarationInfo) {
     if (!isTypeScriptTransformEnabled || keepUnusedImports) {
       return false;
@@ -59125,7 +61645,7 @@ var require_CJSImportTransformer = __commonJS((exports) => {
   }
   var _tokenizer = require_tokenizer();
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   var _elideImportEquals = require_elideImportEquals();
   var _elideImportEquals2 = _interopRequireDefault(_elideImportEquals);
   var _getDeclarationInfo = require_getDeclarationInfo();
@@ -59767,7 +62287,7 @@ var require_ESMImportTransformer = __commonJS((exports) => {
     return obj && obj.__esModule ? obj : { default: obj };
   }
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   var _elideImportEquals = require_elideImportEquals();
   var _elideImportEquals2 = _interopRequireDefault(_elideImportEquals);
   var _getDeclarationInfo = require_getDeclarationInfo();
@@ -60037,7 +62557,7 @@ var require_FlowTransformer = __commonJS((exports) => {
     return obj && obj.__esModule ? obj : { default: obj };
   }
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   var _Transformer = require_Transformer();
   var _Transformer2 = _interopRequireDefault(_Transformer);
 
@@ -60157,7 +62677,7 @@ var require_JestHoistTransformer = __commonJS((exports) => {
     }
     return value;
   }
-  var _types = require_types2();
+  var _types = require_types3();
   var _Transformer = require_Transformer();
   var _Transformer2 = _interopRequireDefault(_Transformer);
   var JEST_GLOBAL_NAME = "jest";
@@ -60231,7 +62751,7 @@ var require_NumericSeparatorTransformer = __commonJS((exports) => {
   function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : { default: obj };
   }
-  var _types = require_types2();
+  var _types = require_types3();
   var _Transformer = require_Transformer();
   var _Transformer2 = _interopRequireDefault(_Transformer);
 
@@ -60260,7 +62780,7 @@ var require_OptionalCatchBindingTransformer = __commonJS((exports) => {
   function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : { default: obj };
   }
-  var _types = require_types2();
+  var _types = require_types3();
   var _Transformer = require_Transformer();
   var _Transformer2 = _interopRequireDefault(_Transformer);
 
@@ -60288,7 +62808,7 @@ var require_OptionalChainingNullishTransformer = __commonJS((exports) => {
   function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : { default: obj };
   }
-  var _types = require_types2();
+  var _types = require_types3();
   var _Transformer = require_Transformer();
   var _Transformer2 = _interopRequireDefault(_Transformer);
 
@@ -60404,7 +62924,7 @@ var require_ReactDisplayNameTransformer = __commonJS((exports) => {
     return obj && obj.__esModule ? obj : { default: obj };
   }
   var _tokenizer = require_tokenizer();
-  var _types = require_types2();
+  var _types = require_types3();
   var _Transformer = require_Transformer();
   var _Transformer2 = _interopRequireDefault(_Transformer);
 
@@ -60655,7 +63175,7 @@ var require_TypeScriptTransformer = __commonJS((exports) => {
   function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : { default: obj };
   }
-  var _types = require_types2();
+  var _types = require_types3();
   var _isIdentifier = require_isIdentifier();
   var _isIdentifier2 = _interopRequireDefault(_isIdentifier);
   var _Transformer = require_Transformer();
@@ -60801,7 +63321,7 @@ var require_RootTransformer = __commonJS((exports) => {
     return obj && obj.__esModule ? obj : { default: obj };
   }
   var _keywords = require_keywords();
-  var _types = require_types2();
+  var _types = require_types3();
   var _getClassInfo = require_getClassInfo();
   var _getClassInfo2 = _interopRequireDefault(_getClassInfo);
   var _CJSImportTransformer = require_CJSImportTransformer();
@@ -61200,7 +63720,7 @@ var require_formatTokens = __commonJS((exports) => {
   }
   var _linesandcolumns = require_build();
   var _linesandcolumns2 = _interopRequireDefault(_linesandcolumns);
-  var _types = require_types2();
+  var _types = require_types3();
   function formatTokens(code, tokens) {
     if (tokens.length === 0) {
       return "";
@@ -61265,7 +63785,7 @@ var require_getTSImportedNames = __commonJS((exports) => {
   function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : { default: obj };
   }
-  var _types = require_types2();
+  var _types = require_types3();
   var _getImportExportSpecifierInfo = require_getImportExportSpecifierInfo();
   var _getImportExportSpecifierInfo2 = _interopRequireDefault(_getImportExportSpecifierInfo);
   function getTSImportedNames(tokens) {
@@ -61650,7 +64170,7 @@ function describeUnsupportedType(nodeType) {
 function compileTypedScript(opts) {
   let ast;
   try {
-    ast = import_parser2.parse(opts.source, {
+    ast = import_parser4.parse(opts.source, {
       sourceType: "script",
       plugins: ["typescript"],
       ranges: true
@@ -61902,9 +64422,9 @@ function stripCommentsAndStrings(s) {
   out = out.replace(/`(\\.|[^`\\])*`/g, "``");
   return out;
 }
-var import_parser2, import_sucrase, EVALUATOR_FN_NAME = "scoreScript", EVALUATOR_PARAM_NAMES, TRANSFORM_FN_NAME = "script";
+var import_parser4, import_sucrase, EVALUATOR_FN_NAME = "scoreScript", EVALUATOR_PARAM_NAMES, TRANSFORM_FN_NAME = "script";
 var init_compile = __esm(() => {
-  import_parser2 = __toESM(require_lib(), 1);
+  import_parser4 = __toESM(require_lib(), 1);
   import_sucrase = __toESM(require_dist3(), 1);
   EVALUATOR_PARAM_NAMES = ["expected", "actual"];
 });
@@ -62262,8 +64782,8 @@ function getAllStepJsonSchemas() {
     category: def.category,
     name: def.name,
     description: def.description,
-    configSchema: toJsonSchema2(def.configSchema),
-    outputSchema: toJsonSchema2(def.outputSchema),
+    configSchema: toJsonSchema(def.configSchema),
+    outputSchema: toJsonSchema(def.outputSchema),
     configInWith: def.configInWith
   }));
 }
@@ -63081,81 +65601,6 @@ var init_actions = __esm(() => {
   ACTION_TYPES = ActionTypeSchema.options;
 });
 
-// ../types/src/processor/execution.ts
-function asTuple(values) {
-  return values;
-}
-var WorkflowExecutionStatusValue2, WorkflowExecutionStatusSchema2, StepExecutionStatusValue2, StepExecutionStatusSchema2, TriggerTypeValue2, TriggerTypeSchema2, ExecutionTypeValue2, ExecutionTypeSchema2, WORKFLOW_EXECUTION_STATUSES2, STEP_EXECUTION_STATUSES2, TRIGGER_TYPES2, EXECUTION_TYPES2;
-var init_execution = __esm(() => {
-  init_zod();
-  WorkflowExecutionStatusValue2 = {
-    CREATED: "created",
-    PENDING: "pending",
-    RUNNING: "running",
-    WAITING: "waiting",
-    COMPLETED: "completed",
-    FAILED: "failed",
-    CANCELLED: "cancelled"
-  };
-  WorkflowExecutionStatusSchema2 = exports_external.enum([
-    WorkflowExecutionStatusValue2.CREATED,
-    WorkflowExecutionStatusValue2.PENDING,
-    WorkflowExecutionStatusValue2.RUNNING,
-    WorkflowExecutionStatusValue2.WAITING,
-    WorkflowExecutionStatusValue2.COMPLETED,
-    WorkflowExecutionStatusValue2.FAILED,
-    WorkflowExecutionStatusValue2.CANCELLED
-  ]);
-  StepExecutionStatusValue2 = {
-    PENDING: "pending",
-    RUNNING: "running",
-    SUCCESS: "success",
-    FAILURE: "failure",
-    WAITING: "waiting",
-    SKIPPED: "skipped"
-  };
-  StepExecutionStatusSchema2 = exports_external.enum([
-    StepExecutionStatusValue2.PENDING,
-    StepExecutionStatusValue2.RUNNING,
-    StepExecutionStatusValue2.SUCCESS,
-    StepExecutionStatusValue2.FAILURE,
-    StepExecutionStatusValue2.WAITING,
-    StepExecutionStatusValue2.SKIPPED
-  ]);
-  TriggerTypeValue2 = {
-    MANUAL: "manual",
-    API: "api",
-    WEBHOOK: "webhook",
-    SCHEDULE: "schedule",
-    EMAIL: "email",
-    EVAL: "eval",
-    CLI: "cli"
-  };
-  TriggerTypeSchema2 = exports_external.enum([
-    TriggerTypeValue2.MANUAL,
-    TriggerTypeValue2.API,
-    TriggerTypeValue2.WEBHOOK,
-    TriggerTypeValue2.SCHEDULE,
-    TriggerTypeValue2.EMAIL,
-    TriggerTypeValue2.EVAL,
-    TriggerTypeValue2.CLI
-  ]);
-  ExecutionTypeValue2 = {
-    PROD: "prod",
-    EVAL: "eval",
-    PLAYGROUND: "playground"
-  };
-  ExecutionTypeSchema2 = exports_external.enum([
-    ExecutionTypeValue2.PROD,
-    ExecutionTypeValue2.EVAL,
-    ExecutionTypeValue2.PLAYGROUND
-  ]);
-  WORKFLOW_EXECUTION_STATUSES2 = asTuple(WorkflowExecutionStatusSchema2.options);
-  STEP_EXECUTION_STATUSES2 = asTuple(StepExecutionStatusSchema2.options);
-  TRIGGER_TYPES2 = TriggerTypeSchema2.options;
-  EXECUTION_TYPES2 = ExecutionTypeSchema2.options;
-});
-
 // ../types/src/workflow/workflow.ts
 function suggestWorkflowName(raw) {
   return raw.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^[_-]+|[_-]+$/g, "").slice(0, 64);
@@ -63237,11 +65682,11 @@ var init_workflow = __esm(() => {
   ManualTriggerMethodSchema = exports_external.object({
     type: exports_external.literal("manual"),
     enabled: exports_external.boolean().optional(),
-    inputSchema: JsonSchemaSchema2.optional()
+    inputSchema: JsonSchemaSchema.optional()
   });
   ApiTriggerMethodSchema = exports_external.object({
     type: exports_external.literal("api"),
-    inputSchema: JsonSchemaSchema2.optional()
+    inputSchema: JsonSchemaSchema.optional()
   });
   EmailTriggerMethodSchema = exports_external.object({
     type: exports_external.literal("email"),
@@ -63281,8 +65726,8 @@ var init_workflow = __esm(() => {
     yamlContent: exports_external.string(),
     definition: WorkflowDefinitionSchema,
     isCurrent: exports_external.boolean().default(true),
-    createdAt: TimestampSchema2,
-    updatedAt: TimestampSchema2.optional(),
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema.optional(),
     createdBy: exports_external.string()
   });
   CreateWorkflowDefinitionSchema = exports_external.object({
@@ -63464,15 +65909,15 @@ function isFileOutput(value) {
 function isWorkflowResult(value) {
   return value != null && typeof value === "object" && "files" in value && Array.isArray(value.files);
 }
-var WorkflowExecutionStatusSchema3, StepExecutionStatusSchema3, ScopeEntryTypeSchema, ScopeEntrySchema, ScopeStackSchema, StepResultSchema, ExecutionContextSchema, StepInputReferenceSchema, WorkflowExecutionSchema, StepExecutionSchema, StepExecutionAttemptSchema, ConnectorSchema, WorkflowFileOutputSchema, WorkflowResultSchema;
+var WorkflowExecutionStatusSchema2, StepExecutionStatusSchema2, ScopeEntryTypeSchema, ScopeEntrySchema, ScopeStackSchema, StepResultSchema, ExecutionContextSchema, StepInputReferenceSchema, WorkflowExecutionSchema, StepExecutionSchema, StepExecutionAttemptSchema, ConnectorSchema, WorkflowFileOutputSchema, WorkflowResultSchema;
 var init_execution2 = __esm(() => {
   init_zod();
   init_common();
   init_execution();
   init_retry();
   init_workflow();
-  WorkflowExecutionStatusSchema3 = WorkflowExecutionStatusSchema2;
-  StepExecutionStatusSchema3 = StepExecutionStatusSchema2;
+  WorkflowExecutionStatusSchema2 = WorkflowExecutionStatusSchema;
+  StepExecutionStatusSchema2 = StepExecutionStatusSchema;
   ScopeEntryTypeSchema = exports_external.enum([
     "root",
     "if-then",
@@ -63495,7 +65940,7 @@ var init_execution2 = __esm(() => {
   ScopeStackSchema = exports_external.array(ScopeEntrySchema);
   StepResultSchema = exports_external.object({
     output: exports_external.unknown(),
-    status: StepExecutionStatusSchema3
+    status: StepExecutionStatusSchema2
   });
   ExecutionContextSchema = exports_external.object({
     input: exports_external.record(exports_external.string(), exports_external.unknown()),
@@ -63523,24 +65968,24 @@ var init_execution2 = __esm(() => {
     triggerType: exports_external.string(),
     triggerInput: exports_external.record(exports_external.string(), exports_external.unknown()).nullable(),
     overrides: exports_external.object({ steps: exports_external.record(exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())).optional() }).nullable().optional(),
-    status: WorkflowExecutionStatusSchema3,
+    status: WorkflowExecutionStatusSchema2,
     scopeStack: ScopeStackSchema,
     currentStepIndex: exports_external.number(),
     stepResults: exports_external.record(exports_external.string(), StepResultSchema).optional(),
     result: exports_external.unknown().nullable(),
     error: exports_external.string().nullable(),
     priority: exports_external.number().default(50),
-    availableAt: TimestampSchema2,
+    availableAt: TimestampSchema,
     leaseId: exports_external.string().nullable(),
-    leaseExpiresAt: TimestampSchema2.nullable(),
+    leaseExpiresAt: TimestampSchema.nullable(),
     workerId: exports_external.string().nullable(),
     maxRetries: exports_external.number().default(0),
     originalExecutionId: exports_external.string().nullable().optional(),
     previousExecutionId: exports_external.string().nullable().optional(),
     retryNumber: exports_external.number().default(0),
-    createdAt: TimestampSchema2,
-    startedAt: TimestampSchema2.nullable(),
-    completedAt: TimestampSchema2.nullable(),
+    createdAt: TimestampSchema,
+    startedAt: TimestampSchema.nullable(),
+    completedAt: TimestampSchema.nullable(),
     createdBy: exports_external.string().nullable()
   });
   StepExecutionSchema = exports_external.object({
@@ -63559,15 +66004,15 @@ var init_execution2 = __esm(() => {
     effectiveRetryPolicy: ResolvedRetryPolicySchema.nullable().optional(),
     retryPolicySource: RetryPolicySourceSchema.nullable().optional(),
     latestAttempt: exports_external.number().default(0),
-    nextAttemptAt: TimestampSchema2.nullable().optional(),
+    nextAttemptAt: TimestampSchema.nullable().optional(),
     inputData: exports_external.unknown().nullable(),
     outputData: exports_external.unknown().nullable(),
-    status: StepExecutionStatusSchema3,
+    status: StepExecutionStatusSchema2,
     error: exports_external.string().nullable(),
     overrideMode: exports_external.enum(["skipped", "partial"]).nullable().optional(),
     durationMs: exports_external.number().nullable(),
-    startedAt: TimestampSchema2.nullable(),
-    completedAt: TimestampSchema2.nullable()
+    startedAt: TimestampSchema.nullable(),
+    completedAt: TimestampSchema.nullable()
   });
   StepExecutionAttemptSchema = exports_external.object({
     id: exports_external.string(),
@@ -63580,8 +66025,8 @@ var init_execution2 = __esm(() => {
     failure: ExecutionFailureSchema.nullable(),
     retryDecision: RetryDecisionSchema.nullable(),
     replaySafe: exports_external.boolean().nullable(),
-    startedAt: TimestampSchema2,
-    completedAt: TimestampSchema2.nullable(),
+    startedAt: TimestampSchema,
+    completedAt: TimestampSchema.nullable(),
     durationMs: exports_external.number().nullable()
   });
   ConnectorSchema = exports_external.object({
@@ -63593,8 +66038,8 @@ var init_execution2 = __esm(() => {
     config: exports_external.record(exports_external.string(), exports_external.unknown()),
     inputSchema: exports_external.unknown().optional(),
     outputSchema: exports_external.unknown().optional(),
-    createdAt: TimestampSchema2,
-    updatedAt: TimestampSchema2.optional(),
+    createdAt: TimestampSchema,
+    updatedAt: TimestampSchema.optional(),
     createdBy: exports_external.string()
   });
   WorkflowFileOutputSchema = exports_external.object({
@@ -64560,8 +67005,8 @@ function parseRunTarget(target) {
     if (root !== "agents") {
       throw new Error(`Agent target must be rooted at "agents.", got "${idOrSlug2}"`);
     }
-    for (const segment of segments) {
-      RunTargetSegmentSchema.parse(segment);
+    for (const segment2 of segments) {
+      RunTargetSegmentSchema.parse(segment2);
     }
     const packagePath = packageName.split(".").join("/");
     const [, ...slugParts] = packagePath.split("/");
@@ -64674,9 +67119,9 @@ var init_grammar = __esm(() => {
     if (!SourcePackageTypeSchema.safeParse(parts[0]).success) {
       ctx.addIssue({ code: "custom", message: `Invalid package root: ${parts[0]}` });
     }
-    for (const segment of parts.slice(1)) {
-      if (!SourcePackageSegmentSchema.safeParse(segment).success) {
-        ctx.addIssue({ code: "custom", message: `Invalid package segment: ${segment}` });
+    for (const segment2 of parts.slice(1)) {
+      if (!SourcePackageSegmentSchema.safeParse(segment2).success) {
+        ctx.addIssue({ code: "custom", message: `Invalid package segment: ${segment2}` });
       }
     }
   });
@@ -64692,9 +67137,9 @@ var init_grammar = __esm(() => {
     if (!SourcePackageTypeSchema.safeParse(parts[0]).success) {
       ctx.addIssue({ code: "custom", message: `Invalid package root: ${parts[0]}` });
     }
-    for (const segment of parts.slice(1)) {
-      if (!SourcePackageSegmentSchema.safeParse(segment).success) {
-        ctx.addIssue({ code: "custom", message: `Invalid package segment: ${segment}` });
+    for (const segment2 of parts.slice(1)) {
+      if (!SourcePackageSegmentSchema.safeParse(segment2).success) {
+        ctx.addIssue({ code: "custom", message: `Invalid package segment: ${segment2}` });
       }
     }
   });
@@ -64788,9 +67233,9 @@ var init_grammar = __esm(() => {
       });
       return;
     }
-    for (const segment of parts.slice(1)) {
-      if (!RunTargetSegmentSchema.safeParse(segment).success) {
-        ctx.addIssue({ code: "custom", message: `Invalid run target segment: ${segment}` });
+    for (const segment2 of parts.slice(1)) {
+      if (!RunTargetSegmentSchema.safeParse(segment2).success) {
+        ctx.addIssue({ code: "custom", message: `Invalid run target segment: ${segment2}` });
       }
     }
     if (ref) {
@@ -65540,7 +67985,7 @@ function fromBig(n, le = false) {
     return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
   return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
 }
-function split(lst, le = false) {
+function split2(lst, le = false) {
   const len = lst.length;
   let Ah = new Uint32Array(len);
   let Al = new Uint32Array(len);
@@ -65720,7 +68165,7 @@ var init_sha2 = __esm(() => {
       super(28);
     }
   };
-  K512 = /* @__PURE__ */ (() => split([
+  K512 = /* @__PURE__ */ (() => split2([
     "0x428a2f98d728ae22",
     "0x7137449123ef65cd",
     "0xb5c0fbcfec4d3b2f",
@@ -66042,6 +68487,216 @@ var init_sample_rank = __esm(() => {
   UNIT_INTERVAL_DENOMINATOR = BigInt(1) << BigInt(53);
 });
 
+// ../types/src/webhooks.ts
+function serializeWebhookEvent(event) {
+  return JSON.stringify(WebhookEventEnvelopeSchema.parse(event));
+}
+function boundWebhookEventOutput(event, maxBytes) {
+  const parsed = WebhookEventEnvelopeSchema.parse(event);
+  if (new TextEncoder().encode(JSON.stringify(parsed)).byteLength <= maxBytes)
+    return parsed;
+  const run = { ...parsed.data.run };
+  delete run.output;
+  run.outputOmitted = true;
+  const bounded = { ...parsed, data: { ...parsed.data, run } };
+  const serialized = JSON.stringify(bounded);
+  if (new TextEncoder().encode(serialized).byteLength > maxBytes) {
+    throw new Error("Webhook envelope exceeds payload limit without output");
+  }
+  return WebhookEventEnvelopeSchema.parse(bounded);
+}
+function getWebhookDestinationUrlError(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return "Enter a valid HTTPS URL.";
+  const result = WebhookDestinationUrlSchema.safeParse(trimmed);
+  if (result.success)
+    return null;
+  return result.error.issues[0]?.message ?? "Enter a valid HTTPS URL.";
+}
+function validateWebhookHeaderCollection(input, ctx) {
+  if (input.customHeaders) {
+    const seen = new Set;
+    let bytes = 0;
+    input.customHeaders.forEach((header, index) => {
+      const normalized = header.name.toLowerCase();
+      if (seen.has(normalized)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["customHeaders", index, "name"],
+          message: "Duplicate webhook header"
+        });
+      }
+      seen.add(normalized);
+      bytes += new TextEncoder().encode(header.name + ("value" in header ? header.value : "")).byteLength;
+    });
+    if (bytes > WEBHOOK_MAX_HEADER_BYTES) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["customHeaders"],
+        message: "Custom webhook headers are too large"
+      });
+    }
+  }
+}
+var WEBHOOK_API_VERSION = "2026-07-01", WEBHOOK_NOTIFY_CHANNEL = "eigenpal:webhooks", WEBHOOK_MAX_PAYLOAD_BYTES, WEBHOOK_MAX_HEADERS = 20, WEBHOOK_MAX_HEADER_BYTES, WEBHOOK_EVENT_TYPES, WEBHOOK_DELIVERY_STATES, WEBHOOK_RESERVED_HEADERS, RESERVED_HEADER_SET, WebhookEventTypeSchema, WebhookDeliveryStateSchema, WebhookEndpointIdSchema, WebhookEventIdSchema, WebhookDeliveryIdSchema, WebhookAttemptIdSchema, HeaderNameSchema, WebhookCustomHeaderSchema, RetainedWebhookCustomHeaderSchema, RedactedWebhookCustomHeaderSchema, PublicWebhookRunSchema, EnvelopeBaseSchema, RunCreatedWebhookEventSchema, RunStatusChangedWebhookEventSchema, WebhookEventEnvelopeSchema, WebhookEndpointSchema, WebhookDestinationUrlSchema, CreateWebhookEndpointSchema, UpdateWebhookEndpointSchema, CreateWebhookEndpointResponseSchema, WebhookDeliverySchema, WebhookDeliveryAttemptSchema;
+var init_webhooks = __esm(() => {
+  init_zod();
+  init_execution_row();
+  WEBHOOK_MAX_PAYLOAD_BYTES = 1024 * 1024;
+  WEBHOOK_MAX_HEADER_BYTES = 16 * 1024;
+  WEBHOOK_EVENT_TYPES = ["run.created", "run.status_changed"];
+  WEBHOOK_DELIVERY_STATES = [
+    "pending",
+    "processing",
+    "succeeded",
+    "failed",
+    "cancelled"
+  ];
+  WEBHOOK_RESERVED_HEADERS = [
+    "connection",
+    "content-length",
+    "content-type",
+    "host",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+    "user-agent",
+    "webhook-id",
+    "webhook-signature",
+    "webhook-timestamp"
+  ];
+  RESERVED_HEADER_SET = new Set(WEBHOOK_RESERVED_HEADERS);
+  WebhookEventTypeSchema = exports_external.enum(WEBHOOK_EVENT_TYPES);
+  WebhookDeliveryStateSchema = exports_external.enum(WEBHOOK_DELIVERY_STATES);
+  WebhookEndpointIdSchema = exports_external.string().regex(/^whep_[A-Za-z0-9_-]+$/);
+  WebhookEventIdSchema = exports_external.string().regex(/^whev_[A-Za-z0-9_-]+$/);
+  WebhookDeliveryIdSchema = exports_external.string().regex(/^whdl_[A-Za-z0-9_-]+$/);
+  WebhookAttemptIdSchema = exports_external.string().regex(/^what_[A-Za-z0-9_-]+$/);
+  HeaderNameSchema = exports_external.string().min(1).max(128).regex(/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/);
+  WebhookCustomHeaderSchema = exports_external.object({
+    name: HeaderNameSchema.refine((name) => !RESERVED_HEADER_SET.has(name.toLowerCase()) && !name.toLowerCase().startsWith("webhook-"), { message: "Reserved webhook header" }),
+    value: exports_external.string().min(1).max(8192).refine((value) => !/[\r\n]/.test(value), {
+      message: "Header values cannot contain CR or LF"
+    })
+  });
+  RetainedWebhookCustomHeaderSchema = exports_external.object({
+    name: WebhookCustomHeaderSchema.shape.name,
+    retained: exports_external.literal(true)
+  });
+  RedactedWebhookCustomHeaderSchema = exports_external.object({
+    name: HeaderNameSchema,
+    configured: exports_external.literal(true)
+  });
+  PublicWebhookRunSchema = exports_external.object({
+    id: exports_external.string().min(1),
+    automationId: exports_external.string().min(1),
+    type: exports_external.enum(["workflow", "agent"]),
+    status: exports_external.enum(EXECUTION_STATUSES),
+    triggerType: exports_external.string(),
+    createdAt: exports_external.string().datetime(),
+    startedAt: exports_external.string().datetime().nullable(),
+    completedAt: exports_external.string().datetime().nullable(),
+    output: exports_external.unknown().optional(),
+    outputOmitted: exports_external.boolean().optional()
+  });
+  EnvelopeBaseSchema = exports_external.object({
+    id: WebhookEventIdSchema,
+    apiVersion: exports_external.literal(WEBHOOK_API_VERSION),
+    createdAt: exports_external.string().datetime(),
+    test: exports_external.boolean().default(false)
+  });
+  RunCreatedWebhookEventSchema = EnvelopeBaseSchema.extend({
+    type: exports_external.literal("run.created"),
+    data: exports_external.object({ run: PublicWebhookRunSchema })
+  });
+  RunStatusChangedWebhookEventSchema = EnvelopeBaseSchema.extend({
+    type: exports_external.literal("run.status_changed"),
+    data: exports_external.object({
+      run: PublicWebhookRunSchema,
+      previousStatus: exports_external.enum(EXECUTION_STATUSES),
+      currentStatus: exports_external.enum(EXECUTION_STATUSES)
+    })
+  });
+  WebhookEventEnvelopeSchema = exports_external.discriminatedUnion("type", [
+    RunCreatedWebhookEventSchema,
+    RunStatusChangedWebhookEventSchema
+  ]);
+  WebhookEndpointSchema = exports_external.object({
+    id: WebhookEndpointIdSchema,
+    tenantId: exports_external.string(),
+    name: exports_external.string().min(1).max(200),
+    url: exports_external.string().url(),
+    eventTypes: exports_external.array(WebhookEventTypeSchema).min(1),
+    enabled: exports_external.boolean(),
+    signingConfigured: exports_external.literal(true),
+    customHeaders: exports_external.array(RedactedWebhookCustomHeaderSchema),
+    createdBy: exports_external.string().nullable(),
+    createdAt: exports_external.coerce.date(),
+    updatedAt: exports_external.coerce.date(),
+    deletedAt: exports_external.coerce.date().nullable()
+  });
+  WebhookDestinationUrlSchema = exports_external.string().url().superRefine((raw, ctx) => {
+    if (!URL.canParse(raw))
+      return;
+    const url2 = new URL(raw);
+    if (url2.protocol !== "https:") {
+      ctx.addIssue({ code: "custom", message: "Webhook URLs must use HTTPS" });
+    }
+    if (url2.username || url2.password) {
+      ctx.addIssue({ code: "custom", message: "Webhook URLs cannot contain credentials" });
+    }
+    if (url2.hash) {
+      ctx.addIssue({ code: "custom", message: "Webhook URLs cannot contain fragments" });
+    }
+  });
+  CreateWebhookEndpointSchema = exports_external.object({
+    name: exports_external.string().trim().min(1).max(200),
+    url: WebhookDestinationUrlSchema,
+    eventTypes: exports_external.array(WebhookEventTypeSchema).min(1),
+    customHeaders: exports_external.array(WebhookCustomHeaderSchema).max(WEBHOOK_MAX_HEADERS).default([])
+  }).superRefine(validateWebhookHeaderCollection);
+  UpdateWebhookEndpointSchema = exports_external.object({
+    name: exports_external.string().trim().min(1).max(200).optional(),
+    url: WebhookDestinationUrlSchema.optional(),
+    eventTypes: exports_external.array(WebhookEventTypeSchema).min(1).optional(),
+    customHeaders: exports_external.array(exports_external.union([WebhookCustomHeaderSchema, RetainedWebhookCustomHeaderSchema])).max(WEBHOOK_MAX_HEADERS).optional(),
+    enabled: exports_external.boolean().optional()
+  }).superRefine(validateWebhookHeaderCollection);
+  CreateWebhookEndpointResponseSchema = exports_external.object({
+    endpoint: WebhookEndpointSchema,
+    signingSecret: exports_external.string().regex(/^whsec_[A-Za-z0-9_-]+$/)
+  });
+  WebhookDeliverySchema = exports_external.object({
+    id: WebhookDeliveryIdSchema,
+    tenantId: exports_external.string(),
+    endpointId: WebhookEndpointIdSchema,
+    eventId: WebhookEventIdSchema,
+    state: WebhookDeliveryStateSchema,
+    attemptCount: exports_external.number().int().nonnegative(),
+    nextAttemptAt: exports_external.coerce.date().nullable(),
+    latestStatusCode: exports_external.number().int().nullable(),
+    latestErrorCategory: exports_external.string().nullable(),
+    createdAt: exports_external.coerce.date(),
+    completedAt: exports_external.coerce.date().nullable()
+  });
+  WebhookDeliveryAttemptSchema = exports_external.object({
+    id: WebhookAttemptIdSchema,
+    deliveryId: WebhookDeliveryIdSchema,
+    attemptNumber: exports_external.number().int().positive(),
+    startedAt: exports_external.coerce.date(),
+    completedAt: exports_external.coerce.date(),
+    latencyMs: exports_external.number().int().nonnegative(),
+    statusCode: exports_external.number().int().nullable(),
+    errorCategory: exports_external.string().nullable(),
+    responseExcerpt: exports_external.string().nullable()
+  });
+});
+
 // ../types/src/storage/s3-paths.ts
 function assertSegment(name, value) {
   if (!value || !SEGMENT_RX.test(value)) {
@@ -66109,11 +68764,11 @@ function walkGrammar(node, parts) {
   }
   return current;
 }
-function normalizeTemplate(template) {
-  return template.endsWith("/") ? template.slice(0, -1) : template;
+function normalizeTemplate(template2) {
+  return template2.endsWith("/") ? template2.slice(0, -1) : template2;
 }
-function renderTemplate(template, params) {
-  return normalizeTemplate(template).split("/").flatMap((part) => {
+function renderTemplate(template2, params) {
+  return normalizeTemplate(template2).split("/").flatMap((part) => {
     if (!part.startsWith(":")) {
       return [part];
     }
@@ -66123,36 +68778,36 @@ function renderTemplate(template, params) {
       throw new Error(`Missing S3 path parameter: ${part}`);
     }
     if (name === "path") {
-      return value.split("/").map((segment) => assertSegment("path", segment));
+      return value.split("/").map((segment2) => assertSegment("path", segment2));
     }
     return [assertSegment(String(name), value)];
   });
 }
-function buildS3Path(tenantId, template, params) {
+function buildS3Path(tenantId, template2, params) {
   const tenant = assertSegment("tenantId", tenantId);
-  const parts = renderTemplate(template, params);
+  const parts = renderTemplate(template2, params);
   const node = walkGrammar(S3_PATH_GRAMMAR, parts);
-  if (template.endsWith("/") && node === PATH_LEAF) {
-    throw new Error(`S3 path leaf cannot have a trailing slash: ${JSON.stringify(template)}`);
+  if (template2.endsWith("/") && node === PATH_LEAF) {
+    throw new Error(`S3 path leaf cannot have a trailing slash: ${JSON.stringify(template2)}`);
   }
   const path = ["tenants", tenant, ...parts].join("/");
-  return template.endsWith("/") ? `${path}/` : path;
+  return template2.endsWith("/") ? `${path}/` : path;
 }
-function buildS3PathSuffix(template, params) {
-  const parts = renderTemplate(template, params);
+function buildS3PathSuffix(template2, params) {
+  const parts = renderTemplate(template2, params);
   const node = walkGrammar(S3_PATH_GRAMMAR, parts);
-  if (template.endsWith("/") && node === PATH_LEAF) {
-    throw new Error(`S3 path leaf cannot have a trailing slash: ${JSON.stringify(template)}`);
+  if (template2.endsWith("/") && node === PATH_LEAF) {
+    throw new Error(`S3 path leaf cannot have a trailing slash: ${JSON.stringify(template2)}`);
   }
   const path = parts.join("/");
-  return template.endsWith("/") ? `${path}/` : path;
+  return template2.endsWith("/") ? `${path}/` : path;
 }
 function stripTenantPrefix(key) {
   return key.replace(TENANT_PREFIX_RX, "");
 }
-function matchS3Path(template, key) {
+function matchS3Path(template2, key) {
   const keyParts = stripTenantPrefix(key).split("/");
-  const templateParts = normalizeTemplate(template).split("/");
+  const templateParts = normalizeTemplate(template2).split("/");
   const params = {};
   let keyIndex = 0;
   for (let templateIndex = 0;templateIndex < templateParts.length; templateIndex += 1) {
@@ -66171,7 +68826,7 @@ function matchS3Path(template, key) {
       if (rest.length === 0)
         return null;
       try {
-        params.path = rest.map((segment) => assertSegment("path", segment)).join("/");
+        params.path = rest.map((segment2) => assertSegment("path", segment2)).join("/");
         walkGrammar(S3_PATH_GRAMMAR, keyParts);
       } catch {
         return null;
@@ -66205,23 +68860,23 @@ function createBuilder(grammarNode, prefixSegments, boundTenantId) {
     }
     return assertSegment("tenantId", tenantId);
   };
-  const build = (template, params) => {
+  const build = (template2, params) => {
     const tenant = resolveTenantId(params);
-    const parts = renderTemplate(template, params ?? {});
+    const parts = renderTemplate(template2, params ?? {});
     const node = walkGrammar(grammarNode, parts);
-    if (template.endsWith("/") && node === PATH_LEAF) {
-      throw new Error(`S3 path leaf cannot have a trailing slash: ${JSON.stringify(template)}`);
+    if (template2.endsWith("/") && node === PATH_LEAF) {
+      throw new Error(`S3 path leaf cannot have a trailing slash: ${JSON.stringify(template2)}`);
     }
     const path = ["tenants", tenant, ...prefixSegments, ...parts].join("/");
-    return template.endsWith("/") ? `${path}/` : path;
+    return template2.endsWith("/") ? `${path}/` : path;
   };
   const builder = build;
-  builder.at = (template, params) => {
+  builder.at = (template2, params) => {
     const tenant = resolveTenantId(params);
-    const parts = renderTemplate(template, params ?? {});
+    const parts = renderTemplate(template2, params ?? {});
     const nextNode = walkGrammar(grammarNode, parts);
-    if (template.endsWith("/") && nextNode === PATH_LEAF) {
-      throw new Error(`S3 path leaf cannot have a trailing slash: ${JSON.stringify(template)}`);
+    if (template2.endsWith("/") && nextNode === PATH_LEAF) {
+      throw new Error(`S3 path leaf cannot have a trailing slash: ${JSON.stringify(template2)}`);
     }
     return createBuilder(nextNode, [...prefixSegments, ...parts], tenant);
   };
@@ -66413,6 +69068,7 @@ __export(exports_src, {
   stripTenantPrefix: () => stripTenantPrefix,
   stringToUnitInterval: () => stringToUnitInterval,
   sourceLockfileInputHash: () => sourceLockfileInputHash,
+  serializeWebhookEvent: () => serializeWebhookEvent,
   scriptParamTypeAlias: () => scriptParamTypeAlias,
   schemaFileUploadMatchesField: () => schemaFileUploadMatchesField,
   s3PathFilename: () => s3PathFilename,
@@ -66482,6 +69138,7 @@ __export(exports_src, {
   hasTriggerMethod: () => hasTriggerMethod,
   hasDeclaredOutput: () => hasDeclaredOutput,
   goldenFileSatisfiedInResult: () => goldenFileSatisfiedInResult,
+  getWebhookDestinationUrlError: () => getWebhookDestinationUrlError,
   getTriggerMethods: () => getTriggerMethods,
   getSupportedFormatsLabel: () => getSupportedFormatsLabel,
   getStepSchema: () => getStepSchema,
@@ -66539,6 +69196,7 @@ __export(exports_src, {
   buildS3Path: () => buildS3Path,
   buildDiscreteJudgeSystemPrompt: () => buildDiscreteJudgeSystemPrompt,
   buildContinuousJudgeSystemPrompt: () => buildContinuousJudgeSystemPrompt,
+  boundWebhookEventOutput: () => boundWebhookEventOutput,
   assertS3PathSegment: () => assertS3PathSegment,
   aliasReplyConfigSchema: () => aliasReplyConfigSchema,
   aggregateEvaluatorCompositionScore: () => aggregateEvaluatorCompositionScore,
@@ -66561,11 +69219,31 @@ __export(exports_src, {
   WorkflowExecutionStatusSchema: () => WorkflowExecutionStatusSchema,
   WorkflowExecutionSchema: () => WorkflowExecutionSchema,
   WorkflowDefinitionSchema: () => WorkflowDefinitionSchema,
+  WebhookEventTypeSchema: () => WebhookEventTypeSchema,
+  WebhookEventIdSchema: () => WebhookEventIdSchema,
+  WebhookEventEnvelopeSchema: () => WebhookEventEnvelopeSchema,
+  WebhookEndpointSchema: () => WebhookEndpointSchema,
+  WebhookEndpointIdSchema: () => WebhookEndpointIdSchema,
+  WebhookDeliveryStateSchema: () => WebhookDeliveryStateSchema,
+  WebhookDeliverySchema: () => WebhookDeliverySchema,
+  WebhookDeliveryIdSchema: () => WebhookDeliveryIdSchema,
+  WebhookDeliveryAttemptSchema: () => WebhookDeliveryAttemptSchema,
+  WebhookCustomHeaderSchema: () => WebhookCustomHeaderSchema,
+  WebhookAttemptIdSchema: () => WebhookAttemptIdSchema,
   WaitStepSchema: () => WaitStepSchema,
   WORKFLOW_TOOL_METADATA: () => WORKFLOW_TOOL_METADATA,
   WORKFLOW_NAME_PATTERN: () => WORKFLOW_NAME_PATTERN,
   WORKFLOW_FILE_REF_JSON_SCHEMA: () => WORKFLOW_FILE_REF_JSON_SCHEMA,
   WORKFLOW_EXECUTION_STATUSES: () => WORKFLOW_EXECUTION_STATUSES,
+  WEBHOOK_RESERVED_HEADERS: () => WEBHOOK_RESERVED_HEADERS,
+  WEBHOOK_NOTIFY_CHANNEL: () => WEBHOOK_NOTIFY_CHANNEL,
+  WEBHOOK_MAX_PAYLOAD_BYTES: () => WEBHOOK_MAX_PAYLOAD_BYTES,
+  WEBHOOK_MAX_HEADER_BYTES: () => WEBHOOK_MAX_HEADER_BYTES,
+  WEBHOOK_MAX_HEADERS: () => WEBHOOK_MAX_HEADERS,
+  WEBHOOK_EVENT_TYPES: () => WEBHOOK_EVENT_TYPES,
+  WEBHOOK_DELIVERY_STATES: () => WEBHOOK_DELIVERY_STATES,
+  WEBHOOK_API_VERSION: () => WEBHOOK_API_VERSION,
+  UpdateWebhookEndpointSchema: () => UpdateWebhookEndpointSchema,
   UNSUPPORTED_SOURCE_MANIFEST_FILENAME: () => UNSUPPORTED_SOURCE_MANIFEST_FILENAME,
   TriggerTypeValue: () => TriggerTypeValue,
   TriggerTypeSchema: () => TriggerTypeSchema,
@@ -66617,7 +69295,7 @@ __export(exports_src, {
   SplitConfigSchema: () => SplitConfigSchema,
   SpanTypes: () => SpanTypes,
   SpanKindMap: () => SpanKindMap,
-  SpanKind: () => SpanKind,
+  SpanKind: () => import_api.SpanKind,
   SourceVersionRefSchema: () => SourceVersionRefSchema,
   SourceSecretsFileSchema: () => SourceSecretsFileSchema,
   SourcePackageTypeSchema: () => SourcePackageTypeSchema,
@@ -66658,6 +69336,8 @@ __export(exports_src, {
   RunTargetStringSchema: () => RunTargetStringSchema,
   RunTargetSchema: () => RunTargetSchema,
   RunTargetObjectSchema: () => RunTargetObjectSchema,
+  RunStatusChangedWebhookEventSchema: () => RunStatusChangedWebhookEventSchema,
+  RunCreatedWebhookEventSchema: () => RunCreatedWebhookEventSchema,
   RootSourceManifestSchema: () => RootSourceManifestSchema,
   RetryTerminalReasonSchema: () => RetryTerminalReasonSchema,
   RetryPolicySourceSchema: () => RetryPolicySourceSchema,
@@ -66666,11 +69346,13 @@ __export(exports_src, {
   ResolvedRetryPolicySchema: () => ResolvedRetryPolicySchema,
   ResolvedProcessorFileSchema: () => ResolvedProcessorFileSchema,
   ReleaseTagSchema: () => ReleaseTagSchema,
+  RedactedWebhookCustomHeaderSchema: () => RedactedWebhookCustomHeaderSchema,
   RUN_TARGET_SEGMENT_PATTERN: () => RUN_TARGET_SEGMENT_PATTERN,
   RUN_EXPAND_SECTIONS: () => RUN_EXPAND_SECTIONS,
   RUN_DETAIL_EXPAND_PRESET: () => RUN_DETAIL_EXPAND_PRESET,
   RUNS_TRIGGERED_BY_SYSTEM: () => RUNS_TRIGGERED_BY_SYSTEM,
   RERUN_ORIGINAL_VERSION: () => RERUN_ORIGINAL_VERSION,
+  PublicWebhookRunSchema: () => PublicWebhookRunSchema,
   ProcessorPortSchema: () => ProcessorPortSchema,
   ProcessorExecutionContextSchema: () => ProcessorExecutionContextSchema,
   ProcessorDefinitionSchema: () => ProcessorDefinitionSchema,
@@ -66730,7 +69412,7 @@ __export(exports_src, {
   GPFS_FILE_SOURCE_DESCRIPTOR: () => GPFS_FILE_SOURCE_DESCRIPTOR,
   ForeachStepSchema: () => ForeachStepSchema,
   FileReferenceSentinelSchema: () => FileReferenceSentinelSchema,
-  FilePathDescriptorSchema: () => FilePathDescriptorSchema2,
+  FilePathDescriptorSchema: () => FilePathDescriptorSchema,
   FileIngressRefSchema: () => FileIngressRefSchema,
   FileIdIngressRefSchema: () => FileIdIngressRefSchema,
   FailStepSchema: () => FailStepSchema,
@@ -66803,6 +69485,8 @@ __export(exports_src, {
   DATASET_NAME_PATTERN: () => DATASET_NAME_PATTERN,
   CustomScriptConfigSchema: () => CustomScriptConfigSchema,
   CreateWorkflowDefinitionSchema: () => CreateWorkflowDefinitionSchema,
+  CreateWebhookEndpointSchema: () => CreateWebhookEndpointSchema,
+  CreateWebhookEndpointResponseSchema: () => CreateWebhookEndpointResponseSchema,
   CoordinateUnitSchema: () => CoordinateUnitSchema,
   ControlWaitOutputSchema: () => ControlWaitOutputSchema,
   ControlWaitConfigSchema: () => ControlWaitConfigSchema,
@@ -66851,8 +69535,8 @@ var init_src = __esm(() => {
   init_legacy_boundary();
   init_runtime_file_ref();
   init_scoped_file_ref();
-  init_processor();
-  init_parser();
+  init_processor2();
+  init_parser2();
   init_otel();
   init_execution_row();
   init_run_expand();
@@ -66864,6 +69548,7 @@ var init_src = __esm(() => {
   init_eval();
   init_git_source();
   init_triggers();
+  init_webhooks();
   init_typed_script();
 });
 
@@ -67765,7 +70450,7 @@ var require_foldFlowLines = __commonJS((exports) => {
       else
         end = lineWidth - indentAtStart;
     }
-    let split2 = undefined;
+    let split3 = undefined;
     let prev = undefined;
     let overflow = false;
     let i = -1;
@@ -67799,20 +70484,20 @@ var require_foldFlowLines = __commonJS((exports) => {
         if (mode === FOLD_BLOCK)
           i = consumeMoreIndentedLines(text, i, indent.length);
         end = i + indent.length + endStep;
-        split2 = undefined;
+        split3 = undefined;
       } else {
         if (ch === " " && prev && prev !== " " && prev !== `
 ` && prev !== "\t") {
           const next = text[i + 1];
           if (next && next !== " " && next !== `
 ` && next !== "\t")
-            split2 = i;
+            split3 = i;
         }
         if (i >= end) {
-          if (split2) {
-            folds.push(split2);
-            end = split2 + endStep;
-            split2 = undefined;
+          if (split3) {
+            folds.push(split3);
+            end = split3 + endStep;
+            split3 = undefined;
           } else if (mode === FOLD_QUOTED) {
             while (prev === " " || prev === "\t") {
               prev = ch;
@@ -67825,7 +70510,7 @@ var require_foldFlowLines = __commonJS((exports) => {
             folds.push(j);
             escapedFolds[j] = true;
             end = j + endStep;
-            split2 = undefined;
+            split3 = undefined;
           } else {
             overflow = true;
           }
@@ -68459,7 +71144,7 @@ var require_merge = __commonJS((exports) => {
   var identity = require_identity();
   var Scalar = require_Scalar();
   var MERGE_KEY = "<<";
-  var merge2 = {
+  var merge3 = {
     identify: (value) => value === MERGE_KEY || typeof value === "symbol" && value.description === MERGE_KEY,
     default: "key",
     tag: "tag:yaml.org,2002:merge",
@@ -68469,7 +71154,7 @@ var require_merge = __commonJS((exports) => {
     }),
     stringify: () => MERGE_KEY
   };
-  var isMergeKey = (ctx, key) => (merge2.identify(key) || identity.isScalar(key) && (!key.type || key.type === Scalar.Scalar.PLAIN) && merge2.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge2.tag && tag.default);
+  var isMergeKey = (ctx, key) => (merge3.identify(key) || identity.isScalar(key) && (!key.type || key.type === Scalar.Scalar.PLAIN) && merge3.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge3.tag && tag.default);
   function addMergeToJSMap(ctx, map2, value) {
     const source = resolveAliasValue(ctx, value);
     if (identity.isSeq(source))
@@ -68508,21 +71193,21 @@ var require_merge = __commonJS((exports) => {
   }
   exports.addMergeToJSMap = addMergeToJSMap;
   exports.isMergeKey = isMergeKey;
-  exports.merge = merge2;
+  exports.merge = merge3;
 });
 
 // ../../node_modules/yaml/dist/nodes/addPairToJSMap.js
 var require_addPairToJSMap = __commonJS((exports) => {
   var log = require_log();
-  var merge2 = require_merge();
+  var merge3 = require_merge();
   var stringify = require_stringify();
   var identity = require_identity();
   var toJS = require_toJS();
   function addPairToJSMap(ctx, map2, { key, value }) {
     if (identity.isNode(key) && key.addToJSMap)
       key.addToJSMap(ctx, map2, value);
-    else if (merge2.isMergeKey(ctx, key))
-      merge2.addMergeToJSMap(ctx, map2, value);
+    else if (merge3.isMergeKey(ctx, key))
+      merge3.addMergeToJSMap(ctx, map2, value);
     else {
       const jsKey = toJS.toJS(key, "", ctx);
       if (map2 instanceof Map) {
@@ -69798,7 +72483,7 @@ var require_schema3 = __commonJS((exports) => {
   var bool = require_bool2();
   var float = require_float2();
   var int2 = require_int2();
-  var merge2 = require_merge();
+  var merge3 = require_merge();
   var omap = require_omap();
   var pairs = require_pairs();
   var set2 = require_set();
@@ -69818,7 +72503,7 @@ var require_schema3 = __commonJS((exports) => {
     float.floatExp,
     float.float,
     binary.binary,
-    merge2.merge,
+    merge3.merge,
     omap.omap,
     pairs.pairs,
     set2.set,
@@ -69841,7 +72526,7 @@ var require_tags = __commonJS((exports) => {
   var schema = require_schema();
   var schema$1 = require_schema2();
   var binary = require_binary();
-  var merge2 = require_merge();
+  var merge3 = require_merge();
   var omap = require_omap();
   var pairs = require_pairs();
   var schema$2 = require_schema3();
@@ -69866,7 +72551,7 @@ var require_tags = __commonJS((exports) => {
     intOct: int2.intOct,
     intTime: timestamp.intTime,
     map: map2.map,
-    merge: merge2.merge,
+    merge: merge3.merge,
     null: _null4.nullTag,
     omap: omap.omap,
     pairs: pairs.pairs,
@@ -69876,7 +72561,7 @@ var require_tags = __commonJS((exports) => {
   };
   var coreKnownTags = {
     "tag:yaml.org,2002:binary": binary.binary,
-    "tag:yaml.org,2002:merge": merge2.merge,
+    "tag:yaml.org,2002:merge": merge3.merge,
     "tag:yaml.org,2002:omap": omap.omap,
     "tag:yaml.org,2002:pairs": pairs.pairs,
     "tag:yaml.org,2002:set": set2.set,
@@ -69885,7 +72570,7 @@ var require_tags = __commonJS((exports) => {
   function getTags(customTags, schemaName, addMergeTag) {
     const schemaTags = schemas3.get(schemaName);
     if (schemaTags && !customTags) {
-      return addMergeTag && !schemaTags.includes(merge2.merge) ? schemaTags.concat(merge2.merge) : schemaTags.slice();
+      return addMergeTag && !schemaTags.includes(merge3.merge) ? schemaTags.concat(merge3.merge) : schemaTags.slice();
     }
     let tags = schemaTags;
     if (!tags) {
@@ -69903,7 +72588,7 @@ var require_tags = __commonJS((exports) => {
       tags = customTags(tags.slice());
     }
     if (addMergeTag)
-      tags = tags.concat(merge2.merge);
+      tags = tags.concat(merge3.merge);
     return tags.reduce((tags2, tag) => {
       const tagObj = typeof tag === "string" ? tagsByName[tag] : tag;
       if (!tagObj) {
@@ -69930,11 +72615,11 @@ var require_Schema = __commonJS((exports) => {
   var sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
 
   class Schema {
-    constructor({ compat: compat2, customTags, merge: merge2, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
+    constructor({ compat: compat2, customTags, merge: merge3, resolveKnownTags, schema, sortMapEntries, toStringDefaults }) {
       this.compat = Array.isArray(compat2) ? tags.getTags(compat2, "compat") : compat2 ? tags.getTags(null, compat2) : null;
       this.name = typeof schema === "string" && schema || "core";
       this.knownTags = resolveKnownTags ? tags.coreKnownTags : {};
-      this.tags = tags.getTags(customTags, this.name, merge2);
+      this.tags = tags.getTags(customTags, this.name, merge3);
       this.toStringOptions = toStringDefaults ?? null;
       Object.defineProperty(this, identity.MAP, { value: map2.map });
       Object.defineProperty(this, identity.SCALAR, { value: string4.string });
@@ -71157,13 +73842,13 @@ var require_resolve_block_scalar = __commonJS((exports) => {
     return { mode, indent, chomp, comment, length };
   }
   function splitLines(source) {
-    const split2 = source.split(/\n( *)/);
-    const first = split2[0];
+    const split3 = source.split(/\n( *)/);
+    const first = split3[0];
     const m = first.match(/^( *)/);
     const line0 = m?.[1] ? [m[1], first.slice(m[1].length)] : ["", first];
     const lines = [line0];
-    for (let i = 1;i < split2.length; i += 2)
-      lines.push([split2[i], split2[i + 1]]);
+    for (let i = 1;i < split3.length; i += 2)
+      lines.push([split3[i], split3[i + 1]]);
     return lines;
   }
   exports.resolveBlockScalar = resolveBlockScalar;
@@ -74177,7 +76862,7 @@ var init_main = __esm(() => {
 });
 
 // ../../node_modules/sisteransi/src/index.js
-var require_src = __commonJS((exports, module) => {
+var require_src2 = __commonJS((exports, module) => {
   var ESC2 = "\x1B";
   var CSI2 = `${ESC2}[`;
   var beep = "\x07";
@@ -74520,7 +77205,7 @@ var import_sisteransi, G, K, h, Y, k, A = (r) => ("columns" in r) && typeof r.co
 }, Q, X, Z, et, it, rt, nt, ot, ut, at, ht;
 var init_dist3 = __esm(() => {
   init_main();
-  import_sisteransi = __toESM(require_src(), 1);
+  import_sisteransi = __toESM(require_src2(), 1);
   G = ["up", "down", "left", "right", "space", "enter", "cancel"];
   K = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
   h = { actions: new Set(G), aliases: new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["\x03", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true, date: { monthNames: [...K], messages: { required: "Please enter a valid date", invalidMonth: "There are only 12 months in a year", invalidDay: (r, t) => `There are only ${r} days in ${t}`, afterMin: (r) => `Date must be on or after ${r.toISOString().slice(0, 10)}`, beforeMax: (r) => `Date must be on or before ${r.toISOString().slice(0, 10)}` } } };
@@ -75863,7 +78548,7 @@ var init_dist4 = __esm(() => {
   init_dist3();
   init_main();
   init_dist2();
-  import_sisteransi2 = __toESM(require_src(), 1);
+  import_sisteransi2 = __toESM(require_src2(), 1);
   tt2 = te();
   _t = w2("◆", "*");
   ot2 = w2("■", "x");
@@ -169355,7 +172040,7 @@ var require3, __filename2, __dirname2, __create2, __defProp3, __getOwnPropDesc,
         __defProp3(to5, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to5;
-}, __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target, mod)), require_array, require_errno, require_fs, require_path, require_is_extglob, require_is_glob, require_glob_parent, require_utils2, require_stringify2, require_is_number, require_to_regex_range, require_fill_range, require_compile2, require_expand, require_constants, require_parse, require_braces, require_constants2, require_utils22, require_scan, require_parse2, require_picomatch, require_picomatch2, require_micromatch, require_pattern2, require_merge2, require_stream, require_string2, require_utils3, require_tasks, require_async, require_sync, require_fs2, require_settings, require_out, require_queue_microtask, require_run_parallel, require_constants3, require_fs3, require_utils4, require_common, require_async2, require_sync2, require_fs4, require_settings2, require_out2, require_reusify, require_queue, require_common2, require_reader, require_async3, require_async4, require_stream2, require_sync3, require_sync4, require_settings3, require_out3, require_reader2, require_stream3, require_async5, require_matcher, require_partial, require_deep, require_entry, require_error2, require_entry2, require_provider, require_async6, require_stream4, require_sync5, require_sync6, require_settings4, require_out4, require_picocolors2, require_debug, require_constants4, require_re, require_parse_options, require_identifiers, require_semver, require_compare, require_gte, require_pseudomap, require_map2, require_yallist, require_lru_cache, require_sigmund, require_fnmatch, require_ini, require_package, require_src2, require_js_tokens, require_readlines, require_ignore, index_exports, Diff = class {
+}, __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target, mod)), require_array, require_errno, require_fs, require_path, require_is_extglob, require_is_glob, require_glob_parent, require_utils4, require_stringify2, require_is_number, require_to_regex_range, require_fill_range, require_compile2, require_expand, require_constants, require_parse, require_braces, require_constants2, require_utils22, require_scan, require_parse2, require_picomatch, require_picomatch2, require_micromatch, require_pattern2, require_merge2, require_stream, require_string2, require_utils32, require_tasks, require_async, require_sync, require_fs2, require_settings, require_out, require_queue_microtask, require_run_parallel, require_constants3, require_fs3, require_utils42, require_common, require_async2, require_sync2, require_fs4, require_settings2, require_out2, require_reusify, require_queue, require_common2, require_reader, require_async3, require_async4, require_stream2, require_sync3, require_sync4, require_settings3, require_out3, require_reader2, require_stream3, require_async5, require_matcher, require_partial, require_deep, require_entry, require_error2, require_entry2, require_provider, require_async6, require_stream4, require_sync5, require_sync6, require_settings4, require_out4, require_picocolors2, require_debug, require_constants4, require_re, require_parse_options, require_identifiers, require_semver2, require_compare, require_gte, require_pseudomap, require_map2, require_yallist, require_lru_cache, require_sigmund, require_fnmatch, require_ini, require_package, require_src3, require_js_tokens, require_readlines, require_ignore, index_exports, Diff = class {
   diff(oldStr, newStr, options8 = {}) {
     let callback;
     if (typeof options8 === "function") {
@@ -170377,7 +173062,7 @@ var init_prettier = __esm(() => {
       };
     }
   });
-  require_utils2 = __commonJS2({
+  require_utils4 = __commonJS2({
     "node_modules/braces/lib/utils.js"(exports) {
       exports.isInteger = (num) => {
         if (typeof num === "number") {
@@ -170466,7 +173151,7 @@ var init_prettier = __esm(() => {
   });
   require_stringify2 = __commonJS2({
     "node_modules/braces/lib/stringify.js"(exports, module) {
-      var utils2 = require_utils2();
+      var utils2 = require_utils4();
       module.exports = (ast, options8 = {}) => {
         const stringify2 = (node, parent = {}) => {
           const invalidBlock = options8.escapeInvalid && utils2.isInvalidBrace(parent);
@@ -170920,7 +173605,7 @@ var init_prettier = __esm(() => {
   require_compile2 = __commonJS2({
     "node_modules/braces/lib/compile.js"(exports, module) {
       var fill2 = require_fill_range();
-      var utils2 = require_utils2();
+      var utils2 = require_utils4();
       var compile = (ast, options8 = {}) => {
         const walk2 = (node, parent = {}) => {
           const invalidBlock = utils2.isInvalidBrace(parent);
@@ -170970,7 +173655,7 @@ var init_prettier = __esm(() => {
     "node_modules/braces/lib/expand.js"(exports, module) {
       var fill2 = require_fill_range();
       var stringify2 = require_stringify2();
-      var utils2 = require_utils2();
+      var utils2 = require_utils4();
       var append = (queue = "", stash = "", enclose = false) => {
         const result = [];
         queue = [].concat(queue);
@@ -173169,8 +175854,8 @@ var init_prettier = __esm(() => {
       var Stream = __require2("stream");
       var PassThrough = Stream.PassThrough;
       var slice = Array.prototype.slice;
-      module.exports = merge2;
-      function merge2() {
+      module.exports = merge22;
+      function merge22() {
         const streamsQueue = [];
         const args = slice.call(arguments);
         let merging = false;
@@ -173284,9 +175969,9 @@ var init_prettier = __esm(() => {
     "node_modules/fast-glob/out/utils/stream.js"(exports) {
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.merge = undefined;
-      var merge2 = require_merge2();
+      var merge22 = require_merge2();
       function merge3(streams) {
-        const mergedStream = merge2(streams);
+        const mergedStream = merge22(streams);
         streams.forEach((stream) => {
           stream.once("error", (error52) => mergedStream.emit("error", error52));
         });
@@ -173314,7 +175999,7 @@ var init_prettier = __esm(() => {
       exports.isEmpty = isEmpty;
     }
   });
-  require_utils3 = __commonJS2({
+  require_utils32 = __commonJS2({
     "node_modules/fast-glob/out/utils/index.js"(exports) {
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.string = exports.stream = exports.pattern = exports.path = exports.fs = exports.errno = exports.array = undefined;
@@ -173338,7 +176023,7 @@ var init_prettier = __esm(() => {
     "node_modules/fast-glob/out/managers/tasks.js"(exports) {
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.convertPatternGroupToTask = exports.convertPatternGroupsToTasks = exports.groupPatternsByBaseDirectory = exports.getNegativePatternsAsPositive = exports.getPositivePatterns = exports.convertPatternsToTasks = exports.generate = undefined;
-      var utils2 = require_utils3();
+      var utils2 = require_utils32();
       function generate(input, settings) {
         const patterns = processPatterns(input, settings);
         const ignore = processPatterns(settings.ignore, settings);
@@ -173647,7 +176332,7 @@ var init_prettier = __esm(() => {
       exports.createDirentFromStats = createDirentFromStats;
     }
   });
-  require_utils4 = __commonJS2({
+  require_utils42 = __commonJS2({
     "node_modules/@nodelib/fs.scandir/out/utils/index.js"(exports) {
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.fs = undefined;
@@ -173675,7 +176360,7 @@ var init_prettier = __esm(() => {
       var fsStat = require_out();
       var rpl = require_run_parallel();
       var constants_1 = require_constants3();
-      var utils2 = require_utils4();
+      var utils2 = require_utils42();
       var common = require_common();
       function read3(directory, settings, callback) {
         if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
@@ -173781,7 +176466,7 @@ var init_prettier = __esm(() => {
       exports.readdir = exports.readdirWithFileTypes = exports.read = undefined;
       var fsStat = require_out();
       var constants_1 = require_constants3();
-      var utils2 = require_utils4();
+      var utils2 = require_utils42();
       var common = require_common();
       function read3(directory, settings) {
         if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
@@ -174561,7 +177246,7 @@ var init_prettier = __esm(() => {
       Object.defineProperty(exports, "__esModule", { value: true });
       var path15 = __require2("path");
       var fsStat = require_out();
-      var utils2 = require_utils3();
+      var utils2 = require_utils32();
       var Reader = class {
         constructor(_settings) {
           this._settings = _settings;
@@ -174685,7 +177370,7 @@ var init_prettier = __esm(() => {
   require_matcher = __commonJS2({
     "node_modules/fast-glob/out/providers/matchers/matcher.js"(exports) {
       Object.defineProperty(exports, "__esModule", { value: true });
-      var utils2 = require_utils3();
+      var utils2 = require_utils32();
       var Matcher = class {
         constructor(_patterns, _settings, _micromatchOptions) {
           this._patterns = _patterns;
@@ -174724,7 +177409,7 @@ var init_prettier = __esm(() => {
           });
         }
         _splitSegmentsIntoSections(segments) {
-          return utils2.array.splitWhen(segments, (segment) => segment.dynamic && utils2.pattern.hasGlobStar(segment.pattern));
+          return utils2.array.splitWhen(segments, (segment2) => segment2.dynamic && utils2.pattern.hasGlobStar(segment2.pattern));
         }
       };
       exports.default = Matcher;
@@ -174745,11 +177430,11 @@ var init_prettier = __esm(() => {
               return true;
             }
             const match = parts.every((part, index) => {
-              const segment = pattern.segments[index];
-              if (segment.dynamic && segment.patternRe.test(part)) {
+              const segment2 = pattern.segments[index];
+              if (segment2.dynamic && segment2.patternRe.test(part)) {
                 return true;
               }
-              if (!segment.dynamic && segment.pattern === part) {
+              if (!segment2.dynamic && segment2.pattern === part) {
                 return true;
               }
               return false;
@@ -174767,7 +177452,7 @@ var init_prettier = __esm(() => {
   require_deep = __commonJS2({
     "node_modules/fast-glob/out/providers/filters/deep.js"(exports) {
       Object.defineProperty(exports, "__esModule", { value: true });
-      var utils2 = require_utils3();
+      var utils2 = require_utils32();
       var partial_1 = require_partial();
       var DeepFilter = class {
         constructor(_settings, _micromatchOptions) {
@@ -174829,7 +177514,7 @@ var init_prettier = __esm(() => {
   require_entry = __commonJS2({
     "node_modules/fast-glob/out/providers/filters/entry.js"(exports) {
       Object.defineProperty(exports, "__esModule", { value: true });
-      var utils2 = require_utils3();
+      var utils2 = require_utils32();
       var EntryFilter = class {
         constructor(_settings, _micromatchOptions) {
           this._settings = _settings;
@@ -174914,7 +177599,7 @@ var init_prettier = __esm(() => {
   require_error2 = __commonJS2({
     "node_modules/fast-glob/out/providers/filters/error.js"(exports) {
       Object.defineProperty(exports, "__esModule", { value: true });
-      var utils2 = require_utils3();
+      var utils2 = require_utils32();
       var ErrorFilter = class {
         constructor(_settings) {
           this._settings = _settings;
@@ -174932,7 +177617,7 @@ var init_prettier = __esm(() => {
   require_entry2 = __commonJS2({
     "node_modules/fast-glob/out/providers/transformers/entry.js"(exports) {
       Object.defineProperty(exports, "__esModule", { value: true });
-      var utils2 = require_utils3();
+      var utils2 = require_utils32();
       var EntryTransformer = class {
         constructor(_settings) {
           this._settings = _settings;
@@ -175200,7 +177885,7 @@ var init_prettier = __esm(() => {
       var stream_1 = require_stream4();
       var sync_1 = require_sync6();
       var settings_1 = require_settings4();
-      var utils2 = require_utils3();
+      var utils2 = require_utils32();
       async function FastGlob(source2, options8) {
         assertPatternsInput(source2);
         const works = getWorks(source2, async_1.default, options8);
@@ -175518,7 +178203,7 @@ var init_prettier = __esm(() => {
       };
     }
   });
-  require_semver = __commonJS2({
+  require_semver2 = __commonJS2({
     "node_modules/semver/classes/semver.js"(exports, module) {
       var debug = require_debug();
       var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants4();
@@ -175788,7 +178473,7 @@ var init_prettier = __esm(() => {
   });
   require_compare = __commonJS2({
     "node_modules/semver/functions/compare.js"(exports, module) {
-      var SemVer = require_semver();
+      var SemVer = require_semver2();
       var compare = (a5, b8, loose) => new SemVer(a5, loose).compare(new SemVer(b8, loose));
       module.exports = compare;
     }
@@ -177521,7 +180206,7 @@ globstar while`, file2, fr10, pattern, pr8, swallowee);
       };
     }
   });
-  require_src2 = __commonJS2({
+  require_src3 = __commonJS2({
     "node_modules/editorconfig/src/index.js"(exports) {
       var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P9, generator) {
         return new (P9 || (P9 = Promise))(function(resolve32, reject) {
@@ -178984,7 +181669,7 @@ globstar while`, file2, fr10, pattern, pr8, swallowee);
   mockable_default = mockable.mocked;
   import_micromatch = __toESM2(require_micromatch(), 1);
   partition_default = partition2;
-  import_editorconfig = __toESM2(require_src2(), 1);
+  import_editorconfig = __toESM2(require_src3(), 1);
   iterate_directory_up_default = iterateDirectoryUp;
   FileSearcher = class extends Searcher {
     findInDirectory = findFile;
@@ -181580,7 +184265,7 @@ import { fileURLToPath as fileURLToPath8 } from "url";
 // package.json
 var package_default = {
   name: "@eigenpal/cli",
-  version: "0.10.20",
+  version: "0.10.21",
   description: "Eigenpal CLI — author and run document workflows from your terminal. Agent-ready.",
   keywords: [
     "eigenpal",
@@ -183094,7 +185779,7 @@ async function pushCurrentBranch(input) {
 function slugifyPackageSegment(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
 }
-function packagePathForTemplate(template, name) {
+function packagePathForTemplate(template2, name) {
   const slug = slugifyPackageSegment(name);
   if (!slug)
     throw new Error("Package name must include at least one letter or number.");
@@ -183106,7 +185791,7 @@ function packagePathForTemplate(template, name) {
     knowledge: "resources/knowledge",
     evaluator: "evaluators"
   };
-  const root = rootByTemplate[template];
+  const root = rootByTemplate[template2];
   if (!root)
     throw new Error("Template must be agent, workflow, skill, rule, knowledge, or evaluator.");
   return SourcePackagePathSchema.parse(`${root}/${slug}`);
@@ -183515,12 +186200,12 @@ function archivePackage(input) {
     runGit(["archive", "--format=tar", `--output=${tarPath}`, input.ref, input.packagePath], {
       cwd: input.gitRoot
     });
-    const extract = spawnSync3("tar", ["-xf", tarPath, "--strip-components", String(input.packagePath.split("/").length)], {
+    const extract2 = spawnSync3("tar", ["-xf", tarPath, "--strip-components", String(input.packagePath.split("/").length)], {
       cwd: input.outDir,
       encoding: "utf8"
     });
-    if (extract.status !== 0)
-      throw new Error(extract.stderr.trim() || "tar extraction failed");
+    if (extract2.status !== 0)
+      throw new Error(extract2.stderr.trim() || "tar extraction failed");
   } finally {
     rmSync(path5.dirname(tarPath), { recursive: true, force: true });
   }
@@ -183549,12 +186234,12 @@ async function tryHostedArchive(input) {
   const tarPath = path5.join(mkdtempSyncCompat("eigenpal-hosted-source-"), "package.tar");
   try {
     writeFileSync4(tarPath, Buffer.from(await response.arrayBuffer()));
-    const extract = spawnSync3("tar", ["-xf", tarPath, "--strip-components", String(input.packagePath.split("/").length)], {
+    const extract2 = spawnSync3("tar", ["-xf", tarPath, "--strip-components", String(input.packagePath.split("/").length)], {
       cwd: input.outDir,
       encoding: "utf8"
     });
-    if (extract.status !== 0)
-      throw new Error(extract.stderr.trim() || "tar extraction failed");
+    if (extract2.status !== 0)
+      throw new Error(extract2.stderr.trim() || "tar extraction failed");
     return true;
   } finally {
     rmSync(path5.dirname(tarPath), { recursive: true, force: true });
@@ -187909,18 +190594,18 @@ async function init(name, opts) {
   if (existsSync11(target) && readdirSync2(target).length > 0) {
     throw new Error(`Target directory ${relative(process.cwd(), target)} exists and is not empty.`);
   }
-  let template;
+  let template2;
   if (opts.template) {
     if (!isTemplateName(opts.template)) {
       throw new Error(`Unknown template "${opts.template}". Available: ${TEMPLATE_NAMES.join(", ")}.`);
     }
-    template = opts.template;
+    template2 = opts.template;
   } else if (opts.yes || !process.stdin.isTTY) {
-    template = "blank";
+    template2 = "blank";
   } else {
-    template = await promptForTemplate();
+    template2 = await promptForTemplate();
   }
-  const sourceRoot = join2(resolveTemplatesRoot(), template);
+  const sourceRoot = join2(resolveTemplatesRoot(), template2);
   if (!existsSync11(sourceRoot)) {
     throw new Error(`Template directory missing on disk: ${sourceRoot}`);
   }