@pome-sh/cli 0.21.13 → 0.21.14

package/dist/{src-YH33B2LP.js → src-566DJYOC.js}

@@ -1,3 +1,4 @@
+import { bracketedQuery, integerInput, booleanInput, declareRouteInputs, mountDeclaredRoute, UndeclaredInputError } from './chunk-4MQULI7E.js';
 import { failureInjectionRuleSchema, loadMcpToolFixture, openTwinDatabase, createFailureInjectionStore, defineTwin, twinBuildInfo, deriveMcpToolTable, failureInjectionMiddleware, createApp, FAILURE_INJECTION_OVERRIDE_KEY, recordedRequestHeaders, UnknownToolError } from './chunk-TV5S6WQV.js';
 import './chunk-VBATFCWR.js';
 import './chunk-SG6ZTIMT.js';
@@ -2742,406 +2743,507 @@ function errorMessage(body) {
   }
   return "request failed";
 }
-function parseListQuery(c) {
-  const limit = c.req.query("limit");
-  const numericLimit = limit !== void 0 ? Number(limit) : void 0;
-  const created2 = createdRangeFromQuery(c);
-  return {
-    limit: Number.isFinite(numericLimit) ? numericLimit : void 0,
-    starting_after: c.req.query("starting_after"),
-    ending_before: c.req.query("ending_before"),
-    ...created2
-  };
+function declaredRoute(router, declaration, recorder, runId, fn) {
+  mountDeclaredRoute(router, declaration, (c) => handle(c, recorder, runId, async () => fn(await parseDeclared(declaration, c), c)));
 }
-async function readBodyForm(c) {
-  const contentType = c.req.header("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    try {
-      return await c.req.json();
-    } catch {
-      return {};
-    }
-  }
-  if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
-    try {
-      const form = await c.req.parseBody({ all: true });
-      return formToObject(form);
-    } catch {
-      return {};
-    }
-  }
+async function parseDeclared(declaration, c) {
   try {
-    return await c.req.json();
-  } catch {
-    try {
-      const form = await c.req.parseBody({ all: true });
-      return formToObject(form);
-    } catch {
-      return {};
+    return await declaration.parse(c.req);
+  } catch (error) {
+    if (error instanceof UndeclaredInputError) {
+      throw new TwinError("invalid_request_error", "parameter_unknown", `Received unknown parameter: ${error.first}`, { param: error.first, statusCode: 400 });
     }
+    throw error;
   }
 }
-function formToObject(form) {
-  const out = {};
-  for (const [rawKey, value] of Object.entries(form)) {
-    const path = parseBracketPath(rawKey);
-    setDeep(out, path, value);
-  }
-  return out;
-}
-var POLLUTION_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function parseBracketPath(key) {
-  const parts = [];
-  const regex = /([^\[\]]+)|\[([^\[\]]*)\]/g;
-  let match;
-  while ((match = regex.exec(key)) !== null) {
-    const piece = match[1] ?? match[2] ?? "";
-    if (/^\d+$/.test(piece))
-      parts.push(Number(piece));
-    else
-      parts.push(piece);
-  }
-  return parts;
-}
-function setDeep(target, path, value) {
-  for (const key of path) {
-    if (typeof key === "string" && POLLUTION_KEYS.has(key)) {
-      return;
-    }
-  }
-  let cursor = target;
-  for (let i = 0; i < path.length; i++) {
-    const key = path[i];
-    const isLast = i === path.length - 1;
-    if (isLast) {
-      cursor[key] = value;
-    } else {
-      const nextKey = path[i + 1];
-      if (cursor[key] === void 0) {
-        cursor[key] = typeof nextKey === "number" ? [] : {};
-      }
-      cursor = cursor[key];
-    }
-  }
+function listQuery(query) {
+  return {
+    limit: query.limit,
+    starting_after: query.starting_after,
+    ending_before: query.ending_before,
+    ...flattenCreated(query.created)
+  };
 }
-function createdRangeFromQuery(c) {
+function flattenCreated(created2) {
   const out = {};
-  const flat = c.req.query("created");
+  if (created2 === void 0)
+    return out;
+  const flat = typeof created2 === "string" ? created2 : created2.value;
   if (flat !== void 0 && /^\d+$/.test(flat)) {
     out.created_gte = Number(flat);
     out.created_lte = Number(flat);
   }
-  const gt = c.req.query("created[gt]");
-  const gte = c.req.query("created[gte]");
-  const lt = c.req.query("created[lt]");
-  const lte = c.req.query("created[lte]");
-  if (gt && /^\d+$/.test(gt))
-    out.created_gt = Number(gt);
-  if (gte && /^\d+$/.test(gte))
-    out.created_gte = Number(gte);
-  if (lt && /^\d+$/.test(lt))
-    out.created_lt = Number(lt);
-  if (lte && /^\d+$/.test(lte))
-    out.created_lte = Number(lte);
+  if (typeof created2 === "string")
+    return out;
+  for (const op of ["gt", "gte", "lt", "lte"]) {
+    const value = created2[op];
+    if (value !== void 0 && /^\d+$/.test(value))
+      out[`created_${op}`] = Number(value);
+  }
   return out;
 }
-var formBool = z.union([z.boolean(), z.enum(["true", "false"]).transform((v) => v === "true")]).optional();
-var createPISchema = z.object({
+var ID_PATH = { id: z.string().min(1) };
+var LIST_QUERY = {
+  limit: integerInput({ min: 1 }).optional(),
+  starting_after: z.string().optional(),
+  ending_before: z.string().optional(),
+  created: bracketedQuery(z.union([z.string(), z.record(z.string(), z.string())]).optional())
+};
+var NULLABLE_METADATA = z.record(z.string(), z.string().nullable()).optional();
+var CREATE_PAYMENT_INTENT_BODY = {
   amount: z.coerce.number().int().positive(),
   currency: z.string().min(1),
   payment_method_types: z.array(z.string()).min(1),
   payment_method_options: z.object({
     crypto: z.object({
       mode: z.literal("deposit"),
-      deposit_options: z.object({
-        networks: z.array(z.string()).min(1).optional()
-      }).optional()
+      deposit_options: z.object({ networks: z.array(z.string()).min(1).optional() }).optional()
     })
   }).optional(),
   payment_method: z.string().optional(),
   customer: z.string().optional(),
-  confirm: formBool,
+  confirm: booleanInput.optional(),
   metadata: z.record(z.string(), z.string()).optional(),
   capture_method: z.string().optional(),
   confirmation_method: z.string().optional()
-});
-var confirmPISchema = z.object({
-  payment_method: z.string().optional()
-});
-var updatePISchema = z.object({
+};
+var UPDATE_PAYMENT_INTENT_BODY = {
   amount: z.coerce.number().int().optional(),
-  metadata: z.record(z.string(), z.string().nullable()).optional(),
+  metadata: NULLABLE_METADATA,
   payment_method: z.string().optional(),
   customer: z.string().optional()
-});
+};
+var CONFIRM_PAYMENT_INTENT_BODY = { payment_method: z.string().optional() };
+var CREATE_REFUND_BODY = {
+  charge: z.string().optional(),
+  amount: z.coerce.number().optional(),
+  reason: z.string().nullish()
+};
+var CUSTOMER_FIELDS_BODY = {
+  name: z.string().nullish(),
+  email: z.string().nullish(),
+  description: z.string().nullish(),
+  phone: z.string().nullish(),
+  metadata: NULLABLE_METADATA
+};
+var CREATE_PAYMENT_METHOD_BODY = {
+  type: z.unknown().optional(),
+  card: z.unknown().optional()
+};
+var PRODUCT_FIELDS_BODY = {
+  name: z.string().min(1).optional(),
+  description: z.string().nullish(),
+  active: booleanInput.optional(),
+  metadata: NULLABLE_METADATA
+};
+var CREATE_PRICE_BODY = {
+  currency: z.string().min(1).optional(),
+  product: z.string().min(1).optional(),
+  unit_amount: z.coerce.number().int().nonnegative().optional(),
+  recurring: z.object({
+    interval: z.string().min(1),
+    interval_count: z.coerce.number().int().positive().optional()
+  }).optional(),
+  nickname: z.string().nullish(),
+  lookup_key: z.string().nullish(),
+  active: booleanInput.optional(),
+  metadata: NULLABLE_METADATA
+};
+var CREATE_SUBSCRIPTION_BODY = {
+  customer: z.string().min(1).optional(),
+  items: z.array(z.object({
+    price: z.string().min(1).optional(),
+    quantity: z.coerce.number().int().positive().optional()
+  })).optional(),
+  cancel_at_period_end: booleanInput.optional(),
+  metadata: NULLABLE_METADATA
+};
+var UPDATE_SUBSCRIPTION_BODY = {
+  cancel_at_period_end: booleanInput.optional(),
+  metadata: NULLABLE_METADATA
+};
+var STRIPE_ROUTES = {
+  // ---------- PaymentIntents ----------
+  createPaymentIntent: declareRouteInputs({
+    method: "POST",
+    path: "/v1/payment_intents",
+    bodyEncoding: "form",
+    body: CREATE_PAYMENT_INTENT_BODY
+  }),
+  retrievePaymentIntent: declareRouteInputs({
+    method: "GET",
+    path: "/v1/payment_intents/:id",
+    pathParams: ID_PATH
+  }),
+  listPaymentIntents: declareRouteInputs({
+    method: "GET",
+    path: "/v1/payment_intents",
+    query: LIST_QUERY
+  }),
+  confirmPaymentIntent: declareRouteInputs({
+    method: "POST",
+    path: "/v1/payment_intents/:id/confirm",
+    pathParams: ID_PATH,
+    bodyEncoding: "form",
+    body: CONFIRM_PAYMENT_INTENT_BODY
+  }),
+  updatePaymentIntent: declareRouteInputs({
+    method: "POST",
+    path: "/v1/payment_intents/:id",
+    pathParams: ID_PATH,
+    bodyEncoding: "form",
+    body: UPDATE_PAYMENT_INTENT_BODY
+  }),
+  // Cancellation takes no body at all here. Real Stripe accepts
+  // `cancellation_reason`; this twin has never read it, so it is not declared.
+  cancelPaymentIntent: declareRouteInputs({
+    method: "POST",
+    path: "/v1/payment_intents/:id/cancel",
+    pathParams: ID_PATH
+  }),
+  simulateCryptoDeposit: declareRouteInputs({
+    method: "POST",
+    path: "/v1/test_helpers/payment_intents/:id/simulate_crypto_deposit",
+    pathParams: ID_PATH
+  }),
+  // ---------- Charges ----------
+  retrieveCharge: declareRouteInputs({
+    method: "GET",
+    path: "/v1/charges/:id",
+    pathParams: ID_PATH
+  }),
+  listCharges: declareRouteInputs({
+    method: "GET",
+    path: "/v1/charges",
+    query: { ...LIST_QUERY, payment_intent: z.string().optional(), customer: z.string().optional() }
+  }),
+  // ---------- Refunds ----------
+  createRefund: declareRouteInputs({
+    method: "POST",
+    path: "/v1/refunds",
+    // A real declared input on this route: the handler reads it and the domain
+    // stores it on the refund. Undeclared headers are ignored rather than
+    // refused, so the engine's own (`Authorization`, `Stripe-Account`) need no
+    // entry here — they are not this route's inputs.
+    headers: { "Idempotency-Key": z.string().optional() },
+    bodyEncoding: "form",
+    body: CREATE_REFUND_BODY
+  }),
+  retrieveRefund: declareRouteInputs({
+    method: "GET",
+    path: "/v1/refunds/:id",
+    pathParams: ID_PATH
+  }),
+  listRefunds: declareRouteInputs({
+    method: "GET",
+    path: "/v1/refunds",
+    query: { ...LIST_QUERY, charge: z.string().optional(), payment_intent: z.string().optional() }
+  }),
+  // ---------- Customers ----------
+  createCustomer: declareRouteInputs({
+    method: "POST",
+    path: "/v1/customers",
+    bodyEncoding: "form",
+    body: CUSTOMER_FIELDS_BODY
+  }),
+  listCustomerPaymentMethods: declareRouteInputs({
+    method: "GET",
+    path: "/v1/customers/:id/payment_methods",
+    pathParams: ID_PATH,
+    query: { ...LIST_QUERY, type: z.string().optional() }
+  }),
+  retrieveCustomer: declareRouteInputs({
+    method: "GET",
+    path: "/v1/customers/:id",
+    pathParams: ID_PATH
+  }),
+  updateCustomer: declareRouteInputs({
+    method: "POST",
+    path: "/v1/customers/:id",
+    pathParams: ID_PATH,
+    bodyEncoding: "form",
+    body: CUSTOMER_FIELDS_BODY
+  }),
+  deleteCustomer: declareRouteInputs({
+    method: "DELETE",
+    path: "/v1/customers/:id",
+    pathParams: ID_PATH
+  }),
+  listCustomers: declareRouteInputs({
+    method: "GET",
+    path: "/v1/customers",
+    query: { ...LIST_QUERY, email: z.string().optional() }
+  }),
+  // ---------- Payment methods ----------
+  createPaymentMethod: declareRouteInputs({
+    method: "POST",
+    path: "/v1/payment_methods",
+    bodyEncoding: "form",
+    body: CREATE_PAYMENT_METHOD_BODY
+  }),
+  retrievePaymentMethod: declareRouteInputs({
+    method: "GET",
+    path: "/v1/payment_methods/:id",
+    pathParams: ID_PATH
+  }),
+  attachPaymentMethod: declareRouteInputs({
+    method: "POST",
+    path: "/v1/payment_methods/:id/attach",
+    pathParams: ID_PATH,
+    bodyEncoding: "form",
+    body: { customer: z.string().optional() }
+  }),
+  detachPaymentMethod: declareRouteInputs({
+    method: "POST",
+    path: "/v1/payment_methods/:id/detach",
+    pathParams: ID_PATH
+  }),
+  // ---------- Products ----------
+  createProduct: declareRouteInputs({
+    method: "POST",
+    path: "/v1/products",
+    bodyEncoding: "form",
+    body: PRODUCT_FIELDS_BODY
+  }),
+  retrieveProduct: declareRouteInputs({
+    method: "GET",
+    path: "/v1/products/:id",
+    pathParams: ID_PATH
+  }),
+  listProducts: declareRouteInputs({
+    method: "GET",
+    path: "/v1/products",
+    query: { ...LIST_QUERY, active: booleanInput.optional() }
+  }),
+  // ---------- Prices ----------
+  createPrice: declareRouteInputs({
+    method: "POST",
+    path: "/v1/prices",
+    bodyEncoding: "form",
+    body: CREATE_PRICE_BODY
+  }),
+  retrievePrice: declareRouteInputs({
+    method: "GET",
+    path: "/v1/prices/:id",
+    pathParams: ID_PATH
+  }),
+  listPrices: declareRouteInputs({
+    method: "GET",
+    path: "/v1/prices",
+    query: { ...LIST_QUERY, product: z.string().optional(), active: booleanInput.optional() }
+  }),
+  // ---------- Subscriptions ----------
+  createSubscription: declareRouteInputs({
+    method: "POST",
+    path: "/v1/subscriptions",
+    bodyEncoding: "form",
+    body: CREATE_SUBSCRIPTION_BODY
+  }),
+  retrieveSubscription: declareRouteInputs({
+    method: "GET",
+    path: "/v1/subscriptions/:id",
+    pathParams: ID_PATH
+  }),
+  updateSubscription: declareRouteInputs({
+    method: "POST",
+    path: "/v1/subscriptions/:id",
+    pathParams: ID_PATH,
+    bodyEncoding: "form",
+    body: UPDATE_SUBSCRIPTION_BODY
+  }),
+  cancelSubscription: declareRouteInputs({
+    method: "DELETE",
+    path: "/v1/subscriptions/:id",
+    pathParams: ID_PATH
+  }),
+  listSubscriptions: declareRouteInputs({
+    method: "GET",
+    path: "/v1/subscriptions",
+    query: { ...LIST_QUERY, customer: z.string().optional(), status: z.string().optional() }
+  }),
+  // ---------- Invoices (reads only) ----------
+  retrieveInvoice: declareRouteInputs({
+    method: "GET",
+    path: "/v1/invoices/:id",
+    pathParams: ID_PATH
+  }),
+  listInvoices: declareRouteInputs({
+    method: "GET",
+    path: "/v1/invoices",
+    query: LIST_QUERY
+  }),
+  // ---------- Balance ----------
+  retrieveBalance: declareRouteInputs({
+    method: "GET",
+    path: "/v1/balance"
+  }),
+  listBalanceTransactions: declareRouteInputs({
+    method: "GET",
+    path: "/v1/balance_transactions",
+    query: { ...LIST_QUERY, type: z.string().optional() }
+  }),
+  // ---------- Events ----------
+  retrieveEvent: declareRouteInputs({
+    method: "GET",
+    path: "/v1/events/:id",
+    pathParams: ID_PATH
+  }),
+  listEvents: declareRouteInputs({
+    method: "GET",
+    path: "/v1/events",
+    query: { ...LIST_QUERY, type: z.string().optional() }
+  })
+};
+
+// ../packages/twin-stripe/dist/src/routes/payment-intents.js
 function registerPaymentIntentRoutes(router, domain, recorder, runId) {
-  router.post("/v1/payment_intents", (c) => handle(c, recorder, runId, async () => {
-    const body = await readBodyForm(c);
-    const input = createPISchema.parse(body);
-    const { body: piBody, delta } = domain.createPaymentIntent(accountId(c), input);
+  declaredRoute(router, STRIPE_ROUTES.createPaymentIntent, recorder, runId, ({ body }, c) => {
+    const { body: piBody, delta } = domain.createPaymentIntent(accountId(c), body);
     return created(piBody, delta);
-  }));
-  router.get("/v1/payment_intents/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrievePaymentIntent(accountId(c), c.req.param("id")))));
-  router.get("/v1/payment_intents", (c) => handle(c, recorder, runId, () => {
-    const list = parseListQuery(c);
-    return ok(domain.listPaymentIntents(accountId(c), list));
-  }));
-  router.post("/v1/payment_intents/:id/confirm", (c) => handle(c, recorder, runId, async () => {
-    const input = confirmPISchema.parse(await readBodyForm(c));
-    const { body, delta } = domain.confirmPaymentIntent(accountId(c), c.req.param("id"), input);
-    return ok(body, true, delta);
-  }));
-  router.post("/v1/payment_intents/:id", (c) => handle(c, recorder, runId, async () => {
-    const input = updatePISchema.parse(await readBodyForm(c));
-    const { body, delta } = domain.updatePaymentIntent(accountId(c), c.req.param("id"), input);
-    return ok(body, true, delta);
-  }));
-  router.post("/v1/payment_intents/:id/cancel", (c) => handle(c, recorder, runId, () => {
-    const { body, delta } = domain.cancelPaymentIntent(accountId(c), c.req.param("id"));
+  });
+  declaredRoute(router, STRIPE_ROUTES.retrievePaymentIntent, recorder, runId, ({ path }, c) => ok(domain.retrievePaymentIntent(accountId(c), path.id)));
+  declaredRoute(router, STRIPE_ROUTES.listPaymentIntents, recorder, runId, ({ query }, c) => ok(domain.listPaymentIntents(accountId(c), listQuery(query))));
+  declaredRoute(router, STRIPE_ROUTES.confirmPaymentIntent, recorder, runId, ({ path, body }, c) => {
+    const { body: piBody, delta } = domain.confirmPaymentIntent(accountId(c), path.id, body);
+    return ok(piBody, true, delta);
+  });
+  declaredRoute(router, STRIPE_ROUTES.updatePaymentIntent, recorder, runId, ({ path, body }, c) => {
+    const { body: piBody, delta } = domain.updatePaymentIntent(accountId(c), path.id, body);
+    return ok(piBody, true, delta);
+  });
+  declaredRoute(router, STRIPE_ROUTES.cancelPaymentIntent, recorder, runId, ({ path }, c) => {
+    const { body, delta } = domain.cancelPaymentIntent(accountId(c), path.id);
     return ok(body, true, delta);
-  }));
-  router.post("/v1/test_helpers/payment_intents/:id/simulate_crypto_deposit", (c) => handle(c, recorder, runId, () => {
-    const { body, delta } = domain.simulateCryptoDeposit(accountId(c), c.req.param("id"));
+  });
+  declaredRoute(router, STRIPE_ROUTES.simulateCryptoDeposit, recorder, runId, ({ path }, c) => {
+    const { body, delta } = domain.simulateCryptoDeposit(accountId(c), path.id);
     return ok(body, true, delta);
-  }));
+  });
 }
 
 // ../packages/twin-stripe/dist/src/routes/charges.js
 function registerChargesRoutes(router, domain, recorder, runId) {
-  router.get("/v1/charges/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveCharge(accountId(c), c.req.param("id")))));
-  router.get("/v1/charges", (c) => handle(c, recorder, runId, () => {
-    const list = parseListQuery(c);
-    return ok(domain.listCharges(accountId(c), {
-      ...list,
-      payment_intent: c.req.query("payment_intent"),
-      customer: c.req.query("customer")
-    }));
-  }));
+  declaredRoute(router, STRIPE_ROUTES.retrieveCharge, recorder, runId, ({ path }, c) => ok(domain.retrieveCharge(accountId(c), path.id)));
+  declaredRoute(router, STRIPE_ROUTES.listCharges, recorder, runId, ({ query }, c) => ok(domain.listCharges(accountId(c), {
+    ...listQuery(query),
+    payment_intent: query.payment_intent,
+    customer: query.customer
+  })));
 }
 
 // ../packages/twin-stripe/dist/src/routes/balance.js
 function registerBalanceRoutes(router, domain, recorder, runId) {
-  router.get("/v1/balance", (c) => handle(c, recorder, runId, () => ok(domain.retrieveBalance(accountId(c)))));
-  router.get("/v1/balance_transactions", (c) => handle(c, recorder, runId, () => {
-    const list = parseListQuery(c);
-    return ok(domain.listBalanceTransactions(accountId(c), {
-      ...list,
-      type: c.req.query("type")
-    }));
-  }));
+  declaredRoute(router, STRIPE_ROUTES.retrieveBalance, recorder, runId, (_input, c) => ok(domain.retrieveBalance(accountId(c))));
+  declaredRoute(router, STRIPE_ROUTES.listBalanceTransactions, recorder, runId, ({ query }, c) => ok(domain.listBalanceTransactions(accountId(c), { ...listQuery(query), type: query.type })));
 }
 
 // ../packages/twin-stripe/dist/src/routes/events.js
 function registerEventsRoutes(router, domain, recorder, runId) {
-  router.get("/v1/events/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveEvent(accountId(c), c.req.param("id")))));
-  router.get("/v1/events", (c) => handle(c, recorder, runId, () => {
-    const list = parseListQuery(c);
-    return ok(domain.listEvents(accountId(c), {
-      ...list,
-      type: c.req.query("type")
-    }));
-  }));
+  declaredRoute(router, STRIPE_ROUTES.retrieveEvent, recorder, runId, ({ path }, c) => ok(domain.retrieveEvent(accountId(c), path.id)));
+  declaredRoute(router, STRIPE_ROUTES.listEvents, recorder, runId, ({ query }, c) => ok(domain.listEvents(accountId(c), { ...listQuery(query), type: query.type })));
 }
 
 // ../packages/twin-stripe/dist/src/routes/refunds.js
 function registerRefundsRoutes(router, domain, recorder, runId) {
-  router.post("/v1/refunds", (c) => handle(c, recorder, runId, async () => {
-    const body = await readJson(c);
+  declaredRoute(router, STRIPE_ROUTES.createRefund, recorder, runId, ({ body, header }, c) => {
     const { body: response, delta } = domain.createRefund(accountId(c), {
-      charge: typeof body.charge === "string" ? body.charge : "",
-      amount: typeof body.amount === "number" ? body.amount : void 0,
-      reason: typeof body.reason === "string" ? body.reason : null,
-      idempotency_key: c.req.header("Idempotency-Key") ?? c.req.header("idempotency-key") ?? null
+      // An absent `charge` still reaches the domain, which answers it with
+      // Stripe's `parameter_missing`.
+      charge: body.charge ?? "",
+      amount: body.amount,
+      reason: body.reason ?? null,
+      idempotency_key: header["Idempotency-Key"] ?? null
     });
     return created(response, delta);
-  }));
-  router.get("/v1/refunds/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveRefund(accountId(c), c.req.param("id")))));
-  router.get("/v1/refunds", (c) => handle(c, recorder, runId, () => {
-    const list = parseListQuery(c);
-    return ok(domain.listRefunds(accountId(c), {
-      ...list,
-      charge: c.req.query("charge"),
-      payment_intent: c.req.query("payment_intent")
-    }));
-  }));
-}
-async function readJson(c) {
-  const contentType = c.req.header("content-type") ?? "";
-  if (contentType.includes("application/x-www-form-urlencoded")) {
-    try {
-      const parsed = await c.req.parseBody();
-      return coerceFormBody(parsed);
-    } catch {
-      return {};
-    }
-  }
-  try {
-    const body = await c.req.json();
-    return body && typeof body === "object" ? body : {};
-  } catch {
-    return {};
-  }
-}
-function coerceFormBody(form) {
-  const out = {};
-  for (const [k, v] of Object.entries(form)) {
-    if (typeof v === "string" && /^-?\d+$/.test(v) && k === "amount") {
-      out[k] = Number(v);
-    } else {
-      out[k] = v;
-    }
-  }
-  return out;
+  });
+  declaredRoute(router, STRIPE_ROUTES.retrieveRefund, recorder, runId, ({ path }, c) => ok(domain.retrieveRefund(accountId(c), path.id)));
+  declaredRoute(router, STRIPE_ROUTES.listRefunds, recorder, runId, ({ query }, c) => ok(domain.listRefunds(accountId(c), {
+    ...listQuery(query),
+    charge: query.charge,
+    payment_intent: query.payment_intent
+  })));
 }
-var customerFieldsSchema = z.object({
-  name: z.string().nullish(),
-  email: z.string().nullish(),
-  description: z.string().nullish(),
-  phone: z.string().nullish(),
-  metadata: z.record(z.string(), z.string().nullable()).optional()
-});
+
+// ../packages/twin-stripe/dist/src/routes/customers.js
 function registerCustomersRoutes(router, domain, recorder, runId) {
-  router.post("/v1/customers", (c) => handle(c, recorder, runId, async () => {
-    const input = customerFieldsSchema.parse(await readBodyForm(c));
-    const { body, delta } = domain.createCustomer(accountId(c), input);
-    return created(body, delta);
-  }));
-  router.get("/v1/customers/:id/payment_methods", (c) => handle(c, recorder, runId, () => {
-    const list = parseListQuery(c);
-    return ok(domain.listCustomerPaymentMethods(accountId(c), c.req.param("id"), {
-      ...list,
-      type: c.req.query("type")
-    }));
-  }));
-  router.get("/v1/customers/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveCustomer(accountId(c), c.req.param("id")))));
-  router.post("/v1/customers/:id", (c) => handle(c, recorder, runId, async () => {
-    const input = customerFieldsSchema.parse(await readBodyForm(c));
-    const { body, delta } = domain.updateCustomer(accountId(c), c.req.param("id"), input);
-    return ok(body, true, delta);
-  }));
-  router.delete("/v1/customers/:id", (c) => handle(c, recorder, runId, () => {
-    const { body, delta } = domain.deleteCustomer(accountId(c), c.req.param("id"));
+  declaredRoute(router, STRIPE_ROUTES.createCustomer, recorder, runId, ({ body }, c) => {
+    const { body: response, delta } = domain.createCustomer(accountId(c), body);
+    return created(response, delta);
+  });
+  declaredRoute(router, STRIPE_ROUTES.listCustomerPaymentMethods, recorder, runId, ({ path, query }, c) => ok(domain.listCustomerPaymentMethods(accountId(c), path.id, {
+    ...listQuery(query),
+    type: query.type
+  })));
+  declaredRoute(router, STRIPE_ROUTES.retrieveCustomer, recorder, runId, ({ path }, c) => ok(domain.retrieveCustomer(accountId(c), path.id)));
+  declaredRoute(router, STRIPE_ROUTES.updateCustomer, recorder, runId, ({ path, body }, c) => {
+    const { body: response, delta } = domain.updateCustomer(accountId(c), path.id, body);
+    return ok(response, true, delta);
+  });
+  declaredRoute(router, STRIPE_ROUTES.deleteCustomer, recorder, runId, ({ path }, c) => {
+    const { body, delta } = domain.deleteCustomer(accountId(c), path.id);
     return ok(body, true, delta);
-  }));
-  router.get("/v1/customers", (c) => handle(c, recorder, runId, () => {
-    const list = parseListQuery(c);
-    return ok(domain.listCustomers(accountId(c), { ...list, email: c.req.query("email") }));
-  }));
+  });
+  declaredRoute(router, STRIPE_ROUTES.listCustomers, recorder, runId, ({ query }, c) => ok(domain.listCustomers(accountId(c), { ...listQuery(query), email: query.email })));
 }
 
 // ../packages/twin-stripe/dist/src/routes/payment-methods.js
 function registerPaymentMethodsRoutes(router, domain, recorder, runId) {
-  router.post("/v1/payment_methods", (c) => handle(c, recorder, runId, async () => {
-    const body = await readBodyForm(c);
+  declaredRoute(router, STRIPE_ROUTES.createPaymentMethod, recorder, runId, ({ body }, c) => {
     const { body: response, delta } = domain.createPaymentMethod(accountId(c), body);
     return created(response, delta);
-  }));
-  router.get("/v1/payment_methods/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrievePaymentMethod(accountId(c), c.req.param("id")))));
-  router.post("/v1/payment_methods/:id/attach", (c) => handle(c, recorder, runId, async () => {
-    const body = await readBodyForm(c);
-    const customer = typeof body.customer === "string" ? body.customer : "";
-    if (!customer) {
+  });
+  declaredRoute(router, STRIPE_ROUTES.retrievePaymentMethod, recorder, runId, ({ path }, c) => ok(domain.retrievePaymentMethod(accountId(c), path.id)));
+  declaredRoute(router, STRIPE_ROUTES.attachPaymentMethod, recorder, runId, ({ path, body }, c) => {
+    if (!body.customer) {
       throw new TwinError("invalid_request_error", "parameter_missing", "Missing required param: customer.", { param: "customer", statusCode: 400 });
     }
-    const { body: response, delta } = domain.attachPaymentMethod(accountId(c), c.req.param("id"), customer);
+    const { body: response, delta } = domain.attachPaymentMethod(accountId(c), path.id, body.customer);
     return ok(response, true, delta);
-  }));
-  router.post("/v1/payment_methods/:id/detach", (c) => handle(c, recorder, runId, () => {
-    const { body, delta } = domain.detachPaymentMethod(accountId(c), c.req.param("id"));
+  });
+  declaredRoute(router, STRIPE_ROUTES.detachPaymentMethod, recorder, runId, ({ path }, c) => {
+    const { body, delta } = domain.detachPaymentMethod(accountId(c), path.id);
     return ok(body, true, delta);
-  }));
+  });
 }
-var formBool2 = z.union([z.boolean(), z.enum(["true", "false"]).transform((v) => v === "true")]).optional();
-var metadataSchema = z.record(z.string(), z.string().nullable()).optional();
-var productFieldsSchema = z.object({
-  name: z.string().min(1).optional(),
-  description: z.string().nullish(),
-  active: formBool2,
-  metadata: metadataSchema
-});
-var createPriceSchema = z.object({
-  currency: z.string().min(1).optional(),
-  product: z.string().min(1).optional(),
-  unit_amount: z.coerce.number().int().nonnegative().optional(),
-  recurring: z.object({
-    interval: z.string().min(1),
-    interval_count: z.coerce.number().int().positive().optional()
-  }).optional(),
-  nickname: z.string().nullish(),
-  lookup_key: z.string().nullish(),
-  active: formBool2,
-  metadata: metadataSchema
-});
-var createSubscriptionSchema = z.object({
-  customer: z.string().min(1).optional(),
-  items: z.array(z.object({
-    price: z.string().min(1).optional(),
-    quantity: z.coerce.number().int().positive().optional()
-  })).optional(),
-  cancel_at_period_end: formBool2,
-  metadata: metadataSchema
-});
-var updateSubscriptionSchema = z.object({
-  cancel_at_period_end: formBool2,
-  metadata: metadataSchema
-});
+
+// ../packages/twin-stripe/dist/src/routes/billing.js
 function registerBillingRoutes(router, domain, recorder, runId) {
-  router.post("/v1/products", (c) => handle(c, recorder, runId, async () => {
-    const input = productFieldsSchema.parse(await readBodyForm(c));
-    const { body, delta } = domain.createProduct(accountId(c), input);
-    return created(body, delta);
-  }));
-  router.get("/v1/products/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveProduct(accountId(c), c.req.param("id")))));
-  router.get("/v1/products", (c) => handle(c, recorder, runId, () => {
-    const list = parseListQuery(c);
-    return ok(domain.listProducts(accountId(c), { ...list, active: queryBool(c.req.query("active")) }));
-  }));
-  router.post("/v1/prices", (c) => handle(c, recorder, runId, async () => {
-    const input = createPriceSchema.parse(await readBodyForm(c));
-    const { body, delta } = domain.createPrice(accountId(c), input);
-    return created(body, delta);
-  }));
-  router.get("/v1/prices/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrievePrice(accountId(c), c.req.param("id")))));
-  router.get("/v1/prices", (c) => handle(c, recorder, runId, () => {
-    const list = parseListQuery(c);
-    return ok(domain.listPrices(accountId(c), {
-      ...list,
-      product: c.req.query("product"),
-      active: queryBool(c.req.query("active"))
-    }));
-  }));
-  router.post("/v1/subscriptions", (c) => handle(c, recorder, runId, async () => {
-    const input = createSubscriptionSchema.parse(await readBodyForm(c));
-    const { body, delta } = domain.createSubscription(accountId(c), input);
-    return created(body, delta);
-  }));
-  router.get("/v1/subscriptions/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveSubscription(accountId(c), c.req.param("id")))));
-  router.post("/v1/subscriptions/:id", (c) => handle(c, recorder, runId, async () => {
-    const input = updateSubscriptionSchema.parse(await readBodyForm(c));
-    const { body, delta } = domain.updateSubscription(accountId(c), c.req.param("id"), input);
-    return ok(body, true, delta);
-  }));
-  router.delete("/v1/subscriptions/:id", (c) => handle(c, recorder, runId, () => {
-    const { body, delta } = domain.cancelSubscription(accountId(c), c.req.param("id"));
+  declaredRoute(router, STRIPE_ROUTES.createProduct, recorder, runId, ({ body }, c) => {
+    const { body: response, delta } = domain.createProduct(accountId(c), body);
+    return created(response, delta);
+  });
+  declaredRoute(router, STRIPE_ROUTES.retrieveProduct, recorder, runId, ({ path }, c) => ok(domain.retrieveProduct(accountId(c), path.id)));
+  declaredRoute(router, STRIPE_ROUTES.listProducts, recorder, runId, ({ query }, c) => ok(domain.listProducts(accountId(c), { ...listQuery(query), active: query.active })));
+  declaredRoute(router, STRIPE_ROUTES.createPrice, recorder, runId, ({ body }, c) => {
+    const { body: response, delta } = domain.createPrice(accountId(c), body);
+    return created(response, delta);
+  });
+  declaredRoute(router, STRIPE_ROUTES.retrievePrice, recorder, runId, ({ path }, c) => ok(domain.retrievePrice(accountId(c), path.id)));
+  declaredRoute(router, STRIPE_ROUTES.listPrices, recorder, runId, ({ query }, c) => ok(domain.listPrices(accountId(c), {
+    ...listQuery(query),
+    product: query.product,
+    active: query.active
+  })));
+  declaredRoute(router, STRIPE_ROUTES.createSubscription, recorder, runId, ({ body }, c) => {
+    const { body: response, delta } = domain.createSubscription(accountId(c), body);
+    return created(response, delta);
+  });
+  declaredRoute(router, STRIPE_ROUTES.retrieveSubscription, recorder, runId, ({ path }, c) => ok(domain.retrieveSubscription(accountId(c), path.id)));
+  declaredRoute(router, STRIPE_ROUTES.updateSubscription, recorder, runId, ({ path, body }, c) => {
+    const { body: response, delta } = domain.updateSubscription(accountId(c), path.id, body);
+    return ok(response, true, delta);
+  });
+  declaredRoute(router, STRIPE_ROUTES.cancelSubscription, recorder, runId, ({ path }, c) => {
+    const { body, delta } = domain.cancelSubscription(accountId(c), path.id);
     return ok(body, true, delta);
-  }));
-  router.get("/v1/subscriptions", (c) => handle(c, recorder, runId, () => {
-    const list = parseListQuery(c);
-    return ok(domain.listSubscriptions(accountId(c), {
-      ...list,
-      customer: c.req.query("customer"),
-      status: c.req.query("status")
-    }));
-  }));
-  router.get("/v1/invoices/:id", (c) => handle(c, recorder, runId, () => ok(domain.retrieveInvoice(accountId(c), c.req.param("id")))));
-  router.get("/v1/invoices", (c) => handle(c, recorder, runId, () => ok(domain.listInvoices(accountId(c), parseListQuery(c)))));
-}
-function queryBool(value) {
-  if (value === "true")
-    return true;
-  if (value === "false")
-    return false;
-  return void 0;
+  });
+  declaredRoute(router, STRIPE_ROUTES.listSubscriptions, recorder, runId, ({ query }, c) => ok(domain.listSubscriptions(accountId(c), {
+    ...listQuery(query),
+    customer: query.customer,
+    status: query.status
+  })));
+  declaredRoute(router, STRIPE_ROUTES.retrieveInvoice, recorder, runId, ({ path }, c) => ok(domain.retrieveInvoice(accountId(c), path.id)));
+  declaredRoute(router, STRIPE_ROUTES.listInvoices, recorder, runId, ({ query }, c) => ok(domain.listInvoices(accountId(c), listQuery(query))));
 }
 
 // ../packages/twin-stripe/dist/src/routes/index.js
@@ -3910,7 +4012,7 @@ var createdRange = {
     })
   ]).optional()
 };
-function flattenCreated(input) {
+function flattenCreated2(input) {
   if (input.created === void 0)
     return {};
   if (typeof input.created === "number") {
@@ -4128,7 +4230,7 @@ function executeTool(domain, accountId2, name, input) {
     case "retrieve_payment_intent":
       return domain.retrievePaymentIntent(accountId2, parsed.id);
     case "list_payment_intents": {
-      const flat = flattenCreated(parsed);
+      const flat = flattenCreated2(parsed);
       return domain.listPaymentIntents(accountId2, { ...parsed, ...flat });
     }
     case "confirm_payment_intent":
@@ -4146,7 +4248,7 @@ function executeTool(domain, accountId2, name, input) {
     case "retrieve_charge":
       return domain.retrieveCharge(accountId2, parsed.id);
     case "list_charges": {
-      const flat = flattenCreated(parsed);
+      const flat = flattenCreated2(parsed);
       return domain.listCharges(accountId2, { ...parsed, ...flat });
     }
     case "create_refund":
@@ -4154,7 +4256,7 @@ function executeTool(domain, accountId2, name, input) {
     case "retrieve_refund":
       return domain.retrieveRefund(accountId2, parsed.id);
     case "list_refunds": {
-      const flat = flattenCreated(parsed);
+      const flat = flattenCreated2(parsed);
       return domain.listRefunds(accountId2, { ...parsed, ...flat });
     }
     case "create_customer":
@@ -4168,7 +4270,7 @@ function executeTool(domain, accountId2, name, input) {
     case "delete_customer":
       return domain.deleteCustomer(accountId2, parsed.id).body;
     case "list_customers": {
-      const flat = flattenCreated(parsed);
+      const flat = flattenCreated2(parsed);
       return domain.listCustomers(accountId2, { ...parsed, ...flat });
     }
     case "list_customer_payment_methods": {
@@ -4186,13 +4288,13 @@ function executeTool(domain, accountId2, name, input) {
     case "retrieve_balance":
       return domain.retrieveBalance(accountId2);
     case "list_balance_transactions": {
-      const flat = flattenCreated(parsed);
+      const flat = flattenCreated2(parsed);
       return domain.listBalanceTransactions(accountId2, { ...parsed, ...flat });
     }
     case "retrieve_event":
       return domain.retrieveEvent(accountId2, parsed.id);
     case "list_events": {
-      const flat = flattenCreated(parsed);
+      const flat = flattenCreated2(parsed);
       return domain.listEvents(accountId2, { ...parsed, ...flat });
     }
   }