@t2000/cli 4.3.1 → 4.4.0

package/dist/dist-YCBO7GXC.js

@@ -0,0 +1,1305 @@
+import { createRequire as __createRequire } from 'module'; import { fileURLToPath as __fileURLToPath } from 'url'; import { dirname as __pathDirname } from 'path'; const require = __createRequire(import.meta.url); const __filename = __fileURLToPath(import.meta.url); const __dirname = __pathDirname(__filename);
+import {
+  $brand,
+  $input,
+  $output,
+  Base64_exports,
+  Bytes_exports,
+  Hash_exports,
+  Hex_exports,
+  Json_exports,
+  NEVER,
+  TimePrecision,
+  ZodMiniAny,
+  ZodMiniArray,
+  ZodMiniBase64,
+  ZodMiniBase64URL,
+  ZodMiniBigInt,
+  ZodMiniBigIntFormat,
+  ZodMiniBoolean,
+  ZodMiniCIDRv4,
+  ZodMiniCIDRv6,
+  ZodMiniCUID,
+  ZodMiniCUID2,
+  ZodMiniCatch,
+  ZodMiniCodec,
+  ZodMiniCustom,
+  ZodMiniCustomStringFormat,
+  ZodMiniDate,
+  ZodMiniDefault,
+  ZodMiniDiscriminatedUnion,
+  ZodMiniE164,
+  ZodMiniEmail,
+  ZodMiniEmoji,
+  ZodMiniEnum,
+  ZodMiniExactOptional,
+  ZodMiniFile,
+  ZodMiniFunction,
+  ZodMiniGUID,
+  ZodMiniIPv4,
+  ZodMiniIPv6,
+  ZodMiniISODate,
+  ZodMiniISODateTime,
+  ZodMiniISODuration,
+  ZodMiniISOTime,
+  ZodMiniIntersection,
+  ZodMiniJWT,
+  ZodMiniKSUID,
+  ZodMiniLazy,
+  ZodMiniLiteral,
+  ZodMiniMAC,
+  ZodMiniMap,
+  ZodMiniNaN,
+  ZodMiniNanoID,
+  ZodMiniNever,
+  ZodMiniNonOptional,
+  ZodMiniNull,
+  ZodMiniNullable,
+  ZodMiniNumber,
+  ZodMiniNumberFormat,
+  ZodMiniObject,
+  ZodMiniOptional,
+  ZodMiniPipe,
+  ZodMiniPrefault,
+  ZodMiniPromise,
+  ZodMiniReadonly,
+  ZodMiniRecord,
+  ZodMiniSet,
+  ZodMiniString,
+  ZodMiniStringFormat,
+  ZodMiniSuccess,
+  ZodMiniSymbol,
+  ZodMiniTemplateLiteral,
+  ZodMiniTransform,
+  ZodMiniTuple,
+  ZodMiniType,
+  ZodMiniULID,
+  ZodMiniURL,
+  ZodMiniUUID,
+  ZodMiniUndefined,
+  ZodMiniUnion,
+  ZodMiniUnknown,
+  ZodMiniVoid,
+  ZodMiniXID,
+  ZodMiniXor,
+  _catch,
+  _default,
+  _endsWith,
+  _enum,
+  _function,
+  _gt,
+  _gte,
+  _includes,
+  _instanceof,
+  _lazy,
+  _length,
+  _lowercase,
+  _lt,
+  _lte,
+  _maxLength,
+  _maxSize,
+  _mime,
+  _minLength,
+  _minSize,
+  _multipleOf,
+  _negative,
+  _nonnegative,
+  _nonpositive,
+  _normalize,
+  _null,
+  _overwrite,
+  _positive,
+  _property,
+  _regex,
+  _size,
+  _startsWith,
+  _toLowerCase,
+  _toUpperCase,
+  _trim,
+  _undefined,
+  _uppercase,
+  _void,
+  any,
+  array,
+  base64,
+  base64url,
+  bigint,
+  boolean,
+  catchall,
+  check,
+  cidrv4,
+  cidrv6,
+  clone,
+  codec,
+  coerce_exports,
+  config,
+  core_exports,
+  cuid,
+  cuid2,
+  custom,
+  date,
+  decode,
+  decodeAsync,
+  describe,
+  discriminatedUnion,
+  e164,
+  email,
+  emoji,
+  encode,
+  encodeAsync,
+  exactOptional,
+  extend,
+  external_exports,
+  file,
+  flattenError,
+  float32,
+  float64,
+  formatError,
+  globalRegistry,
+  guid,
+  hex,
+  hostname,
+  httpUrl,
+  int,
+  int32,
+  int64,
+  intersection,
+  invertCodec,
+  ipv4,
+  ipv6,
+  iso_exports,
+  json,
+  jwt,
+  keyof,
+  ksuid,
+  literal,
+  locales_exports,
+  looseObject,
+  looseRecord,
+  mac,
+  map,
+  merge,
+  meta,
+  nan,
+  nanoid,
+  nativeEnum,
+  never,
+  nonoptional,
+  nullable,
+  nullish,
+  number,
+  object,
+  omit,
+  optional,
+  parse,
+  parseAsync,
+  partial,
+  partialRecord,
+  pick,
+  pipe,
+  prefault,
+  prettifyError,
+  promise,
+  readonly,
+  record,
+  refine,
+  regexes_exports,
+  registry,
+  required,
+  safeDecode,
+  safeDecodeAsync,
+  safeEncode,
+  safeEncodeAsync,
+  safeExtend,
+  safeParse,
+  safeParseAsync,
+  set,
+  strictObject,
+  string,
+  stringFormat,
+  stringbool,
+  success,
+  superRefine,
+  symbol,
+  templateLiteral,
+  toJSONSchema,
+  transform,
+  treeifyError,
+  tuple,
+  uint32,
+  uint64,
+  ulid,
+  union,
+  unknown,
+  url,
+  util_exports,
+  uuid,
+  uuidv4,
+  uuidv6,
+  uuidv7,
+  xid,
+  xor
+} from "./chunk-KC2WRBJB.js";
+import "./chunk-NGS6K3I3.js";
+import "./chunk-77SWBATH.js";
+import "./chunk-7LGHVVIJ.js";
+import {
+  __export
+} from "./chunk-YPWSCLE3.js";
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/BodyDigest.js
+var BodyDigest_exports = {};
+__export(BodyDigest_exports, {
+  compute: () => compute,
+  verify: () => verify
+});
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/internal/constantTimeEqual.js
+function constantTimeEqual(a, b) {
+  const hashA = Hash_exports.sha256(Hex_exports.fromString(a));
+  const hashB = Hash_exports.sha256(Hex_exports.fromString(b));
+  let result = 0;
+  for (let i = 0; i < hashA.length; i++)
+    result |= hashA.charCodeAt(i) ^ hashB.charCodeAt(i);
+  return result === 0;
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/BodyDigest.js
+function compute(body) {
+  const str = typeof body === "object" ? JSON.stringify(body) : body;
+  const bytes = Bytes_exports.fromString(str);
+  const hash2 = Hash_exports.sha256(bytes, { as: "Bytes" });
+  const base642 = Base64_exports.fromBytes(hash2);
+  return `sha-256=${base642}`;
+}
+function verify(digest, body) {
+  return constantTimeEqual(compute(body), digest);
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/Challenge.js
+var Challenge_exports = {};
+__export(Challenge_exports, {
+  Schema: () => Schema,
+  deserialize: () => deserialize2,
+  deserializeList: () => deserializeList,
+  from: () => from2,
+  fromHeaders: () => fromHeaders,
+  fromHeadersList: () => fromHeadersList,
+  fromMethod: () => fromMethod2,
+  fromResponse: () => fromResponse,
+  fromResponseList: () => fromResponseList,
+  meta: () => meta2,
+  serialize: () => serialize2,
+  verify: () => verify2
+});
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/PaymentRequest.js
+var PaymentRequest_exports = {};
+__export(PaymentRequest_exports, {
+  deserialize: () => deserialize,
+  from: () => from,
+  fromMethod: () => fromMethod,
+  serialize: () => serialize
+});
+function deserialize(encoded) {
+  const json2 = Base64_exports.toString(encoded);
+  return JSON.parse(json2);
+}
+function from(request) {
+  return request;
+}
+function fromMethod(method, request) {
+  return method.schema.request.parse(request);
+}
+function serialize(request) {
+  const json2 = Json_exports.canonicalize(request);
+  return Base64_exports.fromString(json2, { pad: false, url: true });
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/zod.js
+var zod_exports = {};
+__export(zod_exports, {
+  $brand: () => $brand,
+  $input: () => $input,
+  $output: () => $output,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  ZodMiniAny: () => ZodMiniAny,
+  ZodMiniArray: () => ZodMiniArray,
+  ZodMiniBase64: () => ZodMiniBase64,
+  ZodMiniBase64URL: () => ZodMiniBase64URL,
+  ZodMiniBigInt: () => ZodMiniBigInt,
+  ZodMiniBigIntFormat: () => ZodMiniBigIntFormat,
+  ZodMiniBoolean: () => ZodMiniBoolean,
+  ZodMiniCIDRv4: () => ZodMiniCIDRv4,
+  ZodMiniCIDRv6: () => ZodMiniCIDRv6,
+  ZodMiniCUID: () => ZodMiniCUID,
+  ZodMiniCUID2: () => ZodMiniCUID2,
+  ZodMiniCatch: () => ZodMiniCatch,
+  ZodMiniCodec: () => ZodMiniCodec,
+  ZodMiniCustom: () => ZodMiniCustom,
+  ZodMiniCustomStringFormat: () => ZodMiniCustomStringFormat,
+  ZodMiniDate: () => ZodMiniDate,
+  ZodMiniDefault: () => ZodMiniDefault,
+  ZodMiniDiscriminatedUnion: () => ZodMiniDiscriminatedUnion,
+  ZodMiniE164: () => ZodMiniE164,
+  ZodMiniEmail: () => ZodMiniEmail,
+  ZodMiniEmoji: () => ZodMiniEmoji,
+  ZodMiniEnum: () => ZodMiniEnum,
+  ZodMiniExactOptional: () => ZodMiniExactOptional,
+  ZodMiniFile: () => ZodMiniFile,
+  ZodMiniFunction: () => ZodMiniFunction,
+  ZodMiniGUID: () => ZodMiniGUID,
+  ZodMiniIPv4: () => ZodMiniIPv4,
+  ZodMiniIPv6: () => ZodMiniIPv6,
+  ZodMiniISODate: () => ZodMiniISODate,
+  ZodMiniISODateTime: () => ZodMiniISODateTime,
+  ZodMiniISODuration: () => ZodMiniISODuration,
+  ZodMiniISOTime: () => ZodMiniISOTime,
+  ZodMiniIntersection: () => ZodMiniIntersection,
+  ZodMiniJWT: () => ZodMiniJWT,
+  ZodMiniKSUID: () => ZodMiniKSUID,
+  ZodMiniLazy: () => ZodMiniLazy,
+  ZodMiniLiteral: () => ZodMiniLiteral,
+  ZodMiniMAC: () => ZodMiniMAC,
+  ZodMiniMap: () => ZodMiniMap,
+  ZodMiniNaN: () => ZodMiniNaN,
+  ZodMiniNanoID: () => ZodMiniNanoID,
+  ZodMiniNever: () => ZodMiniNever,
+  ZodMiniNonOptional: () => ZodMiniNonOptional,
+  ZodMiniNull: () => ZodMiniNull,
+  ZodMiniNullable: () => ZodMiniNullable,
+  ZodMiniNumber: () => ZodMiniNumber,
+  ZodMiniNumberFormat: () => ZodMiniNumberFormat,
+  ZodMiniObject: () => ZodMiniObject,
+  ZodMiniOptional: () => ZodMiniOptional,
+  ZodMiniPipe: () => ZodMiniPipe,
+  ZodMiniPrefault: () => ZodMiniPrefault,
+  ZodMiniPromise: () => ZodMiniPromise,
+  ZodMiniReadonly: () => ZodMiniReadonly,
+  ZodMiniRecord: () => ZodMiniRecord,
+  ZodMiniSet: () => ZodMiniSet,
+  ZodMiniString: () => ZodMiniString,
+  ZodMiniStringFormat: () => ZodMiniStringFormat,
+  ZodMiniSuccess: () => ZodMiniSuccess,
+  ZodMiniSymbol: () => ZodMiniSymbol,
+  ZodMiniTemplateLiteral: () => ZodMiniTemplateLiteral,
+  ZodMiniTransform: () => ZodMiniTransform,
+  ZodMiniTuple: () => ZodMiniTuple,
+  ZodMiniType: () => ZodMiniType,
+  ZodMiniULID: () => ZodMiniULID,
+  ZodMiniURL: () => ZodMiniURL,
+  ZodMiniUUID: () => ZodMiniUUID,
+  ZodMiniUndefined: () => ZodMiniUndefined,
+  ZodMiniUnion: () => ZodMiniUnion,
+  ZodMiniUnknown: () => ZodMiniUnknown,
+  ZodMiniVoid: () => ZodMiniVoid,
+  ZodMiniXID: () => ZodMiniXID,
+  ZodMiniXor: () => ZodMiniXor,
+  _default: () => _default,
+  _function: () => _function,
+  address: () => address,
+  amount: () => amount,
+  any: () => any,
+  array: () => array,
+  base64: () => base64,
+  base64url: () => base64url,
+  bigint: () => bigint,
+  boolean: () => boolean,
+  catch: () => _catch,
+  catchall: () => catchall,
+  check: () => check,
+  cidrv4: () => cidrv4,
+  cidrv6: () => cidrv6,
+  clone: () => clone,
+  codec: () => codec,
+  coerce: () => coerce_exports,
+  config: () => config,
+  core: () => core_exports,
+  cuid: () => cuid,
+  cuid2: () => cuid2,
+  custom: () => custom,
+  date: () => date,
+  datetime: () => datetime,
+  decode: () => decode,
+  decodeAsync: () => decodeAsync,
+  describe: () => describe,
+  discriminatedUnion: () => discriminatedUnion,
+  e164: () => e164,
+  email: () => email,
+  emoji: () => emoji,
+  encode: () => encode,
+  encodeAsync: () => encodeAsync,
+  endsWith: () => _endsWith,
+  enum: () => _enum,
+  exactOptional: () => exactOptional,
+  extend: () => extend,
+  file: () => file,
+  flattenError: () => flattenError,
+  float32: () => float32,
+  float64: () => float64,
+  formatError: () => formatError,
+  function: () => _function,
+  globalRegistry: () => globalRegistry,
+  gt: () => _gt,
+  gte: () => _gte,
+  guid: () => guid,
+  hash: () => hash,
+  hex: () => hex,
+  hostname: () => hostname,
+  httpUrl: () => httpUrl,
+  includes: () => _includes,
+  instanceof: () => _instanceof,
+  int: () => int,
+  int32: () => int32,
+  int64: () => int64,
+  intersection: () => intersection,
+  invertCodec: () => invertCodec,
+  ipv4: () => ipv4,
+  ipv6: () => ipv6,
+  iso: () => iso_exports,
+  json: () => json,
+  jwt: () => jwt,
+  keyof: () => keyof,
+  ksuid: () => ksuid,
+  lazy: () => _lazy,
+  length: () => _length,
+  literal: () => literal,
+  locales: () => locales_exports,
+  looseObject: () => looseObject,
+  looseRecord: () => looseRecord,
+  lowercase: () => _lowercase,
+  lt: () => _lt,
+  lte: () => _lte,
+  mac: () => mac,
+  map: () => map,
+  maxLength: () => _maxLength,
+  maxSize: () => _maxSize,
+  maximum: () => _lte,
+  merge: () => merge,
+  meta: () => meta,
+  mime: () => _mime,
+  minLength: () => _minLength,
+  minSize: () => _minSize,
+  minimum: () => _gte,
+  multipleOf: () => _multipleOf,
+  nan: () => nan,
+  nanoid: () => nanoid,
+  nativeEnum: () => nativeEnum,
+  negative: () => _negative,
+  never: () => never,
+  nonnegative: () => _nonnegative,
+  nonoptional: () => nonoptional,
+  nonpositive: () => _nonpositive,
+  normalize: () => _normalize,
+  null: () => _null,
+  nullable: () => nullable,
+  nullish: () => nullish,
+  number: () => number,
+  object: () => object,
+  omit: () => omit,
+  optional: () => optional,
+  overwrite: () => _overwrite,
+  parse: () => parse,
+  parseAsync: () => parseAsync,
+  partial: () => partial,
+  partialRecord: () => partialRecord,
+  period: () => period,
+  pick: () => pick,
+  pipe: () => pipe,
+  positive: () => _positive,
+  prefault: () => prefault,
+  prettifyError: () => prettifyError,
+  promise: () => promise,
+  property: () => _property,
+  readonly: () => readonly,
+  record: () => record,
+  refine: () => refine,
+  regex: () => _regex,
+  regexes: () => regexes_exports,
+  registry: () => registry,
+  required: () => required,
+  safeDecode: () => safeDecode,
+  safeDecodeAsync: () => safeDecodeAsync,
+  safeEncode: () => safeEncode,
+  safeEncodeAsync: () => safeEncodeAsync,
+  safeExtend: () => safeExtend,
+  safeParse: () => safeParse,
+  safeParseAsync: () => safeParseAsync,
+  set: () => set,
+  signature: () => signature,
+  size: () => _size,
+  startsWith: () => _startsWith,
+  strictObject: () => strictObject,
+  string: () => string,
+  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: () => ulid,
+  undefined: () => _undefined,
+  union: () => union,
+  unknown: () => unknown,
+  unwrapOptional: () => unwrapOptional,
+  uppercase: () => _uppercase,
+  url: () => url,
+  util: () => util_exports,
+  uuid: () => uuid,
+  uuidv4: () => uuidv4,
+  uuidv6: () => uuidv6,
+  uuidv7: () => uuidv7,
+  void: () => _void,
+  xid: () => xid,
+  xor: () => xor,
+  z: () => external_exports
+});
+function amount() {
+  return external_exports.string().check(external_exports.regex(/^\d+(\.\d+)?$/, "Invalid amount"));
+}
+function datetime() {
+  return external_exports.string().check(external_exports.regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/, "Invalid ISO 8601 datetime"));
+}
+function address() {
+  return external_exports.string().check(external_exports.regex(/^0x[0-9a-fA-F]{40}$/, "Invalid address"));
+}
+function hash() {
+  return external_exports.string().check(external_exports.regex(/^0x[0-9a-fA-F]{64}$/, "Invalid hash"));
+}
+function period() {
+  return external_exports.string().check(external_exports.regex(/^(day|week|month|year|\d+)$/, "Invalid period"));
+}
+function signature() {
+  return external_exports.string().check(external_exports.regex(/^0x[0-9a-fA-F]+$/, "Invalid signature"));
+}
+function unwrapOptional(schema) {
+  if (schema._zod.def.type === "optional")
+    return schema._zod.def.innerType;
+  return schema;
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/Challenge.js
+var Schema = object({
+  /** Optional human-readable description of the payment. */
+  description: optional(string()),
+  /** Optional digest of the request body (format: "sha-256=base64hash"). */
+  digest: optional(string().check(_regex(/^sha-256=/, "Invalid digest format"))),
+  /** Optional expiration timestamp (ISO 8601). */
+  expires: optional(datetime()),
+  /** Unique challenge identifier (HMAC-bound). */
+  id: string(),
+  /** Intent type (e.g., "charge", "session"). */
+  intent: string(),
+  /** Payment method (e.g., "tempo", "stripe"). */
+  method: string(),
+  /** Optional server-defined correlation data. Flat string-to-string map; clients MUST NOT modify. */
+  opaque: optional(record(string(), string())),
+  /** Server realm (e.g., hostname). */
+  realm: string(),
+  /** Method-specific request data. */
+  request: record(string(), unknown())
+});
+function from2(parameters, options) {
+  void options;
+  const { description, digest, meta: meta3, method: methodName, intent, realm, request, secretKey } = parameters;
+  const expires = parameters.expires;
+  const id = secretKey ? computeId({ ...parameters, expires, ...meta3 && { opaque: meta3 } }, { secretKey }) : parameters.id;
+  return Schema.parse({
+    id,
+    realm,
+    method: methodName,
+    intent,
+    request,
+    ...description && { description },
+    ...digest && { digest },
+    ...expires && { expires },
+    ...meta3 && { opaque: meta3 }
+  });
+}
+function fromMethod2(method, parameters) {
+  const { name: methodName, intent } = method;
+  const { description, digest, expires, id, meta: meta3, realm, secretKey } = parameters;
+  const request = fromMethod(method, parameters.request);
+  return from2({
+    ...id ? { id } : { secretKey },
+    realm,
+    method: methodName,
+    intent,
+    request,
+    description,
+    digest,
+    expires,
+    meta: meta3
+  });
+}
+function serialize2(challenge) {
+  const parts = [
+    `id="${challenge.id}"`,
+    `realm="${challenge.realm}"`,
+    `method="${challenge.method}"`,
+    `intent="${challenge.intent}"`,
+    `request="${serialize(challenge.request)}"`
+  ];
+  if (challenge.description !== void 0)
+    parts.push(`description="${challenge.description}"`);
+  if (challenge.digest !== void 0)
+    parts.push(`digest="${challenge.digest}"`);
+  if (challenge.expires !== void 0)
+    parts.push(`expires="${challenge.expires}"`);
+  if (challenge.opaque !== void 0)
+    parts.push(`opaque="${serialize(challenge.opaque)}"`);
+  return `Payment ${parts.join(", ")}`;
+}
+function deserialize2(value, options) {
+  const params = extractPaymentAuthParams(value);
+  if (!params)
+    throw new Error("Missing Payment scheme.");
+  const result = parseAuthParams(params);
+  const { request, opaque, ...rest } = result;
+  if (!request)
+    throw new Error("Missing request parameter.");
+  if (rest.method && !/^[a-z][a-z0-9:_-]*$/.test(rest.method))
+    throw new Error(`Invalid method: "${rest.method}". Must be lowercase per spec.`);
+  return from2({
+    ...rest,
+    request: deserialize(request),
+    ...opaque && { meta: deserialize(opaque) }
+  }, options);
+}
+function extractPaymentAuthParams(header) {
+  const token = "Payment";
+  let inQuotes = false;
+  let escaped = false;
+  for (let i = 0; i < header.length; i++) {
+    const char = header[i];
+    if (inQuotes) {
+      if (escaped)
+        escaped = false;
+      else if (char === "\\")
+        escaped = true;
+      else if (char === '"')
+        inQuotes = false;
+      continue;
+    }
+    if (char === '"') {
+      inQuotes = true;
+      continue;
+    }
+    if (!startsWithSchemeToken(header, i, token))
+      continue;
+    const prefix = header.slice(0, i);
+    if (prefix.trim() && !prefix.trimEnd().endsWith(","))
+      continue;
+    let paramsStart = i + token.length;
+    while (paramsStart < header.length && /\s/.test(header[paramsStart] ?? ""))
+      paramsStart++;
+    return header.slice(paramsStart);
+  }
+  return null;
+}
+function parseAuthParams(input) {
+  const result = {};
+  let i = 0;
+  while (i < input.length) {
+    while (i < input.length && /[\s,]/.test(input[i] ?? ""))
+      i++;
+    if (i >= input.length)
+      break;
+    const keyStart = i;
+    while (i < input.length && /[A-Za-z0-9_-]/.test(input[i] ?? ""))
+      i++;
+    const key = input.slice(keyStart, i);
+    if (!key)
+      throw new Error("Malformed auth-param.");
+    while (i < input.length && /\s/.test(input[i] ?? ""))
+      i++;
+    if (input[i] !== "=")
+      break;
+    i++;
+    while (i < input.length && /\s/.test(input[i] ?? ""))
+      i++;
+    const [value, nextIndex] = readAuthParamValue(input, i);
+    i = nextIndex;
+    if (key in result)
+      throw new Error(`Duplicate parameter: ${key}`);
+    result[key] = value;
+  }
+  return result;
+}
+function readAuthParamValue(input, start) {
+  if (input[start] === '"')
+    return readQuotedAuthParamValue(input, start + 1);
+  let i = start;
+  while (i < input.length && input[i] !== ",")
+    i++;
+  return [input.slice(start, i).trim(), i];
+}
+function readQuotedAuthParamValue(input, start) {
+  let i = start;
+  let value = "";
+  let escaped = false;
+  while (i < input.length) {
+    const char = input[i];
+    i++;
+    if (escaped) {
+      value += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"')
+      return [value, i];
+    value += char;
+  }
+  throw new Error("Unterminated quoted-string.");
+}
+function startsWithSchemeToken(value, index, token) {
+  if (!value.slice(index).toLowerCase().startsWith(token.toLowerCase()))
+    return false;
+  const next = value[index + token.length];
+  return Boolean(next && /\s/.test(next));
+}
+function fromHeaders(headers, options) {
+  const header = headers.get("WWW-Authenticate");
+  if (!header)
+    throw new Error("Missing WWW-Authenticate header.");
+  return deserialize2(header, options);
+}
+function fromResponse(response, options) {
+  if (response.status !== 402)
+    throw new Error("Response status is not 402.");
+  return fromHeaders(response.headers, options);
+}
+function fromResponseList(response, options) {
+  if (response.status !== 402)
+    throw new Error("Response status is not 402.");
+  return fromHeadersList(response.headers, options);
+}
+function fromHeadersList(headers, options) {
+  const header = headers.get("WWW-Authenticate");
+  if (!header)
+    throw new Error("Missing WWW-Authenticate header.");
+  return deserializeList(header, options);
+}
+function deserializeList(value, options) {
+  const starts = [];
+  for (const match of value.matchAll(/Payment\s+/gi)) {
+    starts.push(match.index);
+  }
+  if (starts.length === 0)
+    throw new Error("No Payment schemes found.");
+  return starts.map((start, i) => {
+    const end = i + 1 < starts.length ? starts[i + 1] : value.length;
+    const chunk = value.slice(start, end).replace(/,\s*$/, "");
+    return deserialize2(chunk, options);
+  });
+}
+function verify2(challenge, options) {
+  const expectedId = computeId(challenge, options);
+  return constantTimeEqual(challenge.id, expectedId);
+}
+function meta2(challenge) {
+  return challenge.opaque;
+}
+function computeId(challenge, options) {
+  const input = [
+    challenge.realm,
+    challenge.method,
+    challenge.intent,
+    serialize(challenge.request),
+    challenge.expires ?? "",
+    challenge.digest ?? "",
+    challenge.opaque ? serialize(challenge.opaque) : ""
+  ].join("|");
+  const key = Bytes_exports.fromString(options.secretKey);
+  const data = Bytes_exports.fromString(input);
+  const mac2 = Hash_exports.hmac256(key, data, { as: "Bytes" });
+  return Base64_exports.fromBytes(mac2, { url: true, pad: false });
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/Credential.js
+var Credential_exports = {};
+__export(Credential_exports, {
+  deserialize: () => deserialize3,
+  extractPaymentScheme: () => extractPaymentScheme,
+  from: () => from3,
+  fromRequest: () => fromRequest,
+  serialize: () => serialize3
+});
+function deserialize3(value) {
+  const prefixMatch = value.match(/^Payment\s+(.+)$/i);
+  if (!prefixMatch?.[1])
+    throw new Error("Missing Payment scheme.");
+  try {
+    const json2 = Base64_exports.toString(prefixMatch[1]);
+    const parsed = JSON.parse(json2);
+    const challenge = Schema.parse({
+      ...parsed.challenge,
+      request: deserialize(parsed.challenge.request)
+    });
+    return {
+      challenge,
+      payload: parsed.payload,
+      ...parsed.source && { source: parsed.source }
+    };
+  } catch {
+    throw new Error("Invalid base64url or JSON.");
+  }
+}
+function from3(parameters) {
+  const { challenge, payload, source } = parameters;
+  return {
+    challenge,
+    payload,
+    ...source && { source }
+  };
+}
+function fromRequest(request) {
+  const header = request.headers.get("Authorization");
+  if (!header)
+    throw new Error("Missing Authorization header.");
+  const payment = extractPaymentScheme(header);
+  if (!payment)
+    throw new Error("Missing Payment scheme.");
+  return deserialize3(payment);
+}
+function serialize3(credential) {
+  const wire = {
+    challenge: {
+      ...credential.challenge,
+      request: serialize(credential.challenge.request)
+    },
+    payload: credential.payload,
+    ...credential.source && { source: credential.source }
+  };
+  const json2 = JSON.stringify(wire);
+  const encoded = Base64_exports.fromString(json2, { pad: false, url: true });
+  return `Payment ${encoded}`;
+}
+function extractPaymentScheme(header) {
+  const schemes = header.split(",").map((s) => s.trim());
+  return schemes.find((s) => /^Payment\s+/i.test(s)) ?? null;
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/Errors.js
+var Errors_exports = {};
+__export(Errors_exports, {
+  AmountExceedsDepositError: () => AmountExceedsDepositError,
+  BadRequestError: () => BadRequestError,
+  ChannelClosedError: () => ChannelClosedError,
+  ChannelNotFoundError: () => ChannelNotFoundError,
+  DeltaTooSmallError: () => DeltaTooSmallError,
+  InsufficientBalanceError: () => InsufficientBalanceError,
+  InvalidChallengeError: () => InvalidChallengeError,
+  InvalidPayloadError: () => InvalidPayloadError,
+  InvalidSignatureError: () => InvalidSignatureError,
+  MalformedCredentialError: () => MalformedCredentialError,
+  PaymentActionRequiredError: () => PaymentActionRequiredError,
+  PaymentError: () => PaymentError,
+  PaymentExpiredError: () => PaymentExpiredError,
+  PaymentInsufficientError: () => PaymentInsufficientError,
+  PaymentMethodUnsupportedError: () => PaymentMethodUnsupportedError,
+  PaymentRequiredError: () => PaymentRequiredError,
+  SignerMismatchError: () => SignerMismatchError,
+  VerificationFailedError: () => VerificationFailedError
+});
+var PaymentError = class extends Error {
+  /** HTTP status code. */
+  status = 402;
+  /** Converts the error to RFC 9457 Problem Details format. */
+  toProblemDetails(challengeId) {
+    return {
+      type: this.type,
+      title: this.title,
+      status: this.status,
+      detail: this.message,
+      ...challengeId && { challengeId }
+    };
+  }
+};
+var MalformedCredentialError = class extends PaymentError {
+  name = "MalformedCredentialError";
+  title = "Malformed Credential";
+  status = 402;
+  type = "https://paymentauth.org/problems/malformed-credential";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Credential is malformed: ${reason}.` : "Credential is malformed.");
+  }
+};
+var InvalidChallengeError = class extends PaymentError {
+  name = "InvalidChallengeError";
+  title = "Invalid Challenge";
+  status = 402;
+  type = "https://paymentauth.org/problems/invalid-challenge";
+  constructor(options = {}) {
+    const { id, reason } = options;
+    const idPart = id ? ` "${id}"` : "";
+    const reasonPart = reason ? `: ${reason}` : "";
+    super(`Challenge${idPart} is invalid${reasonPart}.`);
+  }
+};
+var VerificationFailedError = class extends PaymentError {
+  name = "VerificationFailedError";
+  title = "Verification Failed";
+  type = "https://paymentauth.org/problems/verification-failed";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Payment verification failed: ${reason}.` : "Payment verification failed.");
+  }
+};
+var PaymentActionRequiredError = class extends PaymentError {
+  name = "PaymentActionRequiredError";
+  title = "Payment Action Required";
+  type = "https://paymentauth.org/problems/payment-action-required";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Payment requires action: ${reason}.` : "Payment requires action.");
+  }
+};
+var PaymentExpiredError = class extends PaymentError {
+  name = "PaymentExpiredError";
+  title = "Payment Expired";
+  type = "https://paymentauth.org/problems/payment-expired";
+  constructor(options = {}) {
+    const { expires } = options;
+    super(expires ? `Payment expired at ${expires}.` : "Payment has expired.");
+  }
+};
+var PaymentRequiredError = class extends PaymentError {
+  name = "PaymentRequiredError";
+  title = "Payment Required";
+  type = "https://paymentauth.org/problems/payment-required";
+  constructor(options = {}) {
+    const { description } = options;
+    const parts = ["Payment is required"];
+    if (description)
+      parts.push(`(${description})`);
+    super(`${parts.join(" ")}.`);
+  }
+};
+var InvalidPayloadError = class extends PaymentError {
+  name = "InvalidPayloadError";
+  title = "Invalid Payload";
+  type = "https://paymentauth.org/problems/invalid-payload";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Credential payload is invalid: ${reason}.` : "Credential payload is invalid.");
+  }
+};
+var BadRequestError = class extends PaymentError {
+  name = "BadRequestError";
+  title = "Bad Request";
+  status = 400;
+  type = "https://paymentauth.org/problems/bad-request";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Bad request: ${reason}.` : "Bad request.");
+  }
+};
+var PaymentInsufficientError = class extends PaymentError {
+  name = "PaymentInsufficientError";
+  title = "Payment Insufficient";
+  type = "https://paymentauth.org/problems/payment-insufficient";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Payment insufficient: ${reason}.` : "Payment amount is insufficient.");
+  }
+};
+var PaymentMethodUnsupportedError = class extends PaymentError {
+  name = "PaymentMethodUnsupportedError";
+  title = "Method Unsupported";
+  status = 400;
+  type = "https://paymentauth.org/problems/method-unsupported";
+  constructor(options = {}) {
+    const { method } = options;
+    super(method ? `Payment method "${method}" is not supported.` : "Payment method is not supported.");
+  }
+};
+var InsufficientBalanceError = class extends PaymentError {
+  name = "InsufficientBalanceError";
+  title = "Insufficient Balance";
+  status = 402;
+  type = "https://paymentauth.org/problems/session/insufficient-balance";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Insufficient balance: ${reason}.` : "Insufficient balance.");
+  }
+};
+var InvalidSignatureError = class extends PaymentError {
+  name = "InvalidSignatureError";
+  title = "Invalid Signature";
+  status = 402;
+  type = "https://paymentauth.org/problems/session/invalid-signature";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Invalid signature: ${reason}.` : "Invalid signature.");
+  }
+};
+var SignerMismatchError = class extends PaymentError {
+  name = "SignerMismatchError";
+  title = "Signer Mismatch";
+  status = 402;
+  type = "https://paymentauth.org/problems/session/signer-mismatch";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Signer mismatch: ${reason}.` : "Signer is not authorized for this channel.");
+  }
+};
+var AmountExceedsDepositError = class extends PaymentError {
+  name = "AmountExceedsDepositError";
+  title = "Amount Exceeds Deposit";
+  status = 402;
+  type = "https://paymentauth.org/problems/session/amount-exceeds-deposit";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Amount exceeds deposit: ${reason}.` : "Voucher amount exceeds channel deposit.");
+  }
+};
+var DeltaTooSmallError = class extends PaymentError {
+  name = "DeltaTooSmallError";
+  title = "Delta Too Small";
+  status = 402;
+  type = "https://paymentauth.org/problems/session/delta-too-small";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Delta too small: ${reason}.` : "Amount increase below minimum voucher delta.");
+  }
+};
+var ChannelNotFoundError = class extends PaymentError {
+  name = "ChannelNotFoundError";
+  title = "Channel Not Found";
+  status = 410;
+  type = "https://paymentauth.org/problems/session/channel-not-found";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Channel not found: ${reason}.` : "No channel with this ID exists.");
+  }
+};
+var ChannelClosedError = class extends PaymentError {
+  name = "ChannelClosedError";
+  title = "Channel Closed";
+  status = 410;
+  type = "https://paymentauth.org/problems/session/channel-finalized";
+  constructor(options = {}) {
+    const { reason } = options;
+    super(reason ? `Channel closed: ${reason}.` : "Channel is closed.");
+  }
+};
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/Expires.js
+var Expires_exports = {};
+__export(Expires_exports, {
+  days: () => days,
+  hours: () => hours,
+  minutes: () => minutes,
+  months: () => months,
+  seconds: () => seconds,
+  weeks: () => weeks,
+  years: () => years
+});
+function days(n) {
+  return new Date(Date.now() + n * 24 * 60 * 60 * 1e3).toISOString();
+}
+function hours(n) {
+  return new Date(Date.now() + n * 60 * 60 * 1e3).toISOString();
+}
+function minutes(n) {
+  return new Date(Date.now() + n * 60 * 1e3).toISOString();
+}
+function months(n) {
+  return new Date(Date.now() + n * 30 * 24 * 60 * 60 * 1e3).toISOString();
+}
+function seconds(n) {
+  return new Date(Date.now() + n * 1e3).toISOString();
+}
+function weeks(n) {
+  return new Date(Date.now() + n * 7 * 24 * 60 * 60 * 1e3).toISOString();
+}
+function years(n) {
+  return new Date(Date.now() + n * 365 * 24 * 60 * 60 * 1e3).toISOString();
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/Mcp.js
+var Mcp_exports = {};
+__export(Mcp_exports, {
+  credentialMetaKey: () => credentialMetaKey,
+  paymentRequiredCode: () => paymentRequiredCode,
+  paymentVerificationFailedCode: () => paymentVerificationFailedCode,
+  receiptMetaKey: () => receiptMetaKey
+});
+var paymentRequiredCode = -32042;
+var paymentVerificationFailedCode = -32043;
+var credentialMetaKey = "org.paymentauth/credential";
+var receiptMetaKey = "org.paymentauth/receipt";
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/Method.js
+var Method_exports = {};
+__export(Method_exports, {
+  from: () => from4,
+  toClient: () => toClient,
+  toServer: () => toServer
+});
+function from4(method) {
+  return method;
+}
+function toClient(method, options) {
+  const { context, createCredential } = options;
+  return {
+    ...method,
+    context,
+    createCredential
+  };
+}
+function toServer(method, options) {
+  const { defaults, request, respond, transport, verify: verify3 } = options;
+  return {
+    ...method,
+    defaults,
+    request,
+    respond,
+    transport,
+    verify: verify3
+  };
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/Receipt.js
+var Receipt_exports = {};
+__export(Receipt_exports, {
+  Schema: () => Schema2,
+  deserialize: () => deserialize4,
+  from: () => from5,
+  fromResponse: () => fromResponse2,
+  serialize: () => serialize4
+});
+var Schema2 = object({
+  /** Payment method used (e.g., "tempo", "stripe"). */
+  method: string(),
+  /** Method-specific reference (e.g., transaction hash). */
+  reference: string(),
+  /** Optional external reference ID echoed from the credential payload. */
+  externalId: optional(string()),
+  /** Payment status. Always "success" — failures use 402 + Problem Details. */
+  status: literal("success"),
+  /** RFC 3339 settlement timestamp. */
+  timestamp: datetime()
+});
+function deserialize4(encoded) {
+  const json2 = Base64_exports.toString(encoded);
+  return from5(JSON.parse(json2));
+}
+function from5(parameters) {
+  return Schema2.parse(parameters);
+}
+function serialize4(receipt) {
+  const json2 = JSON.stringify(receipt);
+  return Base64_exports.fromString(json2, { pad: false, url: true });
+}
+function fromResponse2(response) {
+  const header = response.headers.get("Payment-Receipt");
+  if (!header)
+    throw new Error("Missing Payment-Receipt header.");
+  return deserialize4(header);
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@4.4.3__express@5.2.1_hono@4.12.9_openap_a5bd8709643e33148686c341f103678d/node_modules/mppx/dist/Store.js
+var Store_exports = {};
+__export(Store_exports, {
+  cloudflare: () => cloudflare,
+  from: () => from6,
+  memory: () => memory,
+  redis: () => redis,
+  upstash: () => upstash
+});
+function from6(store) {
+  return store;
+}
+function cloudflare(kv) {
+  return from6({
+    async get(key) {
+      const raw = await kv.get(key);
+      if (raw == null)
+        return null;
+      return Json_exports.parse(raw);
+    },
+    async put(key, value) {
+      await kv.put(key, Json_exports.stringify(value));
+    },
+    async delete(key) {
+      await kv.delete(key);
+    }
+  });
+}
+function memory() {
+  const store = /* @__PURE__ */ new Map();
+  return from6({
+    async get(key) {
+      const raw = store.get(key);
+      if (raw === void 0)
+        return null;
+      return Json_exports.parse(raw);
+    },
+    async put(key, value) {
+      store.set(key, Json_exports.stringify(value));
+    },
+    async delete(key) {
+      store.delete(key);
+    }
+  });
+}
+function redis(client) {
+  return from6({
+    async get(key) {
+      const raw = await client.get(key);
+      if (raw == null)
+        return null;
+      return Json_exports.parse(raw);
+    },
+    async put(key, value) {
+      await client.set(key, Json_exports.stringify(value));
+    },
+    async delete(key) {
+      await client.del(key);
+    }
+  });
+}
+function upstash(redis2) {
+  return from6({
+    async get(key) {
+      return await redis2.get(key);
+    },
+    async put(key, value) {
+      await redis2.set(key, value);
+    },
+    async delete(key) {
+      await redis2.del(key);
+    }
+  });
+}
+export {
+  BodyDigest_exports as BodyDigest,
+  Challenge_exports as Challenge,
+  Credential_exports as Credential,
+  Errors_exports as Errors,
+  Expires_exports as Expires,
+  Mcp_exports as Mcp,
+  Method_exports as Method,
+  PaymentRequest_exports as PaymentRequest,
+  Receipt_exports as Receipt,
+  Store_exports as Store,
+  zod_exports as z
+};
+//# sourceMappingURL=dist-YCBO7GXC.js.map