@boboddy/sdk 0.4.3 → 0.5.1

package/dist/definitions/pipelines/index.js

@@ -17,523 +17,523 @@ var __export = (target, all) => {
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
-  xor: () => xor,
-  xid: () => xid2,
-  void: () => _void2,
-  uuidv7: () => uuidv7,
-  uuidv6: () => uuidv6,
-  uuidv4: () => uuidv4,
-  uuid: () => uuid2,
-  util: () => exports_util,
-  url: () => url,
-  uppercase: () => _uppercase,
-  unknown: () => unknown,
-  union: () => union,
-  undefined: () => _undefined3,
-  ulid: () => ulid2,
-  uint64: () => uint64,
-  uint32: () => uint32,
-  tuple: () => tuple,
-  trim: () => _trim,
-  treeifyError: () => treeifyError,
-  transform: () => transform,
-  toUpperCase: () => _toUpperCase,
-  toLowerCase: () => _toLowerCase,
-  toJSONSchema: () => toJSONSchema,
-  templateLiteral: () => templateLiteral,
-  symbol: () => symbol,
-  superRefine: () => superRefine,
-  success: () => success,
-  stringbool: () => stringbool,
-  stringFormat: () => stringFormat,
-  string: () => string2,
-  strictObject: () => strictObject,
-  startsWith: () => _startsWith,
-  slugify: () => _slugify,
-  size: () => _size,
-  setErrorMap: () => setErrorMap,
-  set: () => set,
-  safeParseAsync: () => safeParseAsync2,
-  safeParse: () => safeParse2,
-  safeEncodeAsync: () => safeEncodeAsync2,
-  safeEncode: () => safeEncode2,
-  safeDecodeAsync: () => safeDecodeAsync2,
-  safeDecode: () => safeDecode2,
-  registry: () => registry,
-  regexes: () => exports_regexes,
-  regex: () => _regex,
-  refine: () => refine,
-  record: () => record,
-  readonly: () => readonly,
-  property: () => _property,
-  promise: () => promise,
-  prettifyError: () => prettifyError,
-  preprocess: () => preprocess,
-  prefault: () => prefault,
-  positive: () => _positive,
-  pipe: () => pipe,
-  partialRecord: () => partialRecord,
-  parseAsync: () => parseAsync2,
-  parse: () => parse3,
-  overwrite: () => _overwrite,
-  optional: () => optional,
-  object: () => object,
-  number: () => number2,
-  nullish: () => nullish2,
-  nullable: () => nullable,
-  null: () => _null3,
-  normalize: () => _normalize,
-  nonpositive: () => _nonpositive,
-  nonoptional: () => nonoptional,
-  nonnegative: () => _nonnegative,
-  never: () => never,
-  negative: () => _negative,
-  nativeEnum: () => nativeEnum,
-  nanoid: () => nanoid2,
-  nan: () => nan,
-  multipleOf: () => _multipleOf,
-  minSize: () => _minSize,
-  minLength: () => _minLength,
-  mime: () => _mime,
-  meta: () => meta2,
-  maxSize: () => _maxSize,
-  maxLength: () => _maxLength,
-  map: () => map,
-  mac: () => mac2,
-  lte: () => _lte,
-  lt: () => _lt,
-  lowercase: () => _lowercase,
-  looseRecord: () => looseRecord,
-  looseObject: () => looseObject,
-  locales: () => exports_locales,
-  literal: () => literal,
-  length: () => _length,
-  lazy: () => lazy,
-  ksuid: () => ksuid2,
-  keyof: () => keyof,
-  jwt: () => jwt,
-  json: () => json,
-  iso: () => exports_iso,
-  ipv6: () => ipv62,
-  ipv4: () => ipv42,
-  invertCodec: () => invertCodec,
-  intersection: () => intersection,
-  int64: () => int64,
-  int32: () => int32,
-  int: () => int,
-  instanceof: () => _instanceof,
-  includes: () => _includes,
-  httpUrl: () => httpUrl,
-  hostname: () => hostname2,
-  hex: () => hex2,
-  hash: () => hash,
-  guid: () => guid2,
-  gte: () => _gte,
-  gt: () => _gt,
-  globalRegistry: () => globalRegistry,
-  getErrorMap: () => getErrorMap,
-  function: () => _function,
-  fromJSONSchema: () => fromJSONSchema,
-  formatError: () => formatError,
-  float64: () => float64,
-  float32: () => float32,
-  flattenError: () => flattenError,
-  file: () => file,
-  exactOptional: () => exactOptional,
-  enum: () => _enum2,
-  endsWith: () => _endsWith,
-  encodeAsync: () => encodeAsync2,
-  encode: () => encode2,
-  emoji: () => emoji2,
-  email: () => email2,
-  e164: () => e1642,
-  discriminatedUnion: () => discriminatedUnion,
-  describe: () => describe2,
-  decodeAsync: () => decodeAsync2,
-  decode: () => decode2,
-  date: () => date3,
-  custom: () => custom,
-  cuid2: () => cuid22,
-  cuid: () => cuid3,
-  core: () => exports_core2,
-  config: () => config,
-  coerce: () => exports_coerce,
-  codec: () => codec,
-  clone: () => clone,
-  cidrv6: () => cidrv62,
-  cidrv4: () => cidrv42,
-  check: () => check,
-  catch: () => _catch2,
-  boolean: () => boolean2,
-  bigint: () => bigint2,
-  base64url: () => base64url2,
-  base64: () => base642,
-  array: () => array,
-  any: () => any,
-  _function: () => _function,
-  _default: () => _default2,
-  _ZodString: () => _ZodString,
-  ZodXor: () => ZodXor,
-  ZodXID: () => ZodXID,
-  ZodVoid: () => ZodVoid,
-  ZodUnknown: () => ZodUnknown,
-  ZodUnion: () => ZodUnion,
-  ZodUndefined: () => ZodUndefined,
-  ZodUUID: () => ZodUUID,
-  ZodURL: () => ZodURL,
-  ZodULID: () => ZodULID,
-  ZodType: () => ZodType,
-  ZodTuple: () => ZodTuple,
-  ZodTransform: () => ZodTransform,
-  ZodTemplateLiteral: () => ZodTemplateLiteral,
-  ZodSymbol: () => ZodSymbol,
-  ZodSuccess: () => ZodSuccess,
-  ZodStringFormat: () => ZodStringFormat,
-  ZodString: () => ZodString,
-  ZodSet: () => ZodSet,
-  ZodRecord: () => ZodRecord,
-  ZodRealError: () => ZodRealError,
-  ZodReadonly: () => ZodReadonly,
-  ZodPromise: () => ZodPromise,
-  ZodPreprocess: () => ZodPreprocess,
-  ZodPrefault: () => ZodPrefault,
-  ZodPipe: () => ZodPipe,
-  ZodOptional: () => ZodOptional,
-  ZodObject: () => ZodObject,
-  ZodNumberFormat: () => ZodNumberFormat,
-  ZodNumber: () => ZodNumber,
-  ZodNullable: () => ZodNullable,
-  ZodNull: () => ZodNull,
-  ZodNonOptional: () => ZodNonOptional,
-  ZodNever: () => ZodNever,
-  ZodNanoID: () => ZodNanoID,
-  ZodNaN: () => ZodNaN,
-  ZodMap: () => ZodMap,
-  ZodMAC: () => ZodMAC,
-  ZodLiteral: () => ZodLiteral,
-  ZodLazy: () => ZodLazy,
-  ZodKSUID: () => ZodKSUID,
-  ZodJWT: () => ZodJWT,
-  ZodIssueCode: () => ZodIssueCode,
-  ZodIntersection: () => ZodIntersection,
-  ZodISOTime: () => ZodISOTime,
-  ZodISODuration: () => ZodISODuration,
-  ZodISODateTime: () => ZodISODateTime,
-  ZodISODate: () => ZodISODate,
-  ZodIPv6: () => ZodIPv6,
-  ZodIPv4: () => ZodIPv4,
-  ZodGUID: () => ZodGUID,
-  ZodFunction: () => ZodFunction,
-  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
-  ZodFile: () => ZodFile,
-  ZodExactOptional: () => ZodExactOptional,
-  ZodError: () => ZodError,
-  ZodEnum: () => ZodEnum,
-  ZodEmoji: () => ZodEmoji,
-  ZodEmail: () => ZodEmail,
-  ZodE164: () => ZodE164,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodDefault: () => ZodDefault,
-  ZodDate: () => ZodDate,
-  ZodCustomStringFormat: () => ZodCustomStringFormat,
-  ZodCustom: () => ZodCustom,
-  ZodCodec: () => ZodCodec,
-  ZodCatch: () => ZodCatch,
-  ZodCUID2: () => ZodCUID2,
-  ZodCUID: () => ZodCUID,
-  ZodCIDRv6: () => ZodCIDRv6,
-  ZodCIDRv4: () => ZodCIDRv4,
-  ZodBoolean: () => ZodBoolean,
-  ZodBigIntFormat: () => ZodBigIntFormat,
-  ZodBigInt: () => ZodBigInt,
-  ZodBase64URL: () => ZodBase64URL,
-  ZodBase64: () => ZodBase64,
-  ZodArray: () => ZodArray,
-  ZodAny: () => ZodAny,
-  TimePrecision: () => TimePrecision,
-  NEVER: () => NEVER,
-  $output: () => $output,
-  $input: () => $input,
-  $brand: () => $brand
-});
-
-// ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/index.js
-var exports_core2 = {};
-__export(exports_core2, {
-  version: () => version,
-  util: () => exports_util,
-  treeifyError: () => treeifyError,
-  toJSONSchema: () => toJSONSchema,
-  toDotPath: () => toDotPath,
-  safeParseAsync: () => safeParseAsync,
-  safeParse: () => safeParse,
-  safeEncodeAsync: () => safeEncodeAsync,
-  safeEncode: () => safeEncode,
-  safeDecodeAsync: () => safeDecodeAsync,
-  safeDecode: () => safeDecode,
-  registry: () => registry,
-  regexes: () => exports_regexes,
-  process: () => process,
-  prettifyError: () => prettifyError,
-  parseAsync: () => parseAsync,
-  parse: () => parse,
-  meta: () => meta,
-  locales: () => exports_locales,
-  isValidJWT: () => isValidJWT,
-  isValidBase64URL: () => isValidBase64URL,
-  isValidBase64: () => isValidBase64,
-  initializeContext: () => initializeContext,
-  globalRegistry: () => globalRegistry,
-  globalConfig: () => globalConfig,
-  formatError: () => formatError,
-  flattenError: () => flattenError,
-  finalize: () => finalize,
-  extractDefs: () => extractDefs,
-  encodeAsync: () => encodeAsync,
-  encode: () => encode,
-  describe: () => describe,
-  decodeAsync: () => decodeAsync,
-  decode: () => decode,
-  createToJSONSchemaMethod: () => createToJSONSchemaMethod,
-  createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod,
-  config: () => config,
-  clone: () => clone,
-  _xor: () => _xor,
-  _xid: () => _xid,
-  _void: () => _void,
-  _uuidv7: () => _uuidv7,
-  _uuidv6: () => _uuidv6,
-  _uuidv4: () => _uuidv4,
-  _uuid: () => _uuid,
-  _url: () => _url,
-  _uppercase: () => _uppercase,
-  _unknown: () => _unknown,
-  _union: () => _union,
-  _undefined: () => _undefined2,
-  _ulid: () => _ulid,
-  _uint64: () => _uint64,
-  _uint32: () => _uint32,
-  _tuple: () => _tuple,
-  _trim: () => _trim,
-  _transform: () => _transform,
-  _toUpperCase: () => _toUpperCase,
-  _toLowerCase: () => _toLowerCase,
-  _templateLiteral: () => _templateLiteral,
-  _symbol: () => _symbol,
-  _superRefine: () => _superRefine,
-  _success: () => _success,
-  _stringbool: () => _stringbool,
-  _stringFormat: () => _stringFormat,
-  _string: () => _string,
-  _startsWith: () => _startsWith,
-  _slugify: () => _slugify,
-  _size: () => _size,
-  _set: () => _set,
-  _safeParseAsync: () => _safeParseAsync,
-  _safeParse: () => _safeParse,
-  _safeEncodeAsync: () => _safeEncodeAsync,
-  _safeEncode: () => _safeEncode,
-  _safeDecodeAsync: () => _safeDecodeAsync,
-  _safeDecode: () => _safeDecode,
-  _regex: () => _regex,
-  _refine: () => _refine,
-  _record: () => _record,
-  _readonly: () => _readonly,
-  _property: () => _property,
-  _promise: () => _promise,
-  _positive: () => _positive,
-  _pipe: () => _pipe,
-  _parseAsync: () => _parseAsync,
-  _parse: () => _parse,
-  _overwrite: () => _overwrite,
-  _optional: () => _optional,
-  _number: () => _number,
-  _nullable: () => _nullable,
-  _null: () => _null2,
-  _normalize: () => _normalize,
-  _nonpositive: () => _nonpositive,
-  _nonoptional: () => _nonoptional,
-  _nonnegative: () => _nonnegative,
-  _never: () => _never,
-  _negative: () => _negative,
-  _nativeEnum: () => _nativeEnum,
-  _nanoid: () => _nanoid,
-  _nan: () => _nan,
-  _multipleOf: () => _multipleOf,
-  _minSize: () => _minSize,
-  _minLength: () => _minLength,
-  _min: () => _gte,
-  _mime: () => _mime,
-  _maxSize: () => _maxSize,
-  _maxLength: () => _maxLength,
-  _max: () => _lte,
-  _map: () => _map,
-  _mac: () => _mac,
-  _lte: () => _lte,
-  _lt: () => _lt,
-  _lowercase: () => _lowercase,
-  _literal: () => _literal,
-  _length: () => _length,
-  _lazy: () => _lazy,
-  _ksuid: () => _ksuid,
-  _jwt: () => _jwt,
-  _isoTime: () => _isoTime,
-  _isoDuration: () => _isoDuration,
-  _isoDateTime: () => _isoDateTime,
-  _isoDate: () => _isoDate,
-  _ipv6: () => _ipv6,
-  _ipv4: () => _ipv4,
-  _intersection: () => _intersection,
-  _int64: () => _int64,
-  _int32: () => _int32,
-  _int: () => _int,
-  _includes: () => _includes,
-  _guid: () => _guid,
-  _gte: () => _gte,
-  _gt: () => _gt,
-  _float64: () => _float64,
-  _float32: () => _float32,
-  _file: () => _file,
-  _enum: () => _enum,
-  _endsWith: () => _endsWith,
-  _encodeAsync: () => _encodeAsync,
-  _encode: () => _encode,
-  _emoji: () => _emoji2,
-  _email: () => _email,
-  _e164: () => _e164,
-  _discriminatedUnion: () => _discriminatedUnion,
-  _default: () => _default,
-  _decodeAsync: () => _decodeAsync,
-  _decode: () => _decode,
-  _date: () => _date,
-  _custom: () => _custom,
-  _cuid2: () => _cuid2,
-  _cuid: () => _cuid,
-  _coercedString: () => _coercedString,
-  _coercedNumber: () => _coercedNumber,
-  _coercedDate: () => _coercedDate,
-  _coercedBoolean: () => _coercedBoolean,
-  _coercedBigint: () => _coercedBigint,
-  _cidrv6: () => _cidrv6,
-  _cidrv4: () => _cidrv4,
-  _check: () => _check,
-  _catch: () => _catch,
-  _boolean: () => _boolean,
-  _bigint: () => _bigint,
-  _base64url: () => _base64url,
-  _base64: () => _base64,
-  _array: () => _array,
-  _any: () => _any,
-  TimePrecision: () => TimePrecision,
-  NEVER: () => NEVER,
-  JSONSchemaGenerator: () => JSONSchemaGenerator,
-  JSONSchema: () => exports_json_schema,
-  Doc: () => Doc,
-  $output: () => $output,
-  $input: () => $input,
-  $constructor: () => $constructor,
   $brand: () => $brand,
-  $ZodXor: () => $ZodXor,
-  $ZodXID: () => $ZodXID,
-  $ZodVoid: () => $ZodVoid,
-  $ZodUnknown: () => $ZodUnknown,
-  $ZodUnion: () => $ZodUnion,
-  $ZodUndefined: () => $ZodUndefined,
-  $ZodUUID: () => $ZodUUID,
-  $ZodURL: () => $ZodURL,
-  $ZodULID: () => $ZodULID,
-  $ZodType: () => $ZodType,
-  $ZodTuple: () => $ZodTuple,
-  $ZodTransform: () => $ZodTransform,
-  $ZodTemplateLiteral: () => $ZodTemplateLiteral,
-  $ZodSymbol: () => $ZodSymbol,
-  $ZodSuccess: () => $ZodSuccess,
-  $ZodStringFormat: () => $ZodStringFormat,
-  $ZodString: () => $ZodString,
-  $ZodSet: () => $ZodSet,
-  $ZodRegistry: () => $ZodRegistry,
-  $ZodRecord: () => $ZodRecord,
-  $ZodRealError: () => $ZodRealError,
-  $ZodReadonly: () => $ZodReadonly,
-  $ZodPromise: () => $ZodPromise,
-  $ZodPreprocess: () => $ZodPreprocess,
-  $ZodPrefault: () => $ZodPrefault,
-  $ZodPipe: () => $ZodPipe,
-  $ZodOptional: () => $ZodOptional,
-  $ZodObjectJIT: () => $ZodObjectJIT,
-  $ZodObject: () => $ZodObject,
-  $ZodNumberFormat: () => $ZodNumberFormat,
-  $ZodNumber: () => $ZodNumber,
-  $ZodNullable: () => $ZodNullable,
-  $ZodNull: () => $ZodNull,
-  $ZodNonOptional: () => $ZodNonOptional,
-  $ZodNever: () => $ZodNever,
-  $ZodNanoID: () => $ZodNanoID,
-  $ZodNaN: () => $ZodNaN,
-  $ZodMap: () => $ZodMap,
-  $ZodMAC: () => $ZodMAC,
-  $ZodLiteral: () => $ZodLiteral,
-  $ZodLazy: () => $ZodLazy,
-  $ZodKSUID: () => $ZodKSUID,
-  $ZodJWT: () => $ZodJWT,
-  $ZodIntersection: () => $ZodIntersection,
-  $ZodISOTime: () => $ZodISOTime,
-  $ZodISODuration: () => $ZodISODuration,
-  $ZodISODateTime: () => $ZodISODateTime,
-  $ZodISODate: () => $ZodISODate,
-  $ZodIPv6: () => $ZodIPv6,
-  $ZodIPv4: () => $ZodIPv4,
-  $ZodGUID: () => $ZodGUID,
-  $ZodFunction: () => $ZodFunction,
-  $ZodFile: () => $ZodFile,
-  $ZodExactOptional: () => $ZodExactOptional,
-  $ZodError: () => $ZodError,
-  $ZodEnum: () => $ZodEnum,
-  $ZodEncodeError: () => $ZodEncodeError,
-  $ZodEmoji: () => $ZodEmoji,
-  $ZodEmail: () => $ZodEmail,
-  $ZodE164: () => $ZodE164,
-  $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
-  $ZodDefault: () => $ZodDefault,
-  $ZodDate: () => $ZodDate,
-  $ZodCustomStringFormat: () => $ZodCustomStringFormat,
-  $ZodCustom: () => $ZodCustom,
-  $ZodCodec: () => $ZodCodec,
-  $ZodCheckUpperCase: () => $ZodCheckUpperCase,
-  $ZodCheckStringFormat: () => $ZodCheckStringFormat,
-  $ZodCheckStartsWith: () => $ZodCheckStartsWith,
-  $ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
-  $ZodCheckRegex: () => $ZodCheckRegex,
-  $ZodCheckProperty: () => $ZodCheckProperty,
-  $ZodCheckOverwrite: () => $ZodCheckOverwrite,
-  $ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
-  $ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
-  $ZodCheckMinSize: () => $ZodCheckMinSize,
-  $ZodCheckMinLength: () => $ZodCheckMinLength,
-  $ZodCheckMimeType: () => $ZodCheckMimeType,
-  $ZodCheckMaxSize: () => $ZodCheckMaxSize,
-  $ZodCheckMaxLength: () => $ZodCheckMaxLength,
-  $ZodCheckLowerCase: () => $ZodCheckLowerCase,
-  $ZodCheckLessThan: () => $ZodCheckLessThan,
-  $ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
-  $ZodCheckIncludes: () => $ZodCheckIncludes,
-  $ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
-  $ZodCheckEndsWith: () => $ZodCheckEndsWith,
-  $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
-  $ZodCheck: () => $ZodCheck,
-  $ZodCatch: () => $ZodCatch,
-  $ZodCUID2: () => $ZodCUID2,
-  $ZodCUID: () => $ZodCUID,
-  $ZodCIDRv6: () => $ZodCIDRv6,
-  $ZodCIDRv4: () => $ZodCIDRv4,
-  $ZodBoolean: () => $ZodBoolean,
-  $ZodBigIntFormat: () => $ZodBigIntFormat,
-  $ZodBigInt: () => $ZodBigInt,
-  $ZodBase64URL: () => $ZodBase64URL,
-  $ZodBase64: () => $ZodBase64,
-  $ZodAsyncError: () => $ZodAsyncError,
+  $input: () => $input,
+  $output: () => $output,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBase64: () => ZodBase64,
+  ZodBase64URL: () => ZodBase64URL,
+  ZodBigInt: () => ZodBigInt,
+  ZodBigIntFormat: () => ZodBigIntFormat,
+  ZodBoolean: () => ZodBoolean,
+  ZodCIDRv4: () => ZodCIDRv4,
+  ZodCIDRv6: () => ZodCIDRv6,
+  ZodCUID: () => ZodCUID,
+  ZodCUID2: () => ZodCUID2,
+  ZodCatch: () => ZodCatch,
+  ZodCodec: () => ZodCodec,
+  ZodCustom: () => ZodCustom,
+  ZodCustomStringFormat: () => ZodCustomStringFormat,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodE164: () => ZodE164,
+  ZodEmail: () => ZodEmail,
+  ZodEmoji: () => ZodEmoji,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodExactOptional: () => ZodExactOptional,
+  ZodFile: () => ZodFile,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodGUID: () => ZodGUID,
+  ZodIPv4: () => ZodIPv4,
+  ZodIPv6: () => ZodIPv6,
+  ZodISODate: () => ZodISODate,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodJWT: () => ZodJWT,
+  ZodKSUID: () => ZodKSUID,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMAC: () => ZodMAC,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNanoID: () => ZodNanoID,
+  ZodNever: () => ZodNever,
+  ZodNonOptional: () => ZodNonOptional,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodNumberFormat: () => ZodNumberFormat,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodPipe: () => ZodPipe,
+  ZodPrefault: () => ZodPrefault,
+  ZodPreprocess: () => ZodPreprocess,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRealError: () => ZodRealError,
+  ZodRecord: () => ZodRecord,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodStringFormat: () => ZodStringFormat,
+  ZodSuccess: () => ZodSuccess,
+  ZodSymbol: () => ZodSymbol,
+  ZodTemplateLiteral: () => ZodTemplateLiteral,
+  ZodTransform: () => ZodTransform,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodULID: () => ZodULID,
+  ZodURL: () => ZodURL,
+  ZodUUID: () => ZodUUID,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  ZodXID: () => ZodXID,
+  ZodXor: () => ZodXor,
+  _ZodString: () => _ZodString,
+  _default: () => _default2,
+  _function: () => _function,
+  any: () => any,
+  array: () => array,
+  base64: () => base642,
+  base64url: () => base64url2,
+  bigint: () => bigint2,
+  boolean: () => boolean2,
+  catch: () => _catch2,
+  check: () => check,
+  cidrv4: () => cidrv42,
+  cidrv6: () => cidrv62,
+  clone: () => clone,
+  codec: () => codec,
+  coerce: () => exports_coerce,
+  config: () => config,
+  core: () => exports_core2,
+  cuid: () => cuid3,
+  cuid2: () => cuid22,
+  custom: () => custom,
+  date: () => date3,
+  decode: () => decode2,
+  decodeAsync: () => decodeAsync2,
+  describe: () => describe2,
+  discriminatedUnion: () => discriminatedUnion,
+  e164: () => e1642,
+  email: () => email2,
+  emoji: () => emoji2,
+  encode: () => encode2,
+  encodeAsync: () => encodeAsync2,
+  endsWith: () => _endsWith,
+  enum: () => _enum2,
+  exactOptional: () => exactOptional,
+  file: () => file,
+  flattenError: () => flattenError,
+  float32: () => float32,
+  float64: () => float64,
+  formatError: () => formatError,
+  fromJSONSchema: () => fromJSONSchema,
+  function: () => _function,
+  getErrorMap: () => getErrorMap,
+  globalRegistry: () => globalRegistry,
+  gt: () => _gt,
+  gte: () => _gte,
+  guid: () => guid2,
+  hash: () => hash,
+  hex: () => hex2,
+  hostname: () => hostname2,
+  httpUrl: () => httpUrl,
+  includes: () => _includes,
+  instanceof: () => _instanceof,
+  int: () => int,
+  int32: () => int32,
+  int64: () => int64,
+  intersection: () => intersection,
+  invertCodec: () => invertCodec,
+  ipv4: () => ipv42,
+  ipv6: () => ipv62,
+  iso: () => exports_iso,
+  json: () => json,
+  jwt: () => jwt,
+  keyof: () => keyof,
+  ksuid: () => ksuid2,
+  lazy: () => lazy,
+  length: () => _length,
+  literal: () => literal,
+  locales: () => exports_locales,
+  looseObject: () => looseObject,
+  looseRecord: () => looseRecord,
+  lowercase: () => _lowercase,
+  lt: () => _lt,
+  lte: () => _lte,
+  mac: () => mac2,
+  map: () => map,
+  maxLength: () => _maxLength,
+  maxSize: () => _maxSize,
+  meta: () => meta2,
+  mime: () => _mime,
+  minLength: () => _minLength,
+  minSize: () => _minSize,
+  multipleOf: () => _multipleOf,
+  nan: () => nan,
+  nanoid: () => nanoid2,
+  nativeEnum: () => nativeEnum,
+  negative: () => _negative,
+  never: () => never,
+  nonnegative: () => _nonnegative,
+  nonoptional: () => nonoptional,
+  nonpositive: () => _nonpositive,
+  normalize: () => _normalize,
+  null: () => _null3,
+  nullable: () => nullable,
+  nullish: () => nullish2,
+  number: () => number2,
+  object: () => object,
+  optional: () => optional,
+  overwrite: () => _overwrite,
+  parse: () => parse3,
+  parseAsync: () => parseAsync2,
+  partialRecord: () => partialRecord,
+  pipe: () => pipe,
+  positive: () => _positive,
+  prefault: () => prefault,
+  preprocess: () => preprocess,
+  prettifyError: () => prettifyError,
+  promise: () => promise,
+  property: () => _property,
+  readonly: () => readonly,
+  record: () => record,
+  refine: () => refine,
+  regex: () => _regex,
+  regexes: () => exports_regexes,
+  registry: () => registry,
+  safeDecode: () => safeDecode2,
+  safeDecodeAsync: () => safeDecodeAsync2,
+  safeEncode: () => safeEncode2,
+  safeEncodeAsync: () => safeEncodeAsync2,
+  safeParse: () => safeParse2,
+  safeParseAsync: () => safeParseAsync2,
+  set: () => set,
+  setErrorMap: () => setErrorMap,
+  size: () => _size,
+  slugify: () => _slugify,
+  startsWith: () => _startsWith,
+  strictObject: () => strictObject,
+  string: () => string2,
+  stringFormat: () => stringFormat,
+  stringbool: () => stringbool,
+  success: () => success,
+  superRefine: () => superRefine,
+  symbol: () => symbol,
+  templateLiteral: () => templateLiteral,
+  toJSONSchema: () => toJSONSchema,
+  toLowerCase: () => _toLowerCase,
+  toUpperCase: () => _toUpperCase,
+  transform: () => transform,
+  treeifyError: () => treeifyError,
+  trim: () => _trim,
+  tuple: () => tuple,
+  uint32: () => uint32,
+  uint64: () => uint64,
+  ulid: () => ulid2,
+  undefined: () => _undefined3,
+  union: () => union,
+  unknown: () => unknown,
+  uppercase: () => _uppercase,
+  url: () => url,
+  util: () => exports_util,
+  uuid: () => uuid2,
+  uuidv4: () => uuidv4,
+  uuidv6: () => uuidv6,
+  uuidv7: () => uuidv7,
+  void: () => _void2,
+  xid: () => xid2,
+  xor: () => xor
+});
+
+// ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/index.js
+var exports_core2 = {};
+__export(exports_core2, {
+  $ZodAny: () => $ZodAny,
   $ZodArray: () => $ZodArray,
-  $ZodAny: () => $ZodAny
+  $ZodAsyncError: () => $ZodAsyncError,
+  $ZodBase64: () => $ZodBase64,
+  $ZodBase64URL: () => $ZodBase64URL,
+  $ZodBigInt: () => $ZodBigInt,
+  $ZodBigIntFormat: () => $ZodBigIntFormat,
+  $ZodBoolean: () => $ZodBoolean,
+  $ZodCIDRv4: () => $ZodCIDRv4,
+  $ZodCIDRv6: () => $ZodCIDRv6,
+  $ZodCUID: () => $ZodCUID,
+  $ZodCUID2: () => $ZodCUID2,
+  $ZodCatch: () => $ZodCatch,
+  $ZodCheck: () => $ZodCheck,
+  $ZodCheckBigIntFormat: () => $ZodCheckBigIntFormat,
+  $ZodCheckEndsWith: () => $ZodCheckEndsWith,
+  $ZodCheckGreaterThan: () => $ZodCheckGreaterThan,
+  $ZodCheckIncludes: () => $ZodCheckIncludes,
+  $ZodCheckLengthEquals: () => $ZodCheckLengthEquals,
+  $ZodCheckLessThan: () => $ZodCheckLessThan,
+  $ZodCheckLowerCase: () => $ZodCheckLowerCase,
+  $ZodCheckMaxLength: () => $ZodCheckMaxLength,
+  $ZodCheckMaxSize: () => $ZodCheckMaxSize,
+  $ZodCheckMimeType: () => $ZodCheckMimeType,
+  $ZodCheckMinLength: () => $ZodCheckMinLength,
+  $ZodCheckMinSize: () => $ZodCheckMinSize,
+  $ZodCheckMultipleOf: () => $ZodCheckMultipleOf,
+  $ZodCheckNumberFormat: () => $ZodCheckNumberFormat,
+  $ZodCheckOverwrite: () => $ZodCheckOverwrite,
+  $ZodCheckProperty: () => $ZodCheckProperty,
+  $ZodCheckRegex: () => $ZodCheckRegex,
+  $ZodCheckSizeEquals: () => $ZodCheckSizeEquals,
+  $ZodCheckStartsWith: () => $ZodCheckStartsWith,
+  $ZodCheckStringFormat: () => $ZodCheckStringFormat,
+  $ZodCheckUpperCase: () => $ZodCheckUpperCase,
+  $ZodCodec: () => $ZodCodec,
+  $ZodCustom: () => $ZodCustom,
+  $ZodCustomStringFormat: () => $ZodCustomStringFormat,
+  $ZodDate: () => $ZodDate,
+  $ZodDefault: () => $ZodDefault,
+  $ZodDiscriminatedUnion: () => $ZodDiscriminatedUnion,
+  $ZodE164: () => $ZodE164,
+  $ZodEmail: () => $ZodEmail,
+  $ZodEmoji: () => $ZodEmoji,
+  $ZodEncodeError: () => $ZodEncodeError,
+  $ZodEnum: () => $ZodEnum,
+  $ZodError: () => $ZodError,
+  $ZodExactOptional: () => $ZodExactOptional,
+  $ZodFile: () => $ZodFile,
+  $ZodFunction: () => $ZodFunction,
+  $ZodGUID: () => $ZodGUID,
+  $ZodIPv4: () => $ZodIPv4,
+  $ZodIPv6: () => $ZodIPv6,
+  $ZodISODate: () => $ZodISODate,
+  $ZodISODateTime: () => $ZodISODateTime,
+  $ZodISODuration: () => $ZodISODuration,
+  $ZodISOTime: () => $ZodISOTime,
+  $ZodIntersection: () => $ZodIntersection,
+  $ZodJWT: () => $ZodJWT,
+  $ZodKSUID: () => $ZodKSUID,
+  $ZodLazy: () => $ZodLazy,
+  $ZodLiteral: () => $ZodLiteral,
+  $ZodMAC: () => $ZodMAC,
+  $ZodMap: () => $ZodMap,
+  $ZodNaN: () => $ZodNaN,
+  $ZodNanoID: () => $ZodNanoID,
+  $ZodNever: () => $ZodNever,
+  $ZodNonOptional: () => $ZodNonOptional,
+  $ZodNull: () => $ZodNull,
+  $ZodNullable: () => $ZodNullable,
+  $ZodNumber: () => $ZodNumber,
+  $ZodNumberFormat: () => $ZodNumberFormat,
+  $ZodObject: () => $ZodObject,
+  $ZodObjectJIT: () => $ZodObjectJIT,
+  $ZodOptional: () => $ZodOptional,
+  $ZodPipe: () => $ZodPipe,
+  $ZodPrefault: () => $ZodPrefault,
+  $ZodPreprocess: () => $ZodPreprocess,
+  $ZodPromise: () => $ZodPromise,
+  $ZodReadonly: () => $ZodReadonly,
+  $ZodRealError: () => $ZodRealError,
+  $ZodRecord: () => $ZodRecord,
+  $ZodRegistry: () => $ZodRegistry,
+  $ZodSet: () => $ZodSet,
+  $ZodString: () => $ZodString,
+  $ZodStringFormat: () => $ZodStringFormat,
+  $ZodSuccess: () => $ZodSuccess,
+  $ZodSymbol: () => $ZodSymbol,
+  $ZodTemplateLiteral: () => $ZodTemplateLiteral,
+  $ZodTransform: () => $ZodTransform,
+  $ZodTuple: () => $ZodTuple,
+  $ZodType: () => $ZodType,
+  $ZodULID: () => $ZodULID,
+  $ZodURL: () => $ZodURL,
+  $ZodUUID: () => $ZodUUID,
+  $ZodUndefined: () => $ZodUndefined,
+  $ZodUnion: () => $ZodUnion,
+  $ZodUnknown: () => $ZodUnknown,
+  $ZodVoid: () => $ZodVoid,
+  $ZodXID: () => $ZodXID,
+  $ZodXor: () => $ZodXor,
+  $brand: () => $brand,
+  $constructor: () => $constructor,
+  $input: () => $input,
+  $output: () => $output,
+  Doc: () => Doc,
+  JSONSchema: () => exports_json_schema,
+  JSONSchemaGenerator: () => JSONSchemaGenerator,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  _any: () => _any,
+  _array: () => _array,
+  _base64: () => _base64,
+  _base64url: () => _base64url,
+  _bigint: () => _bigint,
+  _boolean: () => _boolean,
+  _catch: () => _catch,
+  _check: () => _check,
+  _cidrv4: () => _cidrv4,
+  _cidrv6: () => _cidrv6,
+  _coercedBigint: () => _coercedBigint,
+  _coercedBoolean: () => _coercedBoolean,
+  _coercedDate: () => _coercedDate,
+  _coercedNumber: () => _coercedNumber,
+  _coercedString: () => _coercedString,
+  _cuid: () => _cuid,
+  _cuid2: () => _cuid2,
+  _custom: () => _custom,
+  _date: () => _date,
+  _decode: () => _decode,
+  _decodeAsync: () => _decodeAsync,
+  _default: () => _default,
+  _discriminatedUnion: () => _discriminatedUnion,
+  _e164: () => _e164,
+  _email: () => _email,
+  _emoji: () => _emoji2,
+  _encode: () => _encode,
+  _encodeAsync: () => _encodeAsync,
+  _endsWith: () => _endsWith,
+  _enum: () => _enum,
+  _file: () => _file,
+  _float32: () => _float32,
+  _float64: () => _float64,
+  _gt: () => _gt,
+  _gte: () => _gte,
+  _guid: () => _guid,
+  _includes: () => _includes,
+  _int: () => _int,
+  _int32: () => _int32,
+  _int64: () => _int64,
+  _intersection: () => _intersection,
+  _ipv4: () => _ipv4,
+  _ipv6: () => _ipv6,
+  _isoDate: () => _isoDate,
+  _isoDateTime: () => _isoDateTime,
+  _isoDuration: () => _isoDuration,
+  _isoTime: () => _isoTime,
+  _jwt: () => _jwt,
+  _ksuid: () => _ksuid,
+  _lazy: () => _lazy,
+  _length: () => _length,
+  _literal: () => _literal,
+  _lowercase: () => _lowercase,
+  _lt: () => _lt,
+  _lte: () => _lte,
+  _mac: () => _mac,
+  _map: () => _map,
+  _max: () => _lte,
+  _maxLength: () => _maxLength,
+  _maxSize: () => _maxSize,
+  _mime: () => _mime,
+  _min: () => _gte,
+  _minLength: () => _minLength,
+  _minSize: () => _minSize,
+  _multipleOf: () => _multipleOf,
+  _nan: () => _nan,
+  _nanoid: () => _nanoid,
+  _nativeEnum: () => _nativeEnum,
+  _negative: () => _negative,
+  _never: () => _never,
+  _nonnegative: () => _nonnegative,
+  _nonoptional: () => _nonoptional,
+  _nonpositive: () => _nonpositive,
+  _normalize: () => _normalize,
+  _null: () => _null2,
+  _nullable: () => _nullable,
+  _number: () => _number,
+  _optional: () => _optional,
+  _overwrite: () => _overwrite,
+  _parse: () => _parse,
+  _parseAsync: () => _parseAsync,
+  _pipe: () => _pipe,
+  _positive: () => _positive,
+  _promise: () => _promise,
+  _property: () => _property,
+  _readonly: () => _readonly,
+  _record: () => _record,
+  _refine: () => _refine,
+  _regex: () => _regex,
+  _safeDecode: () => _safeDecode,
+  _safeDecodeAsync: () => _safeDecodeAsync,
+  _safeEncode: () => _safeEncode,
+  _safeEncodeAsync: () => _safeEncodeAsync,
+  _safeParse: () => _safeParse,
+  _safeParseAsync: () => _safeParseAsync,
+  _set: () => _set,
+  _size: () => _size,
+  _slugify: () => _slugify,
+  _startsWith: () => _startsWith,
+  _string: () => _string,
+  _stringFormat: () => _stringFormat,
+  _stringbool: () => _stringbool,
+  _success: () => _success,
+  _superRefine: () => _superRefine,
+  _symbol: () => _symbol,
+  _templateLiteral: () => _templateLiteral,
+  _toLowerCase: () => _toLowerCase,
+  _toUpperCase: () => _toUpperCase,
+  _transform: () => _transform,
+  _trim: () => _trim,
+  _tuple: () => _tuple,
+  _uint32: () => _uint32,
+  _uint64: () => _uint64,
+  _ulid: () => _ulid,
+  _undefined: () => _undefined2,
+  _union: () => _union,
+  _unknown: () => _unknown,
+  _uppercase: () => _uppercase,
+  _url: () => _url,
+  _uuid: () => _uuid,
+  _uuidv4: () => _uuidv4,
+  _uuidv6: () => _uuidv6,
+  _uuidv7: () => _uuidv7,
+  _void: () => _void,
+  _xid: () => _xid,
+  _xor: () => _xor,
+  clone: () => clone,
+  config: () => config,
+  createStandardJSONSchemaMethod: () => createStandardJSONSchemaMethod,
+  createToJSONSchemaMethod: () => createToJSONSchemaMethod,
+  decode: () => decode,
+  decodeAsync: () => decodeAsync,
+  describe: () => describe,
+  encode: () => encode,
+  encodeAsync: () => encodeAsync,
+  extractDefs: () => extractDefs,
+  finalize: () => finalize,
+  flattenError: () => flattenError,
+  formatError: () => formatError,
+  globalConfig: () => globalConfig,
+  globalRegistry: () => globalRegistry,
+  initializeContext: () => initializeContext,
+  isValidBase64: () => isValidBase64,
+  isValidBase64URL: () => isValidBase64URL,
+  isValidJWT: () => isValidJWT,
+  locales: () => exports_locales,
+  meta: () => meta,
+  parse: () => parse,
+  parseAsync: () => parseAsync,
+  prettifyError: () => prettifyError,
+  process: () => process,
+  regexes: () => exports_regexes,
+  registry: () => registry,
+  safeDecode: () => safeDecode,
+  safeDecodeAsync: () => safeDecodeAsync,
+  safeEncode: () => safeEncode,
+  safeEncodeAsync: () => safeEncodeAsync,
+  safeParse: () => safeParse,
+  safeParseAsync: () => safeParseAsync,
+  toDotPath: () => toDotPath,
+  toJSONSchema: () => toJSONSchema,
+  treeifyError: () => treeifyError,
+  util: () => exports_util,
+  version: () => version
 });
 
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/core.js
@@ -600,86 +600,86 @@ class $ZodAsyncError extends Error {
     super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
   }
 }
-
-class $ZodEncodeError extends Error {
-  constructor(name) {
-    super(`Encountered unidirectional transform during encode: ${name}`);
-    this.name = "ZodEncodeError";
-  }
-}
-(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
-var globalConfig = globalThis.__zod_globalConfig;
-function config(newConfig) {
-  if (newConfig)
-    Object.assign(globalConfig, newConfig);
-  return globalConfig;
-}
-// ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/util.js
-var exports_util = {};
-__export(exports_util, {
-  unwrapMessage: () => unwrapMessage,
-  uint8ArrayToHex: () => uint8ArrayToHex,
-  uint8ArrayToBase64url: () => uint8ArrayToBase64url,
-  uint8ArrayToBase64: () => uint8ArrayToBase64,
-  stringifyPrimitive: () => stringifyPrimitive,
-  slugify: () => slugify,
-  shallowClone: () => shallowClone,
-  safeExtend: () => safeExtend,
-  required: () => required,
-  randomString: () => randomString,
-  propertyKeyTypes: () => propertyKeyTypes,
-  promiseAllObject: () => promiseAllObject,
-  primitiveTypes: () => primitiveTypes,
-  prefixIssues: () => prefixIssues,
-  pick: () => pick,
-  partial: () => partial,
-  parsedType: () => parsedType,
-  optionalKeys: () => optionalKeys,
-  omit: () => omit,
-  objectClone: () => objectClone,
-  numKeys: () => numKeys,
-  nullish: () => nullish,
-  normalizeParams: () => normalizeParams,
-  mergeDefs: () => mergeDefs,
-  merge: () => merge,
-  jsonStringifyReplacer: () => jsonStringifyReplacer,
-  joinValues: () => joinValues,
-  issue: () => issue,
-  isPlainObject: () => isPlainObject,
-  isObject: () => isObject,
-  hexToUint8Array: () => hexToUint8Array,
-  getSizableOrigin: () => getSizableOrigin,
-  getParsedType: () => getParsedType,
-  getLengthableOrigin: () => getLengthableOrigin,
-  getEnumValues: () => getEnumValues,
-  getElementAtPath: () => getElementAtPath,
-  floatSafeRemainder: () => floatSafeRemainder,
-  finalizeIssue: () => finalizeIssue,
-  extend: () => extend,
-  explicitlyAborted: () => explicitlyAborted,
-  escapeRegex: () => escapeRegex,
-  esc: () => esc,
-  defineLazy: () => defineLazy,
-  createTransparentProxy: () => createTransparentProxy,
-  cloneDef: () => cloneDef,
-  clone: () => clone,
-  cleanRegex: () => cleanRegex,
-  cleanEnum: () => cleanEnum,
-  captureStackTrace: () => captureStackTrace,
-  cached: () => cached,
-  base64urlToUint8Array: () => base64urlToUint8Array,
-  base64ToUint8Array: () => base64ToUint8Array,
-  assignProp: () => assignProp,
-  assertNotEqual: () => assertNotEqual,
-  assertNever: () => assertNever,
-  assertIs: () => assertIs,
-  assertEqual: () => assertEqual,
-  assert: () => assert,
-  allowsEval: () => allowsEval,
-  aborted: () => aborted,
-  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
+
+class $ZodEncodeError extends Error {
+  constructor(name) {
+    super(`Encountered unidirectional transform during encode: ${name}`);
+    this.name = "ZodEncodeError";
+  }
+}
+(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
+var globalConfig = globalThis.__zod_globalConfig;
+function config(newConfig) {
+  if (newConfig)
+    Object.assign(globalConfig, newConfig);
+  return globalConfig;
+}
+// ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/util.js
+var exports_util = {};
+__export(exports_util, {
+  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
   Class: () => Class,
-  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES
+  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
+  aborted: () => aborted,
+  allowsEval: () => allowsEval,
+  assert: () => assert,
+  assertEqual: () => assertEqual,
+  assertIs: () => assertIs,
+  assertNever: () => assertNever,
+  assertNotEqual: () => assertNotEqual,
+  assignProp: () => assignProp,
+  base64ToUint8Array: () => base64ToUint8Array,
+  base64urlToUint8Array: () => base64urlToUint8Array,
+  cached: () => cached,
+  captureStackTrace: () => captureStackTrace,
+  cleanEnum: () => cleanEnum,
+  cleanRegex: () => cleanRegex,
+  clone: () => clone,
+  cloneDef: () => cloneDef,
+  createTransparentProxy: () => createTransparentProxy,
+  defineLazy: () => defineLazy,
+  esc: () => esc,
+  escapeRegex: () => escapeRegex,
+  explicitlyAborted: () => explicitlyAborted,
+  extend: () => extend,
+  finalizeIssue: () => finalizeIssue,
+  floatSafeRemainder: () => floatSafeRemainder,
+  getElementAtPath: () => getElementAtPath,
+  getEnumValues: () => getEnumValues,
+  getLengthableOrigin: () => getLengthableOrigin,
+  getParsedType: () => getParsedType,
+  getSizableOrigin: () => getSizableOrigin,
+  hexToUint8Array: () => hexToUint8Array,
+  isObject: () => isObject,
+  isPlainObject: () => isPlainObject,
+  issue: () => issue,
+  joinValues: () => joinValues,
+  jsonStringifyReplacer: () => jsonStringifyReplacer,
+  merge: () => merge,
+  mergeDefs: () => mergeDefs,
+  normalizeParams: () => normalizeParams,
+  nullish: () => nullish,
+  numKeys: () => numKeys,
+  objectClone: () => objectClone,
+  omit: () => omit,
+  optionalKeys: () => optionalKeys,
+  parsedType: () => parsedType,
+  partial: () => partial,
+  pick: () => pick,
+  prefixIssues: () => prefixIssues,
+  primitiveTypes: () => primitiveTypes,
+  promiseAllObject: () => promiseAllObject,
+  propertyKeyTypes: () => propertyKeyTypes,
+  randomString: () => randomString,
+  required: () => required,
+  safeExtend: () => safeExtend,
+  shallowClone: () => shallowClone,
+  slugify: () => slugify,
+  stringifyPrimitive: () => stringifyPrimitive,
+  uint8ArrayToBase64: () => uint8ArrayToBase64,
+  uint8ArrayToBase64url: () => uint8ArrayToBase64url,
+  uint8ArrayToHex: () => uint8ArrayToHex,
+  unwrapMessage: () => unwrapMessage
 });
 function assertEqual(val) {
   return val;
@@ -1536,65 +1536,65 @@ var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync($ZodRealError);
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/regexes.js
 var exports_regexes = {};
 __export(exports_regexes, {
-  xid: () => xid,
-  uuid7: () => uuid7,
-  uuid6: () => uuid6,
-  uuid4: () => uuid4,
-  uuid: () => uuid,
-  uppercase: () => uppercase,
-  unicodeEmail: () => unicodeEmail,
-  undefined: () => _undefined,
-  ulid: () => ulid,
-  time: () => time,
-  string: () => string,
-  sha512_hex: () => sha512_hex,
-  sha512_base64url: () => sha512_base64url,
-  sha512_base64: () => sha512_base64,
-  sha384_hex: () => sha384_hex,
-  sha384_base64url: () => sha384_base64url,
-  sha384_base64: () => sha384_base64,
-  sha256_hex: () => sha256_hex,
-  sha256_base64url: () => sha256_base64url,
-  sha256_base64: () => sha256_base64,
-  sha1_hex: () => sha1_hex,
-  sha1_base64url: () => sha1_base64url,
-  sha1_base64: () => sha1_base64,
-  rfc5322Email: () => rfc5322Email,
-  number: () => number,
-  null: () => _null,
-  nanoid: () => nanoid,
-  md5_hex: () => md5_hex,
-  md5_base64url: () => md5_base64url,
-  md5_base64: () => md5_base64,
-  mac: () => mac,
-  lowercase: () => lowercase,
-  ksuid: () => ksuid,
-  ipv6: () => ipv6,
-  ipv4: () => ipv4,
-  integer: () => integer,
-  idnEmail: () => idnEmail,
-  httpProtocol: () => httpProtocol,
-  html5Email: () => html5Email,
-  hostname: () => hostname,
-  hex: () => hex,
-  guid: () => guid,
-  extendedDuration: () => extendedDuration,
-  emoji: () => emoji,
-  email: () => email,
-  e164: () => e164,
-  duration: () => duration,
-  domain: () => domain,
-  datetime: () => datetime,
-  date: () => date,
-  cuid2: () => cuid2,
-  cuid: () => cuid,
-  cidrv6: () => cidrv6,
-  cidrv4: () => cidrv4,
-  browserEmail: () => browserEmail,
-  boolean: () => boolean,
-  bigint: () => bigint,
+  base64: () => base64,
   base64url: () => base64url,
-  base64: () => base64
+  bigint: () => bigint,
+  boolean: () => boolean,
+  browserEmail: () => browserEmail,
+  cidrv4: () => cidrv4,
+  cidrv6: () => cidrv6,
+  cuid: () => cuid,
+  cuid2: () => cuid2,
+  date: () => date,
+  datetime: () => datetime,
+  domain: () => domain,
+  duration: () => duration,
+  e164: () => e164,
+  email: () => email,
+  emoji: () => emoji,
+  extendedDuration: () => extendedDuration,
+  guid: () => guid,
+  hex: () => hex,
+  hostname: () => hostname,
+  html5Email: () => html5Email,
+  httpProtocol: () => httpProtocol,
+  idnEmail: () => idnEmail,
+  integer: () => integer,
+  ipv4: () => ipv4,
+  ipv6: () => ipv6,
+  ksuid: () => ksuid,
+  lowercase: () => lowercase,
+  mac: () => mac,
+  md5_base64: () => md5_base64,
+  md5_base64url: () => md5_base64url,
+  md5_hex: () => md5_hex,
+  nanoid: () => nanoid,
+  null: () => _null,
+  number: () => number,
+  rfc5322Email: () => rfc5322Email,
+  sha1_base64: () => sha1_base64,
+  sha1_base64url: () => sha1_base64url,
+  sha1_hex: () => sha1_hex,
+  sha256_base64: () => sha256_base64,
+  sha256_base64url: () => sha256_base64url,
+  sha256_hex: () => sha256_hex,
+  sha384_base64: () => sha384_base64,
+  sha384_base64url: () => sha384_base64url,
+  sha384_hex: () => sha384_hex,
+  sha512_base64: () => sha512_base64,
+  sha512_base64url: () => sha512_base64url,
+  sha512_hex: () => sha512_hex,
+  string: () => string,
+  time: () => time,
+  ulid: () => ulid,
+  undefined: () => _undefined,
+  unicodeEmail: () => unicodeEmail,
+  uppercase: () => uppercase,
+  uuid: () => uuid,
+  uuid4: () => uuid4,
+  uuid6: () => uuid6,
+  uuid7: () => uuid7,
+  xid: () => xid
 });
 var cuid = /^[cC][0-9a-z]{6,}$/;
 var cuid2 = /^[0-9a-z]+$/;
@@ -4371,58 +4371,58 @@ function handleRefineResult(result, payload, input, inst) {
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/locales/index.js
 var exports_locales = {};
 __export(exports_locales, {
-  zhTW: () => zh_TW_default,
-  zhCN: () => zh_CN_default,
-  yo: () => yo_default,
-  vi: () => vi_default,
-  uz: () => uz_default,
-  ur: () => ur_default,
-  uk: () => uk_default,
-  ua: () => ua_default,
-  tr: () => tr_default,
-  th: () => th_default,
-  ta: () => ta_default,
-  sv: () => sv_default,
-  sl: () => sl_default,
-  ru: () => ru_default,
-  ro: () => ro_default,
-  pt: () => pt_default,
-  ps: () => ps_default,
-  pl: () => pl_default,
-  ota: () => ota_default,
-  no: () => no_default,
-  nl: () => nl_default,
-  ms: () => ms_default,
-  mk: () => mk_default,
-  lt: () => lt_default,
-  ko: () => ko_default,
-  km: () => km_default,
-  kh: () => kh_default,
-  ka: () => ka_default,
-  ja: () => ja_default,
-  it: () => it_default,
-  is: () => is_default,
-  id: () => id_default,
-  hy: () => hy_default,
-  hu: () => hu_default,
-  hr: () => hr_default,
-  he: () => he_default,
-  frCA: () => fr_CA_default,
-  fr: () => fr_default,
-  fi: () => fi_default,
-  fa: () => fa_default,
-  es: () => es_default,
-  eo: () => eo_default,
-  en: () => en_default,
-  el: () => el_default,
-  de: () => de_default,
-  da: () => da_default,
-  cs: () => cs_default,
-  ca: () => ca_default,
-  bg: () => bg_default,
-  be: () => be_default,
+  ar: () => ar_default,
   az: () => az_default,
-  ar: () => ar_default
+  be: () => be_default,
+  bg: () => bg_default,
+  ca: () => ca_default,
+  cs: () => cs_default,
+  da: () => da_default,
+  de: () => de_default,
+  el: () => el_default,
+  en: () => en_default,
+  eo: () => eo_default,
+  es: () => es_default,
+  fa: () => fa_default,
+  fi: () => fi_default,
+  fr: () => fr_default,
+  frCA: () => fr_CA_default,
+  he: () => he_default,
+  hr: () => hr_default,
+  hu: () => hu_default,
+  hy: () => hy_default,
+  id: () => id_default,
+  is: () => is_default,
+  it: () => it_default,
+  ja: () => ja_default,
+  ka: () => ka_default,
+  kh: () => kh_default,
+  km: () => km_default,
+  ko: () => ko_default,
+  lt: () => lt_default,
+  mk: () => mk_default,
+  ms: () => ms_default,
+  nl: () => nl_default,
+  no: () => no_default,
+  ota: () => ota_default,
+  pl: () => pl_default,
+  ps: () => ps_default,
+  pt: () => pt_default,
+  ro: () => ro_default,
+  ru: () => ru_default,
+  sl: () => sl_default,
+  sv: () => sv_default,
+  ta: () => ta_default,
+  th: () => th_default,
+  tr: () => tr_default,
+  ua: () => ua_default,
+  uk: () => uk_default,
+  ur: () => ur_default,
+  uz: () => uz_default,
+  vi: () => vi_default,
+  yo: () => yo_default,
+  zhCN: () => zh_CN_default,
+  zhTW: () => zh_TW_default
 });
 
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/locales/ar.js
@@ -12193,219 +12193,219 @@ var exports_json_schema = {};
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/schemas.js
 var exports_schemas2 = {};
 __export(exports_schemas2, {
-  xor: () => xor,
-  xid: () => xid2,
-  void: () => _void2,
-  uuidv7: () => uuidv7,
-  uuidv6: () => uuidv6,
-  uuidv4: () => uuidv4,
-  uuid: () => uuid2,
-  url: () => url,
-  unknown: () => unknown,
-  union: () => union,
-  undefined: () => _undefined3,
-  ulid: () => ulid2,
-  uint64: () => uint64,
-  uint32: () => uint32,
-  tuple: () => tuple,
-  transform: () => transform,
-  templateLiteral: () => templateLiteral,
-  symbol: () => symbol,
-  superRefine: () => superRefine,
-  success: () => success,
-  stringbool: () => stringbool,
-  stringFormat: () => stringFormat,
-  string: () => string2,
-  strictObject: () => strictObject,
-  set: () => set,
-  refine: () => refine,
-  record: () => record,
-  readonly: () => readonly,
-  promise: () => promise,
-  preprocess: () => preprocess,
-  prefault: () => prefault,
-  pipe: () => pipe,
-  partialRecord: () => partialRecord,
-  optional: () => optional,
-  object: () => object,
-  number: () => number2,
-  nullish: () => nullish2,
-  nullable: () => nullable,
-  null: () => _null3,
-  nonoptional: () => nonoptional,
-  never: () => never,
-  nativeEnum: () => nativeEnum,
-  nanoid: () => nanoid2,
-  nan: () => nan,
-  meta: () => meta2,
-  map: () => map,
-  mac: () => mac2,
-  looseRecord: () => looseRecord,
-  looseObject: () => looseObject,
-  literal: () => literal,
-  lazy: () => lazy,
-  ksuid: () => ksuid2,
-  keyof: () => keyof,
-  jwt: () => jwt,
-  json: () => json,
-  ipv6: () => ipv62,
-  ipv4: () => ipv42,
-  invertCodec: () => invertCodec,
-  intersection: () => intersection,
-  int64: () => int64,
-  int32: () => int32,
-  int: () => int,
-  instanceof: () => _instanceof,
-  httpUrl: () => httpUrl,
-  hostname: () => hostname2,
-  hex: () => hex2,
-  hash: () => hash,
-  guid: () => guid2,
-  function: () => _function,
-  float64: () => float64,
-  float32: () => float32,
-  file: () => file,
-  exactOptional: () => exactOptional,
-  enum: () => _enum2,
-  emoji: () => emoji2,
-  email: () => email2,
-  e164: () => e1642,
-  discriminatedUnion: () => discriminatedUnion,
-  describe: () => describe2,
-  date: () => date3,
-  custom: () => custom,
-  cuid2: () => cuid22,
-  cuid: () => cuid3,
-  codec: () => codec,
-  cidrv6: () => cidrv62,
-  cidrv4: () => cidrv42,
-  check: () => check,
-  catch: () => _catch2,
-  boolean: () => boolean2,
-  bigint: () => bigint2,
-  base64url: () => base64url2,
-  base64: () => base642,
-  array: () => array,
-  any: () => any,
-  _function: () => _function,
-  _default: () => _default2,
-  _ZodString: () => _ZodString,
-  ZodXor: () => ZodXor,
-  ZodXID: () => ZodXID,
-  ZodVoid: () => ZodVoid,
-  ZodUnknown: () => ZodUnknown,
-  ZodUnion: () => ZodUnion,
-  ZodUndefined: () => ZodUndefined,
-  ZodUUID: () => ZodUUID,
-  ZodURL: () => ZodURL,
-  ZodULID: () => ZodULID,
-  ZodType: () => ZodType,
-  ZodTuple: () => ZodTuple,
-  ZodTransform: () => ZodTransform,
-  ZodTemplateLiteral: () => ZodTemplateLiteral,
-  ZodSymbol: () => ZodSymbol,
-  ZodSuccess: () => ZodSuccess,
-  ZodStringFormat: () => ZodStringFormat,
-  ZodString: () => ZodString,
-  ZodSet: () => ZodSet,
-  ZodRecord: () => ZodRecord,
-  ZodReadonly: () => ZodReadonly,
-  ZodPromise: () => ZodPromise,
-  ZodPreprocess: () => ZodPreprocess,
-  ZodPrefault: () => ZodPrefault,
-  ZodPipe: () => ZodPipe,
-  ZodOptional: () => ZodOptional,
-  ZodObject: () => ZodObject,
-  ZodNumberFormat: () => ZodNumberFormat,
-  ZodNumber: () => ZodNumber,
-  ZodNullable: () => ZodNullable,
-  ZodNull: () => ZodNull,
-  ZodNonOptional: () => ZodNonOptional,
-  ZodNever: () => ZodNever,
-  ZodNanoID: () => ZodNanoID,
-  ZodNaN: () => ZodNaN,
-  ZodMap: () => ZodMap,
-  ZodMAC: () => ZodMAC,
-  ZodLiteral: () => ZodLiteral,
-  ZodLazy: () => ZodLazy,
-  ZodKSUID: () => ZodKSUID,
-  ZodJWT: () => ZodJWT,
-  ZodIntersection: () => ZodIntersection,
-  ZodIPv6: () => ZodIPv6,
-  ZodIPv4: () => ZodIPv4,
-  ZodGUID: () => ZodGUID,
-  ZodFunction: () => ZodFunction,
-  ZodFile: () => ZodFile,
-  ZodExactOptional: () => ZodExactOptional,
-  ZodEnum: () => ZodEnum,
-  ZodEmoji: () => ZodEmoji,
-  ZodEmail: () => ZodEmail,
-  ZodE164: () => ZodE164,
-  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
-  ZodDefault: () => ZodDefault,
-  ZodDate: () => ZodDate,
-  ZodCustomStringFormat: () => ZodCustomStringFormat,
-  ZodCustom: () => ZodCustom,
-  ZodCodec: () => ZodCodec,
-  ZodCatch: () => ZodCatch,
-  ZodCUID2: () => ZodCUID2,
-  ZodCUID: () => ZodCUID,
-  ZodCIDRv6: () => ZodCIDRv6,
-  ZodCIDRv4: () => ZodCIDRv4,
-  ZodBoolean: () => ZodBoolean,
-  ZodBigIntFormat: () => ZodBigIntFormat,
-  ZodBigInt: () => ZodBigInt,
-  ZodBase64URL: () => ZodBase64URL,
-  ZodBase64: () => ZodBase64,
+  ZodAny: () => ZodAny,
   ZodArray: () => ZodArray,
-  ZodAny: () => ZodAny
+  ZodBase64: () => ZodBase64,
+  ZodBase64URL: () => ZodBase64URL,
+  ZodBigInt: () => ZodBigInt,
+  ZodBigIntFormat: () => ZodBigIntFormat,
+  ZodBoolean: () => ZodBoolean,
+  ZodCIDRv4: () => ZodCIDRv4,
+  ZodCIDRv6: () => ZodCIDRv6,
+  ZodCUID: () => ZodCUID,
+  ZodCUID2: () => ZodCUID2,
+  ZodCatch: () => ZodCatch,
+  ZodCodec: () => ZodCodec,
+  ZodCustom: () => ZodCustom,
+  ZodCustomStringFormat: () => ZodCustomStringFormat,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodE164: () => ZodE164,
+  ZodEmail: () => ZodEmail,
+  ZodEmoji: () => ZodEmoji,
+  ZodEnum: () => ZodEnum,
+  ZodExactOptional: () => ZodExactOptional,
+  ZodFile: () => ZodFile,
+  ZodFunction: () => ZodFunction,
+  ZodGUID: () => ZodGUID,
+  ZodIPv4: () => ZodIPv4,
+  ZodIPv6: () => ZodIPv6,
+  ZodIntersection: () => ZodIntersection,
+  ZodJWT: () => ZodJWT,
+  ZodKSUID: () => ZodKSUID,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMAC: () => ZodMAC,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNanoID: () => ZodNanoID,
+  ZodNever: () => ZodNever,
+  ZodNonOptional: () => ZodNonOptional,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodNumberFormat: () => ZodNumberFormat,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodPipe: () => ZodPipe,
+  ZodPrefault: () => ZodPrefault,
+  ZodPreprocess: () => ZodPreprocess,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRecord: () => ZodRecord,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodStringFormat: () => ZodStringFormat,
+  ZodSuccess: () => ZodSuccess,
+  ZodSymbol: () => ZodSymbol,
+  ZodTemplateLiteral: () => ZodTemplateLiteral,
+  ZodTransform: () => ZodTransform,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodULID: () => ZodULID,
+  ZodURL: () => ZodURL,
+  ZodUUID: () => ZodUUID,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  ZodXID: () => ZodXID,
+  ZodXor: () => ZodXor,
+  _ZodString: () => _ZodString,
+  _default: () => _default2,
+  _function: () => _function,
+  any: () => any,
+  array: () => array,
+  base64: () => base642,
+  base64url: () => base64url2,
+  bigint: () => bigint2,
+  boolean: () => boolean2,
+  catch: () => _catch2,
+  check: () => check,
+  cidrv4: () => cidrv42,
+  cidrv6: () => cidrv62,
+  codec: () => codec,
+  cuid: () => cuid3,
+  cuid2: () => cuid22,
+  custom: () => custom,
+  date: () => date3,
+  describe: () => describe2,
+  discriminatedUnion: () => discriminatedUnion,
+  e164: () => e1642,
+  email: () => email2,
+  emoji: () => emoji2,
+  enum: () => _enum2,
+  exactOptional: () => exactOptional,
+  file: () => file,
+  float32: () => float32,
+  float64: () => float64,
+  function: () => _function,
+  guid: () => guid2,
+  hash: () => hash,
+  hex: () => hex2,
+  hostname: () => hostname2,
+  httpUrl: () => httpUrl,
+  instanceof: () => _instanceof,
+  int: () => int,
+  int32: () => int32,
+  int64: () => int64,
+  intersection: () => intersection,
+  invertCodec: () => invertCodec,
+  ipv4: () => ipv42,
+  ipv6: () => ipv62,
+  json: () => json,
+  jwt: () => jwt,
+  keyof: () => keyof,
+  ksuid: () => ksuid2,
+  lazy: () => lazy,
+  literal: () => literal,
+  looseObject: () => looseObject,
+  looseRecord: () => looseRecord,
+  mac: () => mac2,
+  map: () => map,
+  meta: () => meta2,
+  nan: () => nan,
+  nanoid: () => nanoid2,
+  nativeEnum: () => nativeEnum,
+  never: () => never,
+  nonoptional: () => nonoptional,
+  null: () => _null3,
+  nullable: () => nullable,
+  nullish: () => nullish2,
+  number: () => number2,
+  object: () => object,
+  optional: () => optional,
+  partialRecord: () => partialRecord,
+  pipe: () => pipe,
+  prefault: () => prefault,
+  preprocess: () => preprocess,
+  promise: () => promise,
+  readonly: () => readonly,
+  record: () => record,
+  refine: () => refine,
+  set: () => set,
+  strictObject: () => strictObject,
+  string: () => string2,
+  stringFormat: () => stringFormat,
+  stringbool: () => stringbool,
+  success: () => success,
+  superRefine: () => superRefine,
+  symbol: () => symbol,
+  templateLiteral: () => templateLiteral,
+  transform: () => transform,
+  tuple: () => tuple,
+  uint32: () => uint32,
+  uint64: () => uint64,
+  ulid: () => ulid2,
+  undefined: () => _undefined3,
+  union: () => union,
+  unknown: () => unknown,
+  url: () => url,
+  uuid: () => uuid2,
+  uuidv4: () => uuidv4,
+  uuidv6: () => uuidv6,
+  uuidv7: () => uuidv7,
+  void: () => _void2,
+  xid: () => xid2,
+  xor: () => xor
 });
 
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/checks.js
 var exports_checks2 = {};
 __export(exports_checks2, {
-  uppercase: () => _uppercase,
-  trim: () => _trim,
-  toUpperCase: () => _toUpperCase,
-  toLowerCase: () => _toLowerCase,
-  startsWith: () => _startsWith,
-  slugify: () => _slugify,
-  size: () => _size,
-  regex: () => _regex,
-  property: () => _property,
-  positive: () => _positive,
-  overwrite: () => _overwrite,
-  normalize: () => _normalize,
-  nonpositive: () => _nonpositive,
-  nonnegative: () => _nonnegative,
-  negative: () => _negative,
-  multipleOf: () => _multipleOf,
-  minSize: () => _minSize,
-  minLength: () => _minLength,
-  mime: () => _mime,
-  maxSize: () => _maxSize,
-  maxLength: () => _maxLength,
-  lte: () => _lte,
-  lt: () => _lt,
-  lowercase: () => _lowercase,
-  length: () => _length,
-  includes: () => _includes,
-  gte: () => _gte,
+  endsWith: () => _endsWith,
   gt: () => _gt,
-  endsWith: () => _endsWith
+  gte: () => _gte,
+  includes: () => _includes,
+  length: () => _length,
+  lowercase: () => _lowercase,
+  lt: () => _lt,
+  lte: () => _lte,
+  maxLength: () => _maxLength,
+  maxSize: () => _maxSize,
+  mime: () => _mime,
+  minLength: () => _minLength,
+  minSize: () => _minSize,
+  multipleOf: () => _multipleOf,
+  negative: () => _negative,
+  nonnegative: () => _nonnegative,
+  nonpositive: () => _nonpositive,
+  normalize: () => _normalize,
+  overwrite: () => _overwrite,
+  positive: () => _positive,
+  property: () => _property,
+  regex: () => _regex,
+  size: () => _size,
+  slugify: () => _slugify,
+  startsWith: () => _startsWith,
+  toLowerCase: () => _toLowerCase,
+  toUpperCase: () => _toUpperCase,
+  trim: () => _trim,
+  uppercase: () => _uppercase
 });
 
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/iso.js
 var exports_iso = {};
 __export(exports_iso, {
-  time: () => time2,
-  duration: () => duration2,
-  datetime: () => datetime2,
-  date: () => date2,
-  ZodISOTime: () => ZodISOTime,
-  ZodISODuration: () => ZodISODuration,
+  ZodISODate: () => ZodISODate,
   ZodISODateTime: () => ZodISODateTime,
-  ZodISODate: () => ZodISODate
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  date: () => date2,
+  datetime: () => datetime2,
+  duration: () => duration2,
+  time: () => time2
 });
 var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
   $ZodISODateTime.init(inst, def);
@@ -14266,11 +14266,11 @@ function fromJSONSchema(schema, params) {
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/coerce.js
 var exports_coerce = {};
 __export(exports_coerce, {
-  string: () => string3,
-  number: () => number3,
-  date: () => date4,
+  bigint: () => bigint3,
   boolean: () => boolean3,
-  bigint: () => bigint3
+  date: () => date4,
+  number: () => number3,
+  string: () => string3
 });
 function string3(params) {
   return _coercedString(ZodString, params);
@@ -14328,10 +14328,19 @@ function any2(conditions, outcome) {
   return { _tag: "rule", mode: "any", conditions, outcome };
 }
 function when(signal2, operator, value, outcome) {
+  const condition = {
+    _tag: "signal",
+    signal: signal2,
+    operator,
+    value
+  };
+  if (outcome === undefined) {
+    return condition;
+  }
   return {
     _tag: "rule",
     mode: "all",
-    conditions: [{ _tag: "signal", signal: signal2, operator, value }],
+    conditions: [condition],
     outcome
   };
 }
@@ -14387,117 +14396,44 @@ function serializeAdvancementPolicy(policy) {
     return serializeRule(rule);
   });
   return {
-    rulesJson: { rules: serializedRules },
-    defaultEventType: defaultResolved.type,
-    defaultEventParamsJson: defaultResolved.params,
-    allowedEventTypes: [...outcomeSet]
-  };
-}
-function visitSignalConditions(conditions, visit) {
-  for (const c of conditions) {
-    if (c._tag === "signal") {
-      visit(c);
-    } else {
-      visitSignalConditions(c.conditions, visit);
-    }
-  }
-}
-function isSameComputedDefinition(a, b) {
-  return a.type === b.type && a.inputSignalKeys.length === b.inputSignalKeys.length && a.inputSignalKeys.every((k, i) => k === b.inputSignalKeys[i]) && JSON.stringify(a.configJson) === JSON.stringify(b.configJson) && JSON.stringify(a.availableWhenResultStatusIn) === JSON.stringify(b.availableWhenResultStatusIn);
-}
-function extractInlineComputedSignals(policy) {
-  if (!policy?.rules)
-    return [];
-  const byKey = new Map;
-  for (const rule of policy.rules) {
-    visitSignalConditions(rule.conditions, (cond) => {
-      if (typeof cond.signal === "string")
-        return;
-      const inline = cond.signal;
-      const def = {
-        key: inline.key,
-        type: inline.type,
-        inputSignalKeys: [...inline.inputSignalKeys],
-        configJson: inline.configJson,
-        availableWhenResultStatusIn: inline.availableWhenResultStatusIn ? [...inline.availableWhenResultStatusIn] : null
-      };
-      const existing = byKey.get(def.key);
-      if (existing) {
-        if (!isSameComputedDefinition(existing, def)) {
-          throw new Error(`Conflicting inline computed signal definitions for key "${def.key}"`);
-        }
-        return;
-      }
-      byKey.set(def.key, def);
-    });
-  }
-  return [...byKey.values()];
-}
-
-// src/definitions/advancement-policies/cohort-advancement-policy.ts
-var cohortAdvancementEventTypeValues = ["continue", "block"];
-function serializeCohortCondition(condition) {
-  if (condition._tag === "signal") {
-    return {
-      fact: typeof condition.signal === "string" ? condition.signal : condition.signal.key,
-      operator: condition.operator,
-      value: condition.value
-    };
-  }
-  if (condition._tag === "all") {
-    return { all: condition.conditions.map(serializeCohortCondition) };
-  }
-  return { any: condition.conditions.map(serializeCohortCondition) };
-}
-function serializeCohortRule(rule) {
-  return {
-    conditions: { [rule.mode]: rule.conditions.map(serializeCohortCondition) },
-    event: {
-      type: rule.outcome,
-      ...rule.outcomeJson ? { params: rule.outcomeJson } : {}
-    }
-  };
-}
-function serializeCohortAdvancementPolicy(policy) {
-  if (!policy) {
-    return { rules: [], defaultEventType: "continue", defaultEventParamsJson: null };
-  }
-  return {
-    rules: (policy.rules ?? []).map(serializeCohortRule),
-    defaultEventType: policy.default,
-    defaultEventParamsJson: policy.defaultParamsJson ?? null
+    rulesJson: { rules: serializedRules },
+    defaultEventType: defaultResolved.type,
+    defaultEventParamsJson: defaultResolved.params,
+    allowedEventTypes: [...outcomeSet]
   };
 }
-function visitCohortSignalConditions(conditions, visit) {
+function visitSignalConditions(conditions, visit) {
   for (const c of conditions) {
     if (c._tag === "signal") {
       visit(c);
     } else {
-      visitCohortSignalConditions(c.conditions, visit);
+      visitSignalConditions(c.conditions, visit);
     }
   }
 }
-function isSameStepSignalsListDefinition(a, b) {
-  return JSON.stringify(a.ops) === JSON.stringify(b.ops) && JSON.stringify(a.reducer) === JSON.stringify(b.reducer);
+function isSameComputedDefinition(a, b) {
+  return a.type === b.type && a.inputSignalKeys.length === b.inputSignalKeys.length && a.inputSignalKeys.every((k, i) => k === b.inputSignalKeys[i]) && JSON.stringify(a.configJson) === JSON.stringify(b.configJson) && JSON.stringify(a.availableWhenResultStatusIn) === JSON.stringify(b.availableWhenResultStatusIn);
 }
-function extractInlineStepSignalsListDefinitions(policy) {
+function extractInlineComputedSignals(policy) {
   if (!policy?.rules)
     return [];
   const byKey = new Map;
   for (const rule of policy.rules) {
-    visitCohortSignalConditions(rule.conditions, (cond) => {
+    visitSignalConditions(rule.conditions, (cond) => {
       if (typeof cond.signal === "string")
         return;
       const inline = cond.signal;
       const def = {
         key: inline.key,
-        ops: inline.ops,
-        reducer: inline.reducer
+        type: inline.type,
+        inputSignalKeys: [...inline.inputSignalKeys],
+        configJson: inline.configJson,
+        availableWhenResultStatusIn: inline.availableWhenResultStatusIn ? [...inline.availableWhenResultStatusIn] : null
       };
       const existing = byKey.get(def.key);
       if (existing) {
-        if (!isSameStepSignalsListDefinition(existing, def)) {
-          throw new Error(`Conflicting inline stepSignalsList definitions for key "${def.key}"`);
+        if (!isSameComputedDefinition(existing, def)) {
+          throw new Error(`Conflicting inline computed signal definitions for key "${def.key}"`);
         }
         return;
       }
@@ -14507,436 +14443,82 @@ function extractInlineStepSignalsListDefinitions(policy) {
   return [...byKey.values()];
 }
 
-// src/definitions/pipelines/chain-graph.ts
-function tryOrderChainNodeDefinitions(nodeDefinitions, dependencyEdges) {
-  const nodesByKey = new Map;
-  for (const nodeDefinition of nodeDefinitions) {
-    nodesByKey.set(nodeDefinition.nodeKey, nodeDefinition);
-  }
-  const outgoing = new Map;
-  const incomingCount = new Map;
-  for (const nodeDefinition of nodeDefinitions) {
-    incomingCount.set(nodeDefinition.nodeKey, 0);
-  }
-  for (const edge of dependencyEdges) {
-    if (!nodesByKey.has(edge.fromNodeKey) || !nodesByKey.has(edge.toNodeKey)) {
-      return null;
-    }
-    if (outgoing.has(edge.fromNodeKey))
-      return null;
-    outgoing.set(edge.fromNodeKey, edge.toNodeKey);
-    incomingCount.set(edge.toNodeKey, (incomingCount.get(edge.toNodeKey) ?? 0) + 1);
-  }
-  for (const count of incomingCount.values()) {
-    if (count > 1)
-      return null;
-  }
-  if (nodeDefinitions.length === 0)
-    return [];
-  const roots = nodeDefinitions.filter((nodeDefinition) => (incomingCount.get(nodeDefinition.nodeKey) ?? 0) === 0);
-  if (roots.length !== 1)
-    return null;
-  const rootNode = roots[0];
-  if (!rootNode)
-    return null;
-  const ordered = [];
-  const visited = new Set;
-  let currentKey = rootNode.nodeKey;
-  while (currentKey !== undefined) {
-    if (visited.has(currentKey))
-      return null;
-    visited.add(currentKey);
-    const currentNode = nodesByKey.get(currentKey);
-    if (!currentNode)
-      return null;
-    ordered.push(currentNode);
-    currentKey = outgoing.get(currentKey);
-  }
-  if (ordered.length !== nodeDefinitions.length)
-    return null;
-  return ordered;
-}
-function buildChainDependencyEdges(orderedNodes) {
-  const dependencyEdges = [];
-  for (let index = 0;index < orderedNodes.length - 1; index += 1) {
-    const from = orderedNodes[index];
-    const to = orderedNodes[index + 1];
-    if (!from || !to)
-      continue;
-    dependencyEdges.push({ fromNodeKey: from.nodeKey, toNodeKey: to.nodeKey });
-  }
-  return dependencyEdges;
-}
-
-// src/definitions/pipelines/define-pipeline.ts
-function serializeBinding(binding) {
-  if (binding.source === "pipeline_input") {
-    return { source: "pipeline_input", path: binding.path };
-  }
-  if (binding.source === "work_item") {
-    return { source: "work_item", field: binding.field };
-  }
-  if (binding.source === "step_signal") {
+// src/definitions/advancement-policies/cohort-advancement-policy.ts
+var cohortAdvancementEventTypeValues = ["continue", "block"];
+function serializeCohortCondition(condition) {
+  if (condition._tag === "signal") {
     return {
-      source: "step_signal",
-      stepKey: binding.step.key,
-      signalKey: binding.signalKey
+      fact: typeof condition.signal === "string" ? condition.signal : condition.signal.key,
+      operator: condition.operator,
+      value: condition.value
     };
   }
-  if (binding.source === "literal") {
-    return { source: "literal", value: binding.value };
-  }
-  if (binding.source === "signals_list") {
-    return { source: "signals_list", stepKey: binding.fanOutStep.key };
-  }
-  if (binding.source === "fan_out_item") {
-    return { source: "fan_out_item" };
-  }
-  return { source: "step_output", stepKey: binding.step.key };
-}
-var isFanOutConfig = (node) => ("nodeType" in node) && node.nodeType === "fanOut";
-var isCohortGateConfig = (node) => ("nodeType" in node) && node.nodeType === "cohortGate";
-function serializeInputBindings(input, pipelineInputBindings) {
-  const autoBindings = {
-    workItemTitle: { source: "work_item", field: "title" },
-    workItemDescription: { source: "work_item", field: "description" }
-  };
-  const pipelineBindings = {};
-  for (const [key, binding] of Object.entries(pipelineInputBindings ?? {})) {
-    pipelineBindings[key] = serializeBinding(binding);
-  }
-  const explicitBindings = Object.fromEntries(Object.entries(input ?? {}).filter((entry) => entry[1] !== undefined).map(([key, binding]) => [key, serializeBinding(binding)]));
-  return { ...autoBindings, ...pipelineBindings, ...explicitBindings };
-}
-function buildPipelineSpec(config2) {
-  const nodes = config2.nodes;
-  const stepDefMap = new Map;
-  const registerStepDef = (step) => {
-    const mapKey = `${step.key}@v${String(step.version)}`;
-    if (!stepDefMap.has(mapKey)) {
-      stepDefMap.set(mapKey, step);
-    }
-  };
-  for (const node of nodes) {
-    if (isFanOutConfig(node)) {
-      registerStepDef(node.fanOutStep);
-    } else if (!isCohortGateConfig(node)) {
-      registerStepDef(node.step);
-    }
-  }
-  let inputSchemaJson = null;
-  if (config2.input) {
-    try {
-      inputSchemaJson = exports_external.toJSONSchema(config2.input);
-    } catch {
-      inputSchemaJson = null;
-    }
+  if (condition._tag === "all") {
+    return { all: condition.conditions.map(serializeCohortCondition) };
   }
-  const nodeDefinitions = nodes.map((node) => {
-    if (isCohortGateConfig(node)) {
-      const serializedPolicy = serializeCohortAdvancementPolicy(node.advanceAll);
-      const inlineStepSignalsListDefinitions = extractInlineStepSignalsListDefinitions(node.advanceAll);
-      return {
-        nodeKey: node.nodeKey,
-        kind: "cohortGate",
-        advanceAllPolicyDefinition: serializedPolicy,
-        stepSignalsListDefinitions: [
-          ...inlineStepSignalsListDefinitions,
-          ...node.stepSignalsListDefinitions ?? []
-        ]
-      };
-    }
-    if (isFanOutConfig(node)) {
-      return {
-        nodeKey: node.fanOutStep.key,
-        kind: "fanOut",
-        stepKey: node.fanOutStep.key,
-        stepName: node.fanOutStep.name,
-        stepDescription: node.fanOutStep.description,
-        inputBindingsJson: serializeInputBindings(node.input, config2.pipelineInputBindings),
-        timeoutSeconds: node.timeout ?? null,
-        overSignalKey: node.overSignalKey,
-        advanceEachPolicyDefinition: serializeCohortAdvancementPolicy(node.advanceEach)
-      };
-    }
-    return {
-      nodeKey: node.step.key,
-      kind: "step",
-      stepKey: node.step.key,
-      stepName: node.step.name,
-      stepDescription: node.step.description,
-      inputBindingsJson: serializeInputBindings(node.input, config2.pipelineInputBindings),
-      timeoutSeconds: node.timeout ?? null,
-      advancementPolicyDefinition: serializeAdvancementPolicy(node.advancement),
-      computedSignalDefinitions: extractInlineComputedSignals(node.advancement)
-    };
-  });
-  const dependencyEdges = buildChainDependencyEdges(nodeDefinitions);
-  return {
-    key: config2.key,
-    name: config2.name,
-    description: config2.description ?? null,
-    version: config2.version ?? 1,
-    status: config2.status ?? "active",
-    inputSchemaJson,
-    _stepDefinitions: [...stepDefMap.values()],
-    nodeDefinitions,
-    dependencyEdges
-  };
-}
-// src/definitions/advancement-policies/fluent-rules.ts
-var LEAF_BRAND = Symbol.for("boboddy.fluentRule.leaf");
-var GROUP_BRAND = Symbol.for("boboddy.fluentRule.group");
-var SIGNAL_KEY = Symbol.for("boboddy.fluentRule.signalKey");
-function createSignalRef(signal2) {
-  const leaf = (operator, value) => {
-    const condition = {
-      _tag: "signal",
-      signal: signal2,
-      operator,
-      value
-    };
-    return {
-      [LEAF_BRAND]: condition,
-      then(outcome) {
-        return {
-          _tag: "rule",
-          mode: "all",
-          conditions: [condition],
-          outcome
-        };
-      }
-    };
-  };
-  return {
-    eq: (v) => leaf("equal", v),
-    ne: (v) => leaf("notEqual", v),
-    gt: (v) => leaf("greaterThan", v),
-    gte: (v) => leaf("greaterThanInclusive", v),
-    lt: (v) => leaf("lessThan", v),
-    lte: (v) => leaf("lessThanInclusive", v),
-    in: (vs) => leaf("in", vs),
-    notIn: (vs) => leaf("notIn", vs),
-    contains: (v) => leaf("contains", v),
-    doesNotContain: (v) => leaf("doesNotContain", v)
-  };
-}
-function extractCondition(ref) {
-  if (LEAF_BRAND in ref)
-    return ref[LEAF_BRAND];
-  const group = ref[GROUP_BRAND];
-  return group.mode === "all" ? { _tag: "all", conditions: group.conditions } : { _tag: "any", conditions: group.conditions };
-}
-function createGroup(mode, refs) {
-  const conditions = refs.map(extractCondition);
-  return {
-    [GROUP_BRAND]: { mode, conditions },
-    then(outcome) {
-      return { _tag: "rule", mode, conditions, outcome };
-    }
-  };
-}
-function resolveComputedArg(arg) {
-  return arg[SIGNAL_KEY];
-}
-function makeKeyedSignalRef(key) {
-  const ref = createSignalRef(key);
-  return Object.assign(ref, {
-    [SIGNAL_KEY]: key
-  });
+  return { any: condition.conditions.map(serializeCohortCondition) };
 }
-function makeAdvanceCtx() {
-  const wrapComputed = (token) => createSignalRef(token);
+function serializeCohortRule(rule) {
   return {
-    signal: (key) => makeKeyedSignalRef(key),
-    stepSignals: new Proxy({}, {
-      get(_, key) {
-        if (typeof key === "string")
-          return makeKeyedSignalRef(key);
-        return;
-      }
-    }),
-    avg: (...args) => wrapComputed(Computed.average(args.map(resolveComputedArg))),
-    weightedAvg: (...args) => wrapComputed(Computed.weightedAverage(args.map(resolveComputedArg))),
-    sum: (...args) => wrapComputed(Computed.sum(args.map(resolveComputedArg))),
-    min: (...args) => wrapComputed(Computed.min(args.map(resolveComputedArg))),
-    max: (...args) => wrapComputed(Computed.max(args.map(resolveComputedArg))),
-    count: (...args) => wrapComputed(Computed.count(args.map(resolveComputedArg))),
-    booleanAny: (...args) => wrapComputed(Computed.booleanAny(args.map(resolveComputedArg))),
-    booleanAll: (...args) => wrapComputed(Computed.booleanAll(args.map(resolveComputedArg))),
-    all: (...refs) => createGroup("all", refs),
-    any: (...refs) => createGroup("any", refs),
-    route: (pipelineKey, inputJson) => inputJson !== undefined ? { outcome: "route", pipelineKey, inputJson } : { outcome: "route", pipelineKey }
-  };
-}
-
-// src/definitions/pipelines/input-accessor.ts
-var ACCESSOR_BRAND = Symbol.for("boboddy.inputAccessor.brand");
-var ACCESSOR_PATH = Symbol.for("boboddy.inputAccessor.path");
-function createInputAccessor(_schema) {
-  return createProxy([]);
-}
-function createProxy(path) {
-  const pathStr = path.join(".");
-  const target = Object.freeze({});
-  return new Proxy(target, {
-    get(_t, prop) {
-      if (prop === ACCESSOR_BRAND)
-        return true;
-      if (prop === ACCESSOR_PATH)
-        return pathStr;
-      if (prop === "toJSON") {
-        return () => ({
-          source: "pipeline_input",
-          path: pathStr
-        });
-      }
-      if (prop === Symbol.toPrimitive) {
-        return () => {
-          throw new Error(`Pipeline input accessor at path "${pathStr || "<root>"}" cannot be coerced to a primitive. ` + `Pass it to a step input field instead of using it in a string/number expression.`);
-        };
-      }
-      if (typeof prop === "symbol")
-        return;
-      return createProxy([...path, prop]);
-    },
-    has(_t, prop) {
-      return prop === ACCESSOR_BRAND || prop === ACCESSOR_PATH;
-    },
-    ownKeys() {
-      throw new Error(`Pipeline input accessor at path "${pathStr || "<root>"}" cannot be enumerated. ` + `Drill into specific fields instead of spreading the input.`);
-    },
-    set() {
-      throw new Error(`Pipeline input accessor at path "${pathStr || "<root>"}" is read-only.`);
+    conditions: { [rule.mode]: rule.conditions.map(serializeCohortCondition) },
+    event: {
+      type: rule.outcome,
+      ...rule.outcomeJson ? { params: rule.outcomeJson } : {}
     }
-  });
-}
-function isInputAccessor(value) {
-  return typeof value === "object" && value !== null && value[ACCESSOR_BRAND] === true;
-}
-function materializeAccessor(accessor) {
-  return {
-    source: "pipeline_input",
-    path: accessor[ACCESSOR_PATH]
   };
 }
-
-// src/definitions/pipelines/work-item-fields.ts
-var WORK_ITEM_TOP_LEVEL_FIELDS = [
-  "id",
-  "projectId",
-  "platform",
-  "platformId",
-  "platformKey",
-  "url",
-  "title",
-  "description",
-  "sourceCreatedAt",
-  "sourceUpdatedAt",
-  "createdByUserId",
-  "parentWorkItemId",
-  "createdAt",
-  "updatedAt"
-];
-var WORK_ITEM_FIELDS_PATH_PREFIX = "fields.";
-function resolveWorkItemFieldPath(record2, path) {
-  if (typeof record2 !== "object" || record2 === null)
-    return;
-  const asRecord = record2;
-  if (path.startsWith(WORK_ITEM_FIELDS_PATH_PREFIX)) {
-    const fieldName = path.slice(WORK_ITEM_FIELDS_PATH_PREFIX.length);
-    const fields = asRecord["fields"];
-    if (typeof fields !== "object" || fields === null)
-      return;
-    return fields[fieldName];
+function serializeCohortAdvancementPolicy(policy) {
+  if (!policy) {
+    return { rules: [], defaultEventType: "continue", defaultEventParamsJson: null };
   }
-  return asRecord[path];
-}
-
-// src/definitions/pipelines/builder-helpers.ts
-var WORK_ITEM_ACCESSOR = Object.freeze({
-  ...Object.fromEntries(WORK_ITEM_TOP_LEVEL_FIELDS.map((field) => [
-    field,
-    Object.freeze({ source: "work_item", field })
-  ])),
-  field: (fieldName) => Object.freeze({
-    source: "work_item",
-    field: `${WORK_ITEM_FIELDS_PATH_PREFIX}${fieldName}`
-  })
-});
-var WORK_ITEM_FIELD_BINDINGS = {
-  workItemTitle: { source: "work_item", field: "title" },
-  workItemDescription: { source: "work_item", field: "description" }
-};
-function makeStepInputCtx(inputSchema) {
-  const baseAccessor = createInputAccessor(inputSchema);
-  const input = new Proxy(baseAccessor, {
-    get(target, prop) {
-      if (typeof prop === "string" && prop in WORK_ITEM_FIELD_BINDINGS) {
-        return WORK_ITEM_FIELD_BINDINGS[prop];
-      }
-      return target[prop];
-    }
-  });
   return {
-    input,
-    signal(step, key) {
-      return { source: "step_signal", step, signalKey: key };
-    },
-    output(step) {
-      return { source: "step_output", step };
-    },
-    literal: literal2,
-    signalsList(fanOutStep) {
-      return { source: "signals_list", fanOutStep };
-    }
+    rules: (policy.rules ?? []).map(serializeCohortRule),
+    defaultEventType: policy.default,
+    defaultEventParamsJson: policy.defaultParamsJson ?? null
   };
 }
-function literal2(value) {
-  return { source: "literal", value };
-}
-function normalizeInputMapping(mapping) {
-  if (!mapping)
-    return;
-  const out = {};
-  for (const [key, value] of Object.entries(mapping)) {
-    if (value === undefined)
-      continue;
-    out[key] = isInputAccessor(value) ? materializeAccessor(value) : value;
-  }
-  return out;
-}
-function resolveAdditionalStepInputBindings(label, definition) {
-  if (!definition) {
-    return {};
-  }
-  const raw = definition.bindings({
-    workItemField: (fieldName) => ({
-      source: "work_item",
-      field: `${WORK_ITEM_FIELDS_PATH_PREFIX}${fieldName}`
-    }),
-    literal: literal2
-  });
-  if (definition.schema instanceof exports_external.ZodObject) {
-    const validKeys = new Set(Object.keys(definition.schema.shape));
-    const unknown2 = Object.keys(raw).filter((key) => !validKeys.has(key));
-    if (unknown2.length > 0) {
-      throw new Error(`${label}.bindings returned key${unknown2.length > 1 ? "s" : ""} not in schema: ${unknown2.map((key) => `"${key}"`).join(", ")}`);
+function visitCohortSignalConditions(conditions, visit) {
+  for (const c of conditions) {
+    if (c._tag === "signal") {
+      visit(c);
+    } else {
+      visitCohortSignalConditions(c.conditions, visit);
     }
   }
-  return normalizeInputMapping(raw) ?? {};
 }
-function mergeStepBindings(pipelineBindings, explicitBindings) {
-  const merged = {
-    ...pipelineBindings,
-    ...explicitBindings ?? {}
-  };
-  return Object.keys(merged).length > 0 ? merged : undefined;
+function isSameStepSignalsListDefinition(a, b) {
+  return JSON.stringify(a.ops) === JSON.stringify(b.ops) && JSON.stringify(a.reducer) === JSON.stringify(b.reducer);
+}
+function extractInlineStepSignalsListDefinitions(policy) {
+  if (!policy?.rules)
+    return [];
+  const byKey = new Map;
+  for (const rule of policy.rules) {
+    visitCohortSignalConditions(rule.conditions, (cond) => {
+      if (typeof cond.signal === "string")
+        return;
+      const inline = cond.signal;
+      const def = {
+        key: inline.key,
+        ops: inline.ops,
+        reducer: inline.reducer
+      };
+      const existing = byKey.get(def.key);
+      if (existing) {
+        if (!isSameStepSignalsListDefinition(existing, def)) {
+          throw new Error(`Conflicting inline stepSignalsList definitions for key "${def.key}"`);
+        }
+        return;
+      }
+      byKey.set(def.key, def);
+    });
+  }
+  return [...byKey.values()];
 }
 
 // src/definitions/advancement-policies/cohort-fluent-rules.ts
-var LEAF_BRAND2 = Symbol("boboddy.cohortRule.leaf");
-var GROUP_BRAND2 = Symbol("boboddy.cohortRule.group");
+var LEAF_BRAND = Symbol("boboddy.cohortRule.leaf");
+var GROUP_BRAND = Symbol("boboddy.cohortRule.group");
 function createCohortSignalRef(signal2) {
   const leaf = (operator, value) => {
     const condition = {
@@ -14946,7 +14528,7 @@ function createCohortSignalRef(signal2) {
       value
     };
     return {
-      [LEAF_BRAND2]: condition,
+      [LEAF_BRAND]: condition,
       then(outcome, paramsJson) {
         return {
           _tag: "rule",
@@ -14973,7 +14555,7 @@ function createCohortSignalRef(signal2) {
 }
 function createCohortLeafFromCondition(condition) {
   return {
-    [LEAF_BRAND2]: condition,
+    [LEAF_BRAND]: condition,
     then(outcome, paramsJson) {
       return {
         _tag: "rule",
@@ -14986,15 +14568,15 @@ function createCohortLeafFromCondition(condition) {
   };
 }
 function extractCohortCondition(ref) {
-  if (LEAF_BRAND2 in ref)
-    return ref[LEAF_BRAND2];
-  const group = ref[GROUP_BRAND2];
+  if (LEAF_BRAND in ref)
+    return ref[LEAF_BRAND];
+  const group = ref[GROUP_BRAND];
   return group.mode === "all" ? { _tag: "all", conditions: group.conditions } : { _tag: "any", conditions: group.conditions };
 }
 function createCohortGroup(mode, refs) {
   const conditions = refs.map(extractCohortCondition);
   return {
-    [GROUP_BRAND2]: { mode, conditions },
+    [GROUP_BRAND]: { mode, conditions },
     then(outcome, paramsJson) {
       return {
         _tag: "rule",
@@ -15099,132 +14681,385 @@ function makeAdvanceAllCtx() {
   };
 }
 
-// src/definitions/pipelines/fan-out-builder.ts
-function beginFanOut(inputSchema, meta3, nodes, pipelineInputBindings, pipelineStepInputBindings, step, config2) {
-  const baseCtx = makeStepInputCtx(inputSchema);
-  const ctx = {
-    ...baseCtx,
+// src/definitions/pipelines/bindings.ts
+function serializeBinding(binding) {
+  if (binding.source === "pipeline_input") {
+    return { source: "pipeline_input", path: binding.path };
+  }
+  if (binding.source === "work_item") {
+    return { source: "work_item", field: binding.field };
+  }
+  if (binding.source === "step_signal") {
+    return {
+      source: "step_signal",
+      stepKey: binding.nodeKey,
+      signalKey: binding.signalKey
+    };
+  }
+  if (binding.source === "literal") {
+    return { source: "literal", value: binding.value };
+  }
+  if (binding.source === "signals_list") {
+    return { source: "signals_list", stepKey: binding.nodeKey };
+  }
+  if (binding.source === "fan_out_item") {
+    return { source: "fan_out_item" };
+  }
+  return { source: "step_output", stepKey: binding.nodeKey };
+}
+function serializeInputBindings(input) {
+  const autoBindings = {
+    workItemTitle: { source: "work_item", field: "title" },
+    workItemDescription: { source: "work_item", field: "description" }
+  };
+  const explicitBindings = Object.fromEntries(Object.entries(input).filter((entry) => entry[1] !== undefined).map(([key, binding]) => [key, serializeBinding(binding)]));
+  return { ...autoBindings, ...explicitBindings };
+}
+
+// src/definitions/pipelines/work-item-fields.ts
+var WORK_ITEM_TOP_LEVEL_FIELDS = [
+  "id",
+  "projectId",
+  "platform",
+  "platformId",
+  "platformKey",
+  "url",
+  "title",
+  "description",
+  "sourceCreatedAt",
+  "sourceUpdatedAt",
+  "createdByUserId",
+  "parentWorkItemId",
+  "createdAt",
+  "updatedAt"
+];
+var WORK_ITEM_FIELDS_PATH_PREFIX = "fields.";
+function resolveWorkItemFieldPath(record2, path) {
+  if (typeof record2 !== "object" || record2 === null)
+    return;
+  const asRecord = record2;
+  if (path.startsWith(WORK_ITEM_FIELDS_PATH_PREFIX)) {
+    const fieldName = path.slice(WORK_ITEM_FIELDS_PATH_PREFIX.length);
+    const fields = asRecord["fields"];
+    if (typeof fields !== "object" || fields === null)
+      return;
+    return fields[fieldName];
+  }
+  return asRecord[path];
+}
+
+// src/definitions/pipelines/builder-helpers.ts
+var WORK_ITEM_ACCESSOR = Object.freeze({
+  ...Object.fromEntries(WORK_ITEM_TOP_LEVEL_FIELDS.map((field) => [
+    field,
+    Object.freeze({ source: "work_item", field })
+  ])),
+  field: (fieldName) => Object.freeze({
+    source: "work_item",
+    field: `${WORK_ITEM_FIELDS_PATH_PREFIX}${fieldName}`
+  })
+});
+function literal2(value) {
+  return { source: "literal", value };
+}
+
+// src/definitions/pipelines/node-input-ctx.ts
+function makeBaseNodeInputCtx() {
+  return {
+    pipelineInput: (path) => ({ source: "pipeline_input", path }),
+    workItem: WORK_ITEM_ACCESSOR,
+    signal: (nodeKey, signalKey) => ({
+      source: "step_signal",
+      nodeKey,
+      signalKey
+    }),
+    output: (nodeKey) => ({ source: "step_output", nodeKey }),
+    signalsList: (nodeKey) => ({ source: "signals_list", nodeKey }),
+    literal: literal2
+  };
+}
+function makeNodeInputCtx() {
+  return makeBaseNodeInputCtx();
+}
+function makeFanOutNodeInputCtx() {
+  return {
+    ...makeBaseNodeInputCtx(),
     item: { source: "fan_out_item" }
   };
-  const rawInput = config2.input ? config2.input(ctx) : {};
-  const input = mergeStepBindings(pipelineStepInputBindings, normalizeInputMapping(rawInput));
-  const fanOutNodeConfig = {
-    nodeType: "fanOut",
-    fanOutStep: step,
-    overSignalKey: config2.over,
-    ...input ? { input } : {},
-    ...config2.timeout !== undefined ? { timeout: config2.timeout } : {}
-  };
-  const advanceEachCtx = makeAdvanceEachCtx();
-  const advanceEachResult = config2.advance(advanceEachCtx);
+}
+
+// src/definitions/pipelines/compile-node-definitions.ts
+function assertTargetExists(ctx, fromKey, toKey) {
+  if (!ctx.stateKeys.has(toKey)) {
+    throw new Error(`Pipeline "${ctx.pipelineKey}": state "${fromKey}" targets unknown state "${toKey}"`);
+  }
+}
+function overSignalKeyOf(over) {
+  const lastDot = over.lastIndexOf(".");
+  return lastDot === -1 ? over : over.slice(lastDot + 1);
+}
+function compileStepState(stateKey, state, ctx) {
+  ctx.registerStep(state.step);
+  const inputCtx = makeNodeInputCtx();
+  const rawInput = state.input ? state.input(inputCtx) : {};
+  const inputBindingsJson = serializeInputBindings(rawInput);
+  const routeTarget = typeof state.next === "object" ? state.next : null;
+  const defaultOutcome = routeTarget ? {
+    outcome: "route",
+    pipelineKey: routeTarget.routeToPipeline,
+    ...routeTarget.input ? { inputJson: routeTarget.input } : {}
+  } : "continue";
+  const rules = state.blockWhen ? [{ _tag: "rule", mode: "all", conditions: [state.blockWhen], outcome: "block" }] : [];
+  const policy = { defaultOutcome, rules };
+  const nodeDefinitions = [
+    {
+      nodeKey: stateKey,
+      kind: "step",
+      stepKey: state.step.key,
+      stepName: state.step.name,
+      stepDescription: state.step.description,
+      inputBindingsJson,
+      timeoutSeconds: state.timeout ?? null,
+      advancementPolicyDefinition: serializeAdvancementPolicy(policy),
+      computedSignalDefinitions: extractInlineComputedSignals(policy)
+    }
+  ];
+  const edges = [];
+  if (!routeTarget) {
+    const nextKey = state.next;
+    assertTargetExists(ctx, stateKey, nextKey);
+    edges.push({ fromNodeKey: stateKey, toNodeKey: nextKey });
+  }
+  return { nodeDefinitions, edges };
+}
+function compileChoiceState(stateKey, state, ctx) {
+  const stateChoices = state.choices ?? [];
+  if (stateChoices.length === 0 && !state.default) {
+    throw new Error(`Pipeline "${ctx.pipelineKey}": choice state "${stateKey}" requires at least one entry in choices or a default target`);
+  }
+  const choices = stateChoices.map((choiceCase) => {
+    assertTargetExists(ctx, stateKey, choiceCase.next);
+    return {
+      conditionJson: serializeCondition(choiceCase.when),
+      targetNodeKey: choiceCase.next
+    };
+  });
+  if (state.default)
+    assertTargetExists(ctx, stateKey, state.default);
+  const edges = stateChoices.map((choiceCase) => ({
+    fromNodeKey: stateKey,
+    toNodeKey: choiceCase.next,
+    discriminantJson: { conditionSummary: serializeCondition(choiceCase.when) }
+  }));
+  if (state.default) {
+    edges.push({
+      fromNodeKey: stateKey,
+      toNodeKey: state.default,
+      discriminantJson: { default: true }
+    });
+  }
+  return {
+    nodeDefinitions: [
+      { nodeKey: stateKey, kind: "choice", choices, default: state.default ?? null }
+    ],
+    edges
+  };
+}
+function compileFanOutState(stateKey, state, ctx) {
+  ctx.registerStep(state.step);
+  const inputCtx = makeFanOutNodeInputCtx();
+  const rawInput = state.input ? state.input(inputCtx) : {};
+  const inputBindingsJson = serializeInputBindings(rawInput);
+  const advanceEachResult = state.advanceEach(makeAdvanceEachCtx());
   const advanceEachPolicy = {
     default: advanceEachResult.default,
     ...advanceEachResult.rules !== undefined ? { rules: advanceEachResult.rules } : {}
   };
-  fanOutNodeConfig.advanceEach = advanceEachPolicy;
-  const cohortGateNodeConfig = {
-    nodeType: "cohortGate",
-    nodeKey: `${step.key}__cohortGate`
-  };
-  const advanceAllCtx = makeAdvanceAllCtx();
-  const advanceAllResult = config2.advanceAll(advanceAllCtx);
+  const advanceAllResult = state.advanceAll(makeAdvanceAllCtx());
   const advanceAllPolicy = {
     default: advanceAllResult.default,
     ...advanceAllResult.rules !== undefined ? { rules: advanceAllResult.rules } : {}
   };
-  cohortGateNodeConfig.advanceAll = advanceAllPolicy;
-  nodes.push(fanOutNodeConfig, cohortGateNodeConfig);
-  return new PipelineStepBuilder(inputSchema, meta3, nodes, pipelineInputBindings, pipelineStepInputBindings);
-}
-
-// src/definitions/pipelines/builder.ts
-function pushStep(inputSchema, meta3, nodes, pipelineInputBindings, pipelineStepInputBindings, step, rawOptions) {
-  const options = rawOptions;
-  const ctx = makeStepInputCtx(inputSchema);
-  const rawInput = options.input ? options.input(ctx) : {};
-  const input = mergeStepBindings(pipelineStepInputBindings, normalizeInputMapping(rawInput));
-  const stepConfig = { step, input };
-  if (options.timeout !== undefined)
-    stepConfig.timeout = options.timeout;
-  const advanceCtx = makeAdvanceCtx();
-  const result = options.advance(advanceCtx);
-  const policy = {
-    defaultOutcome: result.default,
-    ...result.rules !== undefined ? { rules: result.rules } : {}
-  };
-  stepConfig.advancement = policy;
-  nodes.push(stepConfig);
-  return new PipelineStepBuilder(inputSchema, meta3, nodes, pipelineInputBindings, pipelineStepInputBindings);
-}
-
-class PipelineStepBuilder {
-  inputSchema;
-  meta;
-  nodes;
-  pipelineInputBindings;
-  pipelineStepInputBindings;
-  constructor(inputSchema, meta3, nodes, pipelineInputBindings = {}, pipelineStepInputBindings = {}) {
-    this.inputSchema = inputSchema;
-    this.meta = meta3;
-    this.nodes = nodes;
-    this.pipelineInputBindings = pipelineInputBindings;
-    this.pipelineStepInputBindings = pipelineStepInputBindings;
-  }
-  step(step, options) {
-    return pushStep(this.inputSchema, this.meta, this.nodes, this.pipelineInputBindings, this.pipelineStepInputBindings, step, options);
-  }
-  fanOutStep(step, config2) {
-    return beginFanOut(this.inputSchema, this.meta, this.nodes, this.pipelineInputBindings, this.pipelineStepInputBindings, step, config2);
-  }
-  build() {
-    const config2 = {
-      key: this.meta.key,
-      name: this.meta.name,
-      description: this.meta.description,
-      version: this.meta.version,
-      status: this.meta.status,
-      input: this.inputSchema,
-      nodes: this.nodes,
-      pipelineInputBindings: this.pipelineInputBindings
+  const gateKey = `${stateKey}__cohortGate`;
+  if (ctx.stateKeys.has(gateKey)) {
+    throw new Error(`Pipeline "${ctx.pipelineKey}": synthesized cohortGate key "${gateKey}" collides with an author-declared state \u2014 rename state "${stateKey}"`);
+  }
+  assertTargetExists(ctx, stateKey, state.next);
+  return {
+    nodeDefinitions: [
+      {
+        nodeKey: stateKey,
+        kind: "fanOut",
+        stepKey: state.step.key,
+        stepName: state.step.name,
+        stepDescription: state.step.description,
+        inputBindingsJson,
+        timeoutSeconds: state.timeout ?? null,
+        overSignalKey: overSignalKeyOf(state.over),
+        advanceEachPolicyDefinition: serializeCohortAdvancementPolicy(advanceEachPolicy),
+        maxConcurrency: state.maxConcurrency ?? null
+      },
+      {
+        nodeKey: gateKey,
+        kind: "cohortGate",
+        advanceAllPolicyDefinition: serializeCohortAdvancementPolicy(advanceAllPolicy),
+        stepSignalsListDefinitions: extractInlineStepSignalsListDefinitions(advanceAllPolicy)
+      }
+    ],
+    edges: [
+      { fromNodeKey: stateKey, toNodeKey: gateKey },
+      { fromNodeKey: gateKey, toNodeKey: state.next }
+    ]
+  };
+}
+function compileParallelState(stateKey, state, ctx) {
+  const branchEntries = Object.entries(state.branches);
+  if (branchEntries.length === 0) {
+    throw new Error(`Pipeline "${ctx.pipelineKey}": parallel state "${stateKey}" requires at least one branch`);
+  }
+  const branches = {};
+  for (const [branchKey, branchConfig] of branchEntries) {
+    ctx.registerStep(branchConfig.step);
+    const inputCtx = makeNodeInputCtx();
+    const rawInput = branchConfig.input ? branchConfig.input(inputCtx) : {};
+    branches[branchKey] = {
+      stepKey: branchConfig.step.key,
+      stepName: branchConfig.step.name,
+      stepDescription: branchConfig.step.description,
+      inputBindingsJson: serializeInputBindings(rawInput)
+    };
+  }
+  let advanceAllPolicyDefinition;
+  if (state.advanceAll) {
+    const advanceAllResult = state.advanceAll(makeAdvanceAllCtx());
+    const advanceAllPolicy = {
+      default: advanceAllResult.default,
+      ...advanceAllResult.rules !== undefined ? { rules: advanceAllResult.rules } : {}
     };
-    return buildPipelineSpec(config2);
+    advanceAllPolicyDefinition = serializeCohortAdvancementPolicy(advanceAllPolicy);
+  }
+  assertTargetExists(ctx, stateKey, state.next);
+  return {
+    nodeDefinitions: [
+      {
+        nodeKey: stateKey,
+        kind: "parallel",
+        branches,
+        ...advanceAllPolicyDefinition ? { advanceAllPolicyDefinition } : {}
+      }
+    ],
+    edges: [{ fromNodeKey: stateKey, toNodeKey: state.next }]
+  };
+}
+function compileLoopState(stateKey, state, ctx) {
+  ctx.registerStep(state.step);
+  const inputCtx = makeNodeInputCtx();
+  const rawInput = state.input ? state.input(inputCtx) : {};
+  assertTargetExists(ctx, stateKey, state.next);
+  assertTargetExists(ctx, stateKey, state.onExhausted);
+  return {
+    nodeDefinitions: [
+      {
+        nodeKey: stateKey,
+        kind: "loop",
+        stepKey: state.step.key,
+        stepName: state.step.name,
+        stepDescription: state.step.description,
+        inputBindingsJson: serializeInputBindings(rawInput),
+        timeoutSeconds: state.timeout ?? null,
+        maxIterations: state.maxIterations,
+        untilConditionJson: serializeCondition(state.until)
+      }
+    ],
+    edges: [
+      { fromNodeKey: stateKey, toNodeKey: state.next, discriminantJson: { loopExit: "next" } },
+      {
+        fromNodeKey: stateKey,
+        toNodeKey: state.onExhausted,
+        discriminantJson: { loopExit: "onExhausted" }
+      }
+    ]
+  };
+}
+function compileTerminalState(stateKey, kind) {
+  return { nodeDefinitions: [{ nodeKey: stateKey, kind }], edges: [] };
+}
+function assertNoIllegalConvergentEdges(pipelineKey, nodeKindByKey, edges) {
+  const incoming = new Map;
+  for (const edge of edges) {
+    const list = incoming.get(edge.toNodeKey) ?? [];
+    list.push(edge);
+    incoming.set(edge.toNodeKey, list);
+  }
+  for (const [targetKey, incomingEdges] of incoming) {
+    if (incomingEdges.length <= 1)
+      continue;
+    const hasInvalidSource = incomingEdges.some((edge) => {
+      const kind = nodeKindByKey.get(edge.fromNodeKey);
+      return kind !== "choice" && kind !== "loop";
+    });
+    if (hasInvalidSource) {
+      throw new Error(`Pipeline "${pipelineKey}": state "${targetKey}" has more than one incoming edge, but not every source is a 'choice'/'loop' state (unconditional convergent edges are not allowed \u2014 see docs/research/flat-pipeline-sdk-and-visual-designer.md \xA76).`);
+    }
   }
 }
 
-class PipelineBuilder {
-  inputSchema;
-  meta;
-  nodes = [];
-  pipelineInputBindings;
-  pipelineStepInputBindings;
-  constructor(meta3) {
-    const { additionalPipelineInput, additionalStepInput, ...rest } = meta3;
-    this.inputSchema = additionalPipelineInput?.schema ?? exports_external.unknown();
-    this.meta = rest;
-    if (additionalPipelineInput) {
-      const raw = additionalPipelineInput.bindings({
-        workItem: WORK_ITEM_ACCESSOR,
-        literal: literal2
-      });
-      if (additionalPipelineInput.schema instanceof exports_external.ZodObject) {
-        const validKeys = new Set(Object.keys(additionalPipelineInput.schema.shape));
-        const unknown2 = Object.keys(raw).filter((k) => !validKeys.has(k));
-        if (unknown2.length > 0) {
-          throw new Error(`additionalPipelineInput.bindings returned key${unknown2.length > 1 ? "s" : ""} not in schema: ${unknown2.map((k) => `"${k}"`).join(", ")}`);
-        }
-      }
-      this.pipelineInputBindings = normalizeInputMapping(raw) ?? {};
-    } else {
-      this.pipelineInputBindings = {};
-    }
-    this.pipelineStepInputBindings = resolveAdditionalStepInputBindings("additionalStepInput", additionalStepInput);
+// src/definitions/pipelines/define-pipeline.ts
+function isWorkingNodeDefinition(node) {
+  return node.kind === "step" || node.kind === "fanOut" || node.kind === "loop";
+}
+function definePipeline(config2) {
+  const stateEntries = Object.entries(config2.states);
+  if (stateEntries.length === 0) {
+    throw new Error(`Pipeline "${config2.key}" must declare at least one state`);
   }
-  step(step, options) {
-    return pushStep(this.inputSchema, this.meta, this.nodes, this.pipelineInputBindings, this.pipelineStepInputBindings, step, options);
+  const startState = config2.states[config2.startAt];
+  if (!startState) {
+    throw new Error(`Pipeline "${config2.key}"'s startAt "${config2.startAt}" does not name a declared state`);
   }
-}
-function pipeline(meta3) {
-  return new PipelineBuilder(meta3);
+  if (startState.kind === "choice" || startState.kind === "succeed" || startState.kind === "fail") {
+    throw new Error(`Pipeline "${config2.key}"'s startAt "${config2.startAt}" names a '${startState.kind}' state, which cannot be an entry point`);
+  }
+  const stateKeys = new Set(Object.keys(config2.states));
+  const stepDefMap = new Map;
+  const registerStep = (step) => {
+    const mapKey = `${step.key}@v${String(step.version)}`;
+    if (!stepDefMap.has(mapKey))
+      stepDefMap.set(mapKey, step);
+  };
+  const compileContext = {
+    pipelineKey: config2.key,
+    stateKeys,
+    registerStep
+  };
+  const nodeDefinitions = [];
+  const dependencyEdges = [];
+  for (const [stateKey, state] of stateEntries) {
+    const compiled = state.kind === "step" ? compileStepState(stateKey, state, compileContext) : state.kind === "choice" ? compileChoiceState(stateKey, state, compileContext) : state.kind === "fanOut" ? compileFanOutState(stateKey, state, compileContext) : state.kind === "parallel" ? compileParallelState(stateKey, state, compileContext) : state.kind === "loop" ? compileLoopState(stateKey, state, compileContext) : compileTerminalState(stateKey, state.kind);
+    nodeDefinitions.push(...compiled.nodeDefinitions);
+    dependencyEdges.push(...compiled.edges);
+  }
+  const nodeKindByKey = new Map(nodeDefinitions.map((node) => [node.nodeKey, node.kind]));
+  assertNoIllegalConvergentEdges(config2.key, nodeKindByKey, dependencyEdges);
+  let inputSchemaJson = null;
+  if (config2.input) {
+    try {
+      inputSchemaJson = exports_external.toJSONSchema(config2.input);
+    } catch {
+      inputSchemaJson = null;
+    }
+  }
+  return {
+    key: config2.key,
+    name: config2.name ?? config2.key,
+    description: config2.description ?? null,
+    version: config2.version ?? 1,
+    status: config2.status ?? "active",
+    inputSchemaJson,
+    _stepDefinitions: [...stepDefMap.values()],
+    nodeDefinitions,
+    dependencyEdges
+  };
 }
 // src/generated/core/bodySerializer.gen.ts
 var jsonBodySerializer = {
@@ -16305,29 +16140,6 @@ class PipelineDefinitions extends HeyApiClient {
   unarchivePipelineDefinition(options) {
     return (options.client ?? this.client).put({ url: "/api/pipeline-definitions/{pipelineDefinitionId}/unarchive", ...options });
   }
-  addPipelineStep(options) {
-    return (options.client ?? this.client).post({
-      url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
-  removePipelineStep(options) {
-    return (options.client ?? this.client).delete({ url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps/{pipelineStepDefinitionId}", ...options });
-  }
-  updatePipelineStep(options) {
-    return (options.client ?? this.client).put({
-      url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps/{pipelineStepDefinitionId}",
-      ...options,
-      headers: {
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-  }
   setPipelineStepAdvancementPolicy(options) {
     return (options.client ?? this.client).put({
       url: "/api/pipeline-definitions/{pipelineDefinitionId}/steps/{pipelineStepDefinitionId}/advancement-policy",
@@ -16834,6 +16646,76 @@ function createPipelineDefinitionsClient(baseUrl) {
   const client2 = createClient({ baseUrl });
   return buildPipelineDefinitionsClient(new PipelineDefinitions({ client: client2 }));
 }
+function resolveStepRef(pipelineKey, nodeKey, stepKey, stepDefMap) {
+  const stepDef = stepDefMap.get(stepKey);
+  if (!stepDef) {
+    throw new Error(`Step "${stepKey}" referenced by node "${nodeKey}" in pipeline "${pipelineKey}" was not found on ` + `the server. Run \`boboddy steps push\` first to push your step definitions.`);
+  }
+  return {
+    stepDefinitionId: stepDef.id,
+    stepDefinitionVersion: stepDef.version
+  };
+}
+function buildConfigJson(pipelineKey, node, stepDefMap) {
+  if (node.kind === "choice") {
+    return { choices: node.choices, default: node.default };
+  }
+  if (node.kind === "loop") {
+    return {
+      maxIterations: node.maxIterations,
+      untilConditionJson: node.untilConditionJson
+    };
+  }
+  if (node.kind === "parallel") {
+    const branches = {};
+    for (const [branchKey, branch] of Object.entries(node.branches)) {
+      branches[branchKey] = {
+        ...resolveStepRef(pipelineKey, node.nodeKey, branch.stepKey, stepDefMap),
+        inputBindingsJson: branch.inputBindingsJson
+      };
+    }
+    return {
+      branches,
+      ...node.advanceAllPolicyDefinition ? { advanceAllPolicyDefinition: node.advanceAllPolicyDefinition } : {}
+    };
+  }
+  if (node.kind === "fanOut") {
+    return {
+      overSignalKey: node.overSignalKey,
+      advanceEachPolicyDefinition: node.advanceEachPolicyDefinition,
+      maxConcurrency: node.maxConcurrency
+    };
+  }
+  if (node.kind === "cohortGate") {
+    return {
+      advanceAllPolicyDefinition: node.advanceAllPolicyDefinition,
+      stepSignalsListDefinitions: node.stepSignalsListDefinitions
+    };
+  }
+  return null;
+}
+function buildGraphNodeInput(pipelineKey, node, stepDefMap) {
+  const working = isWorkingNodeDefinition(node) ? node : null;
+  const stepRef = working ? resolveStepRef(pipelineKey, node.nodeKey, working.stepKey, stepDefMap) : null;
+  const policy = node.kind === "step" ? node.advancementPolicyDefinition : undefined;
+  return {
+    key: node.nodeKey,
+    kind: node.kind,
+    name: working?.stepName ?? node.nodeKey,
+    ...stepRef ?? {},
+    description: working?.stepDescription ?? null,
+    inputBindingsJson: working ? working.inputBindingsJson : null,
+    timeoutSeconds: working?.timeoutSeconds ?? null,
+    ...policy ? {
+      advancementPolicyRulesJson: policy.rulesJson,
+      advancementPolicyDefaultEventType: policy.defaultEventType,
+      advancementPolicyDefaultEventParamsJson: policy.defaultEventParamsJson,
+      advancementPolicyAllowedEventTypes: policy.allowedEventTypes
+    } : {},
+    configJson: buildConfigJson(pipelineKey, node, stepDefMap),
+    computedSignalDefinitions: node.kind === "step" ? node.computedSignalDefinitions : []
+  };
+}
 var buildPipelineDefinitionsClient = (pipelineDefinitions) => {
   return {
     listByProjectId: async (projectId, options) => {
@@ -16853,37 +16735,12 @@ var buildPipelineDefinitionsClient = (pipelineDefinitions) => {
           stepDefMap.set(s.key, s);
         }
       }
-      const nonStepNode = spec.nodeDefinitions.find((node) => node.kind !== "step");
-      if (nonStepNode) {
-        throw new Error(`Pipeline "${spec.key}" contains a "${nonStepNode.kind}" node ("${nonStepNode.nodeKey}"), ` + `but fan-out pipelines cannot be pushed via the current wire contract yet. ` + `Only "step"-only (chain) pipelines can be pushed with \`upsertFromSpec\` today.`);
-      }
-      const ordered = tryOrderChainNodeDefinitions(spec.nodeDefinitions, spec.dependencyEdges);
-      if (ordered === null) {
-        throw new Error(`Pipeline "${spec.key}" has a malformed step graph: its node and ` + `dependency-edge definitions do not form a single connected, ` + `acyclic chain. This should not happen from the \`pipeline()\` ` + `builder \u2014 check for hand-edited or generated pipeline specs.`);
-      }
-      const stepDefinitions = ordered.map((node, index) => {
-        const stepKey = node.stepKey;
-        if (!stepKey) {
-          throw new Error(`Node "${node.nodeKey}" in pipeline "${spec.key}" has no stepKey.`);
-        }
-        const stepDef = stepDefMap.get(stepKey);
-        if (!stepDef) {
-          throw new Error(`Step "${stepKey}" referenced in pipeline "${spec.key}" was not found on the server. ` + `Run \`boboddy steps push\` first to push your step definitions.`);
-        }
-        return {
-          stepDefinitionId: stepDef.id,
-          stepDefinitionVersion: stepDef.version,
-          key: node.nodeKey,
-          name: node.stepName ?? "",
-          description: node.stepDescription ?? null,
-          position: index + 1,
-          inputBindingsJson: node.inputBindingsJson ?? {},
-          timeoutSeconds: node.timeoutSeconds ?? null,
-          retryPolicyJson: null,
-          advancementPolicyDefinition: node.advancementPolicyDefinition,
-          computedSignalDefinitions: node.computedSignalDefinitions ?? []
-        };
-      });
+      const nodeDefinitions = spec.nodeDefinitions.map((node) => buildGraphNodeInput(spec.key, node, stepDefMap));
+      const dependencyEdges = spec.dependencyEdges.map((edge) => ({
+        fromNodeKey: edge.fromNodeKey,
+        toNodeKey: edge.toNodeKey,
+        discriminantJson: edge.discriminantJson ?? null
+      }));
       const body = {
         projectId,
         key: spec.key,
@@ -16891,7 +16748,8 @@ var buildPipelineDefinitionsClient = (pipelineDefinitions) => {
         description: spec.description,
         status: spec.status,
         inputSchemaJson: spec.inputSchemaJson,
-        stepDefinitions
+        nodeDefinitions,
+        dependencyEdges
       };
       const result = await pipelineDefinitions.upsertPipelineDefinition({
         body,
@@ -16949,17 +16807,17 @@ function buildWorkItemAccessor() {
   }
   return accessor;
 }
-function makeAssign(pipeline2) {
-  if (typeof pipeline2 !== "object" || typeof pipeline2["key"] !== "string" || !Array.isArray(pipeline2["nodeDefinitions"])) {
-    throw new Error("assign() requires a pipeline spec produced by pipeline().build(). " + "Pass the default-exported value from a pipeline definition file.");
+function makeAssign(pipeline) {
+  if (typeof pipeline !== "object" || typeof pipeline["key"] !== "string" || !Array.isArray(pipeline["nodeDefinitions"])) {
+    throw new Error("assign() requires a pipeline spec produced by definePipeline(). " + "Pass the default-exported value from a pipeline definition file.");
   }
-  return { _tag: "assign", pipeline: pipeline2 };
+  return { _tag: "assign", pipeline };
 }
-function extractCondition2(ref) {
+function extractCondition(ref) {
   return ref._condition;
 }
 function makeGroup(mode, refs) {
-  const conditions = refs.map(extractCondition2);
+  const conditions = refs.map(extractCondition);
   const condition = { _tag: "group", mode, conditions };
   return {
     _condition: condition,
@@ -17049,22 +16907,19 @@ function isDefaultPipelineAssignmentSpec(value) {
   return value["_tag"] === "default_pipeline_assignment";
 }
 export {
-  serializeDefaultPipelineAssignment,
-  resolveWorkItemFieldPath,
-  pipeline,
-  materializeAccessor,
-  literal2 as literal,
-  isInputAccessor,
-  isDefaultPipelineAssignmentSpec,
-  defaultPipelineAssignment,
-  createPipelineDefinitionsClient,
-  createInputAccessor,
-  buildPipelineSpec,
-  WORK_ITEM_TOP_LEVEL_FIELDS,
-  WORK_ITEM_FIELDS_PATH_PREFIX,
-  Rule,
-  PipelineStepBuilder,
-  PipelineBuilder,
+  Computed,
   DEFAULT_PIPELINE_ASSIGNMENT_FILENAME,
-  Computed
+  Rule,
+  WORK_ITEM_FIELDS_PATH_PREFIX,
+  WORK_ITEM_TOP_LEVEL_FIELDS,
+  createPipelineDefinitionsClient,
+  defaultPipelineAssignment,
+  definePipeline,
+  isDefaultPipelineAssignmentSpec,
+  isWorkingNodeDefinition,
+  makeFanOutNodeInputCtx,
+  makeNodeInputCtx,
+  resolveWorkItemFieldPath,
+  serializeDefaultPipelineAssignment,
+  serializeInputBindings
 };