@eigenpal/cli 0.10.35 → 0.10.37

package/dist/cli.js

@@ -17245,8 +17245,148 @@ var init_provider_logo_data_generated = __esm(() => {
   };
 });
 
+// ../../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",
+    PAID_ALLOWANCE_GRANT: "pag",
+    PAID_ALLOWANCE_ADJUSTMENT: "paa",
+    OCR_EXTRACTION_PIPELINE: "oep",
+    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",
+    CLASSIFY_PAGES: "builtin/classify-pages",
+    VISION: "builtin/vision",
+    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;
@@ -17271,6 +17411,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;
 }
@@ -17493,11 +17636,2508 @@ 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/normalize-extract-input.ts
+function normalizeExtractInputToText(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (input && typeof input === "object") {
+    const obj = input;
+    if (typeof obj.content === "string") {
+      return obj.content;
+    }
+    if (typeof obj.text === "string") {
+      return obj.text;
+    }
+    return JSON.stringify(input, null, 2);
+  }
+  return String(input ?? "");
+}
+function extractSourceTextFromResolvedConfig(config2) {
+  if (!config2 || typeof config2 !== "object")
+    return null;
+  if (typeof config2.content === "string") {
+    return normalizeExtractInputToText({ content: config2.content });
+  }
+  if (typeof config2.text === "string") {
+    return normalizeExtractInputToText({ text: config2.text });
+  }
+  if (typeof config2.input === "string") {
+    return normalizeExtractInputToText({ content: config2.input });
+  }
+  if (config2.input !== null && config2.input !== undefined) {
+    return normalizeExtractInputToText(config2.input);
+  }
+  return null;
+}
+
+// ../types/src/processor/grounding.ts
+function stripGroundingMetadata(value) {
+  if (Array.isArray(value))
+    return value.map(stripGroundingMetadata);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (k === "_grounding")
+        continue;
+      out[k] = stripGroundingMetadata(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+// ../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/processor/configs/classify-pages.ts
+var ClassifyPagesInputSchema, ClassifyPagesLabelSchema, ClassifyPagesConfigSchema, ClassifyPagesOutputSchema;
+var init_classify_pages = __esm(() => {
+  init_zod();
+  ClassifyPagesInputSchema = exports_external.object({
+    pages: exports_external.array(exports_external.object({
+      pageIndex: exports_external.number().int().nonnegative().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.");
+  ClassifyPagesLabelSchema = exports_external.union([
+    exports_external.string().min(1),
+    exports_external.object({
+      name: exports_external.string().min(1),
+      description: exports_external.string().optional()
+    })
+  ]);
+  ClassifyPagesConfigSchema = exports_external.object({
+    labels: exports_external.array(ClassifyPagesLabelSchema).min(1),
+    prompt: exports_external.string().optional(),
+    provider: exports_external.string().optional(),
+    model: exports_external.string().optional(),
+    windowTokenBudget: exports_external.number().int().positive().optional()
+  });
+  ClassifyPagesOutputSchema = exports_external.object({
+    pages: exports_external.array(exports_external.object({
+      pageIndex: exports_external.number().int(),
+      labels: exports_external.array(exports_external.string())
+    })),
+    byLabel: exports_external.record(exports_external.string(), exports_external.array(exports_external.number().int()))
+  });
+});
+
+// ../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)"),
+    describeFigures: exports_external.boolean().optional().describe("Opt-in (default off). After text extraction, detect figure pages with a layout model and caption them with a vision model, appending `<figure>description</figure>` to their text. Skipped for plaintext. The caption vision calls are billed."),
+    figureInstructions: exports_external.string().optional().describe("Custom instruction for the figure-description pass."),
+    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. Unless grounding is disabled (grounded: false), the output also carries a reserved `_grounding` map keyed by field name: `_grounding.<field> = { confidence: high|medium|low, needsReview, reason?, source_span: { start, end, text, alignment } | null }`, plus reserved `_degraded: true` / `_reason` markers when the grounding LLM pass could not run.");
+  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("Grounding is ON by default: a grounding pass runs over the schema fields and attaches per-field source spans + confidence under a reserved `_grounding` output key, flagging fields whose value cannot be located in the source for human review. The pass runs through the workspace LLM (any provider) and chunks long documents automatically. Tri-state: unset (default) = on, degrading gracefully to deterministic text alignment (`_grounding._degraded: true`) if no grounding model is available; `true` = strict, the step fails when the grounding model cannot be resolved; `false` = off, no `_grounding` key at all."),
+    groundingModel: exports_external.string().optional().describe("Provider/model for the grounding pass. Defaults to the workspace default LLM. Any configured provider works; the pass only fails the step when `grounded: true` is set explicitly and no model resolves."),
+    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 set needsReview on a field. Default: low_only (only fields whose value could not be located in the source). Use medium_or_low to also flag approximate and derived matches.")
+  });
+});
+
+// ../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, SplitSectionSchema, 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.");
+  SplitSectionSchema = 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())
+  });
+  SplitOutputSchema = exports_external.object({
+    splits: exports_external.array(SplitSectionSchema),
+    sections: exports_external.record(exports_external.string(), SplitSectionSchema).describe("The same sections keyed by their config name, for direct reference: `steps.<split>.output.sections.<name>.page_range`. On the rare duplicate name, the last section wins; use `splits` for the full ordered list.")
+  });
+});
+
+// ../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_classify_pages();
+  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_classify_pages();
+  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.CLASSIFY_PAGES]: {
+      id: PROCESSOR_IDS.CLASSIFY_PAGES,
+      inputSchema: ClassifyPagesInputSchema,
+      outputSchema: ClassifyPagesOutputSchema,
+      configSchema: ClassifyPagesConfigSchema
+    },
+    [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) {
@@ -20535,9 +23175,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}`;
       }
     }
@@ -20817,7 +23457,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) {
@@ -21073,7 +23713,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",
@@ -21247,7 +23887,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") {
@@ -23657,7 +26297,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;
@@ -23671,7 +26311,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();
@@ -24599,24 +27239,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", {
@@ -25030,12 +27652,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;
@@ -39508,7 +42130,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) {
@@ -39572,8 +42194,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;
@@ -39992,7 +42614,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) {
@@ -40378,7 +43000,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) {
@@ -40540,7 +43162,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,
@@ -49518,7 +52140,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;
@@ -49584,7 +52206,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;
@@ -50301,7 +52923,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)) {
@@ -50654,7 +53276,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);
@@ -51158,7 +53780,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);
@@ -51197,7 +53819,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();
@@ -51968,18 +54590,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();
@@ -52534,11 +55156,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;
@@ -52651,8 +55273,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;
     }
@@ -52680,8 +55302,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]);
     }
   });
 });
@@ -53232,7 +55854,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;
@@ -53297,7 +55919,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) {
@@ -53473,7 +56095,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) {
@@ -54073,9 +56695,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;
   } });
@@ -54357,7 +56979,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();
@@ -54489,7 +57111,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();
@@ -55751,7 +58373,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();
@@ -56014,10 +58636,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();
@@ -56050,12 +58672,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();
@@ -56771,7 +59393,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();
@@ -57646,7 +60268,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();
@@ -58681,7 +61303,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);
 
@@ -58939,7 +61561,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);
@@ -59177,7 +61799,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();
@@ -59201,7 +61823,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
@@ -59229,7 +61851,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)) {
@@ -59244,7 +61866,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();
@@ -59259,7 +61881,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;
@@ -59290,7 +61912,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();
@@ -59932,7 +62554,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();
@@ -60202,7 +62824,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);
 
@@ -60322,7 +62944,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";
@@ -60396,7 +63018,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);
 
@@ -60425,7 +63047,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);
 
@@ -60453,7 +63075,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);
 
@@ -60569,7 +63191,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);
 
@@ -60820,7 +63442,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();
@@ -60966,7 +63588,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();
@@ -61365,7 +63987,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 "";
@@ -61430,7 +64052,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) {
@@ -61815,7 +64437,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
@@ -62067,9 +64689,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"];
 });
@@ -62239,6 +64861,7 @@ var init_steps = __esm(() => {
     "ai.split",
     "ai.segment",
     "ai.classify",
+    "ai.classify-pages",
     "ai.vision"
   ];
   TRANSFORM_STEP_TYPES = [
@@ -62280,6 +64903,7 @@ var init_steps = __esm(() => {
     AI_SPLIT: "ai.split",
     AI_SEGMENT: "ai.segment",
     AI_CLASSIFY: "ai.classify",
+    AI_CLASSIFY_PAGES: "ai.classify-pages",
     AI_VISION: "ai.vision",
     TRANSFORM_SET: "transform.set",
     TRANSFORM_REMOVE: "transform.remove",
@@ -62429,8 +65053,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
   }));
 }
@@ -62480,7 +65104,7 @@ function isOutputSchemaUnknown(stepType) {
   const def = schema._def;
   return def?.typeName === "ZodUnknown";
 }
-var AiParseConfigSchema, AiParseOutputSchema, AiExtractConfigSchema, AiExtractOutputSchema, VisionPageRangeSchema, AiVisionConfigSchema, AiVisionOutputSchema, AiSplitConfigSchema, AiSplitSectionSchema, AiSplitOutputSchema, AiSegmentConfigSchema, AiSegmentOutputSchema, AiClassifyConfigSchema, AiClassifyOutputSchema, TransformSetConfigSchema, TransformSetOutputSchema, TransformRemoveConfigSchema, TransformRemoveOutputSchema, TransformCombineConfigSchema, TransformCombineOutputSchema, TransformSplitConfigSchema, TransformSplitOutputSchema, TransformMergeConfigSchema, TransformMergeOutputSchema, TransformTemplateConfigSchema, TransformTemplateOutputSchema, TransformPdfEmbedConfigSchema, TransformPdfEmbedOutputSchema, TransformXlsxToJsonConfigSchema, TransformXlsxToJsonOutputSchema, TransformScriptConfigSchema, TransformScriptOutputSchema, ParsedDocPageSchema, TransformTextChunkerConfigSchema, TransformTextChunkerOutputSchema, RegexNormalizerSchema, RegexFormatSchema, REGEX_FLAGS, RegexFieldSchema, TransformRegexExtractConfigSchema, TransformRegexExtractOutputSchema, ActionHttpConfigSchema, ActionHttpOutputSchema, ActionInvokeWorkflowConfigSchema, ActionInvokeWorkflowOutputSchema, ActionWebsiteReaderConfigSchema, ActionWebsiteReaderOutputSchema, ControlIfConfigSchema, ControlIfOutputSchema, ControlSwitchConfigSchema, ControlSwitchOutputSchema, ControlForeachConfigSchema, ControlForeachOutputSchema, ControlParallelMapConfigSchema, ControlParallelMapOutputSchema, ControlParallelConfigSchema, ControlParallelOutputSchema, ControlWaitConfigSchema, ControlWaitOutputSchema, ControlFailConfigSchema, ControlFailOutputSchema, AI_RETRY_CAPABILITY, DETERMINISTIC_RETRY_CAPABILITY, CONTROL_RETRY_CAPABILITY, FILE_OUTPUT_RETRY_CAPABILITY, STEP_RETRY_CAPABILITIES, STEP_SCHEMAS;
+var AiParseConfigSchema, AiParseOutputSchema, AiExtractConfigSchema, AiExtractOutputSchema, VisionPageRangeSchema, AiVisionConfigSchema, AiVisionOutputSchema, AiSplitConfigSchema, AiSplitSectionSchema, AiSplitOutputSchema, AiSegmentConfigSchema, AiSegmentOutputSchema, AiClassifyConfigSchema, AiClassifyOutputSchema, ClassifyPagesLabelSchema2, AiClassifyPagesConfigSchema, AiClassifyPagesOutputSchema, TransformSetConfigSchema, TransformSetOutputSchema, TransformRemoveConfigSchema, TransformRemoveOutputSchema, TransformCombineConfigSchema, TransformCombineOutputSchema, TransformSplitConfigSchema, TransformSplitOutputSchema, TransformMergeConfigSchema, TransformMergeOutputSchema, TransformTemplateConfigSchema, TransformTemplateOutputSchema, TransformPdfEmbedConfigSchema, TransformPdfEmbedOutputSchema, TransformXlsxToJsonConfigSchema, TransformXlsxToJsonOutputSchema, TransformScriptConfigSchema, TransformScriptOutputSchema, ParsedDocPageSchema, TransformTextChunkerConfigSchema, TransformTextChunkerOutputSchema, RegexNormalizerSchema, RegexFormatSchema, REGEX_FLAGS, RegexFieldSchema, TransformRegexExtractConfigSchema, TransformRegexExtractOutputSchema, ActionHttpConfigSchema, ActionHttpOutputSchema, ActionInvokeWorkflowConfigSchema, ActionInvokeWorkflowOutputSchema, ActionWebsiteReaderConfigSchema, ActionWebsiteReaderOutputSchema, ControlIfConfigSchema, ControlIfOutputSchema, ControlSwitchConfigSchema, ControlSwitchOutputSchema, ControlForeachConfigSchema, ControlForeachOutputSchema, ControlParallelMapConfigSchema, ControlParallelMapOutputSchema, ControlParallelConfigSchema, ControlParallelOutputSchema, ControlWaitConfigSchema, ControlWaitOutputSchema, ControlFailConfigSchema, ControlFailOutputSchema, AI_RETRY_CAPABILITY, DETERMINISTIC_RETRY_CAPABILITY, CONTROL_RETRY_CAPABILITY, FILE_OUTPUT_RETRY_CAPABILITY, STEP_RETRY_CAPABILITIES, STEP_SCHEMAS;
 var init_step_configs = __esm(() => {
   init_zod();
   init_common();
@@ -62538,7 +65162,8 @@ var init_step_configs = __esm(() => {
     document: exports_external.string().describe("Template expression resolving to the input file (PDF, image, or Office document)."),
     pageFrom: exports_external.union([exports_external.number().int().min(0), exports_external.string()]).optional().describe("First page to inspect (0-based, inclusive). Optional. Accepts a template expression. When omitted, starts from the first page."),
     pageTo: exports_external.union([exports_external.number().int().min(0), exports_external.string()]).optional().describe("Last page to inspect (0-based, inclusive). Optional. Accepts a template expression. When omitted, runs to the last page. When BOTH pageFrom and pageTo are omitted, the whole document is inspected in chunks of maxPages (divide-and-conquer, results merged)."),
-    pages: exports_external.union([exports_external.literal("all"), VisionPageRangeSchema, exports_external.array(VisionPageRangeSchema), exports_external.string()]).optional().describe('DEPRECATED — prefer pageFrom/pageTo. Which pages to inspect: "all", a single [start,end] range, a list of ranges, or a template expression resolving to one of those.'),
+    pageIndices: exports_external.union([exports_external.array(exports_external.number().int().min(0)).min(1), exports_external.string()]).optional().describe('Explicit list of 0-based page indices to inspect — supports NON-contiguous selections, e.g. [4, 11, 19], or a template resolving to a number[] such as "{{ steps.label_pages.output.byLabel.photo }}". Highest priority: when set, pageFrom/pageTo and pages are ignored.'),
+    pages: exports_external.union([exports_external.literal("all"), VisionPageRangeSchema, exports_external.array(VisionPageRangeSchema), exports_external.string()]).optional().describe('DEPRECATED — prefer pageIndices (scattered) or pageFrom/pageTo (contiguous). Which pages to inspect: "all", a single [start,end] range, a list of ranges, or a template expression resolving to one of those.'),
     schema: exports_external.object({
       type: exports_external.literal("object"),
       properties: exports_external.record(exports_external.string(), exports_external.unknown()),
@@ -62656,6 +65281,56 @@ var init_step_configs = __esm(() => {
     confidence: exports_external.enum(["low", "medium", "high"]).describe("LLM confidence in the classification. Coarse enum — numeric scores cluster meaninglessly at 0.85-0.95."),
     reason: exports_external.string().describe("Short justification for the chosen label — useful for debugging.")
   });
+  ClassifyPagesLabelSchema2 = exports_external.union([
+    exports_external.string().min(1),
+    exports_external.object({
+      name: exports_external.string().min(1).describe("Label value — the key in output.byLabel and an entry in pages[].labels."),
+      description: exports_external.string().optional().describe("What a page must show to earn this label. Fed to the LLM as guidance.")
+    })
+  ]);
+  AiClassifyPagesConfigSchema = exports_external.object({
+    input: exports_external.string().describe('The ai.parse output to label, e.g. "{{ steps.parse.output }}". Each page is labelled independently.'),
+    labels: exports_external.array(ClassifyPagesLabelSchema2).min(1).describe('Labels a page can carry. A page may match ZERO, ONE, or MANY of them. Each entry is a bare name (e.g. "photo") or { name, description }. Names must be unique.'),
+    prompt: exports_external.string().optional().describe("Extra classification guidance appended to the system prompt."),
+    provider: exports_external.string().optional().describe("Provider ID from eigenpal.config.yaml. Falls back to the tenant default."),
+    model: exports_external.string().optional().describe("Model override (advanced)."),
+    windowTokenBudget: exports_external.number().int().positive().optional().describe("Per-window token ceiling. Pages are packed into windows under this budget; one LLM call per window. Defaults to env SPLIT_WINDOW_TOKEN_BUDGET (20000).")
+  }).superRefine((cfg, ctx) => {
+    const RESERVED = new Set(["__proto__", "prototype", "constructor"]);
+    const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+    const names = cfg.labels.map((l) => typeof l === "string" ? l : l.name);
+    const seen = new Set;
+    names.forEach((name, i) => {
+      if (!IDENTIFIER.test(name)) {
+        ctx.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          message: `label name "${name}" must be a template-safe identifier (letters, digits, underscore; no dots or spaces)`,
+          path: ["labels", i]
+        });
+      } else if (RESERVED.has(name)) {
+        ctx.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          message: `label name "${name}" is reserved`,
+          path: ["labels", i]
+        });
+      }
+      if (seen.has(name)) {
+        ctx.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          message: `duplicate label name "${name}"`,
+          path: ["labels", i]
+        });
+      }
+      seen.add(name);
+    });
+  });
+  AiClassifyPagesOutputSchema = exports_external.object({
+    pages: exports_external.array(exports_external.object({
+      pageIndex: exports_external.number().int(),
+      labels: exports_external.array(exports_external.string()).describe("Labels assigned to this page (possibly empty).")
+    })).describe("Every input page, in order, with the labels the model assigned to it."),
+    byLabel: exports_external.record(exports_external.string(), exports_external.array(exports_external.number().int())).describe("Label name -> ascending page indices carrying it. Every configured label is present (empty array when no page matched), so dot access is always safe: `{{ steps.<step>.output.byLabel.<label> }}` resolves to a number[] ready for ai.vision `pageIndices`.")
+  });
   TransformSetConfigSchema = exports_external.object({
     fields: exports_external.record(exports_external.string(), exports_external.unknown()).refine((obj) => Object.keys(obj).length > 0, {
       message: "At least one field must be defined"
@@ -62991,6 +65666,7 @@ var init_step_configs = __esm(() => {
     "ai.split": AI_RETRY_CAPABILITY,
     "ai.segment": AI_RETRY_CAPABILITY,
     "ai.classify": AI_RETRY_CAPABILITY,
+    "ai.classify-pages": AI_RETRY_CAPABILITY,
     "ai.vision": AI_RETRY_CAPABILITY,
     "transform.set": DETERMINISTIC_RETRY_CAPABILITY,
     "transform.remove": DETERMINISTIC_RETRY_CAPABILITY,
@@ -63069,6 +65745,15 @@ var init_step_configs = __esm(() => {
       outputSchema: AiClassifyOutputSchema,
       configInWith: true
     },
+    "ai.classify-pages": {
+      type: "ai.classify-pages",
+      category: "ai",
+      name: "Label Pages",
+      description: "Assign zero or more labels to each page independently (multi-label) using an LLM. Consumes ai.parse output; emits per-page labels and a byLabel map (label -> page indices) that supports NON-contiguous selections. Feed byLabel.<label> straight into ai.vision `pageIndices` to inspect scattered pages of a type (e.g. every signature or property-photo page).",
+      configSchema: AiClassifyPagesConfigSchema,
+      outputSchema: AiClassifyPagesOutputSchema,
+      configInWith: true
+    },
     "ai.vision": {
       type: "ai.vision",
       category: "ai",
@@ -63283,81 +65968,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);
@@ -63439,11 +66049,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"),
@@ -63483,8 +66093,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({
@@ -63666,15 +66276,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",
@@ -63697,7 +66307,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()),
@@ -63725,24 +66335,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({
@@ -63761,15 +66371,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(),
@@ -63782,8 +66392,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({
@@ -63795,8 +66405,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({
@@ -64762,8 +67372,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("/");
@@ -64876,9 +67486,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}` });
       }
     }
   });
@@ -64894,9 +67504,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}` });
       }
     }
   });
@@ -64990,9 +67600,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) {
@@ -65742,7 +68352,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);
@@ -65922,7 +68532,7 @@ var init_sha2 = __esm(() => {
       super(28);
     }
   };
-  K512 = /* @__PURE__ */ (() => split([
+  K512 = /* @__PURE__ */ (() => split2([
     "0x428a2f98d728ae22",
     "0x7137449123ef65cd",
     "0xb5c0fbcfec4d3b2f",
@@ -68072,11 +70682,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];
     }
@@ -68086,36 +70696,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) {
@@ -68134,7 +70744,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;
@@ -68168,23 +70778,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);
   };
@@ -68629,7 +71239,7 @@ __export(exports_src, {
   SplitConfigSchema: () => SplitConfigSchema,
   SpanTypes: () => SpanTypes,
   SpanKindMap: () => SpanKindMap,
-  SpanKind: () => SpanKind,
+  SpanKind: () => import_api.SpanKind,
   SourceVersionRefSchema: () => SourceVersionRefSchema,
   SourceSecretsFileSchema: () => SourceSecretsFileSchema,
   SourcePackageTypeSchema: () => SourcePackageTypeSchema,
@@ -68837,7 +71447,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,
@@ -68957,6 +71567,10 @@ __export(exports_src, {
   ControlFailConfigSchema: () => ControlFailConfigSchema,
   ContentKindSchema: () => ContentKindSchema,
   ConnectorSchema: () => ConnectorSchema,
+  ClassifyPagesOutputSchema: () => ClassifyPagesOutputSchema,
+  ClassifyPagesLabelSchema: () => ClassifyPagesLabelSchema,
+  ClassifyPagesInputSchema: () => ClassifyPagesInputSchema,
+  ClassifyPagesConfigSchema: () => ClassifyPagesConfigSchema,
   ClassifyOutputSchema: () => ClassifyOutputSchema,
   ClassifyLabelSchema: () => ClassifyLabelSchema,
   ClassifyInputSchema: () => ClassifyInputSchema,
@@ -68999,8 +71613,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();
@@ -69915,7 +72529,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;
@@ -69949,20 +72563,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;
@@ -69975,7 +72589,7 @@ var require_foldFlowLines = __commonJS((exports) => {
             folds.push(j);
             escapedFolds[j] = true;
             end = j + endStep;
-            split2 = undefined;
+            split3 = undefined;
           } else {
             overflow = true;
           }
@@ -70609,7 +73223,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",
@@ -70619,7 +73233,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))
@@ -70658,21 +73272,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) {
@@ -71948,7 +74562,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();
@@ -71968,7 +74582,7 @@ var require_schema3 = __commonJS((exports) => {
     float.floatExp,
     float.float,
     binary.binary,
-    merge2.merge,
+    merge3.merge,
     omap.omap,
     pairs.pairs,
     set2.set,
@@ -71991,7 +74605,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();
@@ -72016,7 +74630,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,
@@ -72026,7 +74640,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,
@@ -72035,7 +74649,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) {
@@ -72053,7 +74667,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) {
@@ -72080,11 +74694,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 });
@@ -73307,13 +75921,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;
@@ -76327,7 +78941,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";
@@ -76670,7 +79284,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)}` } } };
@@ -78013,7 +80627,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");
@@ -171505,7 +174119,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") {
@@ -172527,7 +175141,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") {
@@ -172616,7 +175230,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);
@@ -173070,7 +175684,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 walk = (node, parent = {}) => {
           const invalidBlock = utils2.isInvalidBrace(parent);
@@ -173120,7 +175734,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);
@@ -175319,8 +177933,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;
@@ -175434,9 +178048,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));
         });
@@ -175464,7 +178078,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;
@@ -175488,7 +178102,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);
@@ -175797,7 +178411,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;
@@ -175825,7 +178439,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) {
@@ -175931,7 +178545,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) {
@@ -176711,7 +179325,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;
@@ -176835,7 +179449,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;
@@ -176874,7 +179488,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;
@@ -176895,11 +179509,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;
@@ -176917,7 +179531,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) {
@@ -176979,7 +179593,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;
@@ -177064,7 +179678,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;
@@ -177082,7 +179696,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;
@@ -177350,7 +179964,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);
@@ -177668,7 +180282,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();
@@ -177938,7 +180552,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;
     }
@@ -179671,7 +182285,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(resolve3, reject) {
@@ -181134,7 +183748,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;
@@ -183730,7 +186344,7 @@ import { fileURLToPath as fileURLToPath9 } from "url";
 // package.json
 var package_default = {
   name: "@eigenpal/cli",
-  version: "0.10.35",
+  version: "0.10.37",
   description: "Eigenpal CLI — author and run document workflows from your terminal. Agent-ready.",
   keywords: [
     "eigenpal",
@@ -185245,7 +187859,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.");
@@ -185257,7 +187871,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}`);
@@ -185688,12 +188302,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 });
   }
@@ -185722,12 +188336,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 });
@@ -190708,18 +193322,18 @@ async function init(name, opts) {
   if (existsSync13(target) && readdirSync4(target).length > 0) {
     throw new Error(`Target directory ${relative2(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 = join7(resolveTemplatesRoot(), template);
+  const sourceRoot = join7(resolveTemplatesRoot(), template2);
   if (!existsSync13(sourceRoot)) {
     throw new Error(`Template directory missing on disk: ${sourceRoot}`);
   }