@t2000/cli 4.3.0 → 4.4.0

package/dist/chunk-W7ACGWI5.js

@@ -0,0 +1,879 @@
+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,
+  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 {
+  __export
+} from "./chunk-YPWSCLE3.js";
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@3.25.76__express@5.2.1_hono@4.12.9_open_8aabd0282577a5490f679a88cca7000d/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@3.25.76__express@5.2.1_hono@4.12.9_open_8aabd0282577a5490f679a88cca7000d/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@3.25.76__express@5.2.1_hono@4.12.9_open_8aabd0282577a5490f679a88cca7000d/node_modules/mppx/dist/Credential.js
+var Credential_exports = {};
+__export(Credential_exports, {
+  deserialize: () => deserialize3,
+  extractPaymentScheme: () => extractPaymentScheme,
+  from: () => from2,
+  fromRequest: () => fromRequest,
+  serialize: () => serialize2
+});
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@3.25.76__express@5.2.1_hono@4.12.9_open_8aabd0282577a5490f679a88cca7000d/node_modules/mppx/dist/PaymentRequest.js
+function deserialize(encoded) {
+  const json2 = Base64_exports.toString(encoded);
+  return JSON.parse(json2);
+}
+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@3.25.76__express@5.2.1_hono@4.12.9_open_8aabd0282577a5490f679a88cca7000d/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 from(parameters, options) {
+  void options;
+  const { description, digest, meta: meta2, method: methodName, intent, realm, request, secretKey } = parameters;
+  const expires = parameters.expires;
+  const id = secretKey ? computeId({ ...parameters, expires, ...meta2 && { opaque: meta2 } }, { secretKey }) : parameters.id;
+  return Schema.parse({
+    id,
+    realm,
+    method: methodName,
+    intent,
+    request,
+    ...description && { description },
+    ...digest && { digest },
+    ...expires && { expires },
+    ...meta2 && { opaque: meta2 }
+  });
+}
+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 from({
+    ...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 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@3.25.76__express@5.2.1_hono@4.12.9_open_8aabd0282577a5490f679a88cca7000d/node_modules/mppx/dist/Credential.js
+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 from2(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 serialize2(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@3.25.76__express@5.2.1_hono@4.12.9_open_8aabd0282577a5490f679a88cca7000d/node_modules/mppx/dist/Method.js
+var Method_exports = {};
+__export(Method_exports, {
+  from: () => from3,
+  toClient: () => toClient,
+  toServer: () => toServer
+});
+function from3(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 } = options;
+  return {
+    ...method,
+    defaults,
+    request,
+    respond,
+    transport,
+    verify
+  };
+}
+
+// ../../node_modules/.pnpm/mppx@0.4.9_@modelcontextprotocol+sdk@1.28.0_zod@3.25.76__express@5.2.1_hono@4.12.9_open_8aabd0282577a5490f679a88cca7000d/node_modules/mppx/dist/Mcp.js
+var paymentRequiredCode = -32042;
+var credentialMetaKey = "org.paymentauth/credential";
+
+export {
+  Expires_exports,
+  amount,
+  hash,
+  signature,
+  zod_exports,
+  fromResponse,
+  fromResponseList,
+  deserialize3 as deserialize,
+  serialize2 as serialize,
+  Credential_exports,
+  from3 as from,
+  toClient,
+  Method_exports,
+  paymentRequiredCode,
+  credentialMetaKey
+};
+//# sourceMappingURL=chunk-W7ACGWI5.js.map