theokit 0.2.4 → 0.4.0

package/dist/chunk-UUFYP2UM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server/webhook/timing-safe-equal.ts","../src/server/webhook/raw-body.ts","../src/server/webhook/define-webhook.ts"],"sourcesContent":["/**\n * Constant-time byte comparison.\n *\n * Wraps `node:crypto.timingSafeEqual` when available (Node 6.6+) and falls\n * back to a constant-time XOR loop for runtimes without `node:crypto`\n * (Cloudflare Workers, Deno, Bun edge). Required to defeat timing attacks\n * on webhook signature verification — a naive `===` or `Buffer.equals`\n * would short-circuit on first mismatch byte and leak signature position\n * via wall-clock timing.\n *\n * Web Crypto's `crypto.subtle.verify` would also work, but requires a\n * `CryptoKey` object and is asymmetric (verify a signature against a key).\n * For our case — comparing two pre-computed digests — raw byte equality\n * is the correct primitive.\n *\n * @see https://nodejs.org/api/crypto.html#cryptotimingsafeequala-b\n * @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/verify\n */\n\ntype NodeTimingSafeEqual = (a: Uint8Array, b: Uint8Array) => boolean\n\nlet cachedNodeImpl: NodeTimingSafeEqual | null | undefined\n\nfunction resolveNodeImpl(): NodeTimingSafeEqual | null {\n  if (cachedNodeImpl !== undefined) return cachedNodeImpl\n  try {\n    // require() avoids the dynamic-import-of-node-builtin warnings some\n    // bundlers emit; `node:crypto` is always synchronously available.\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const cryptoMod = require('node:crypto') as {\n      timingSafeEqual?: NodeTimingSafeEqual\n    }\n    cachedNodeImpl = cryptoMod.timingSafeEqual ?? null\n  } catch {\n    cachedNodeImpl = null\n  }\n  return cachedNodeImpl\n}\n\n/**\n * Returns true iff `a` and `b` have identical bytes. Takes time\n * proportional to `a.length` regardless of where bytes differ.\n *\n * @throws TypeError if either argument is not a Uint8Array.\n */\nexport function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean {\n  if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) {\n    throw new TypeError(\n      `timingSafeEqual expects Uint8Array arguments (got ${typeof a} and ${typeof b})`,\n    )\n  }\n  // Length mismatch is constant-time-safe by construction (no per-byte work).\n  if (a.length !== b.length) return false\n  if (a.length === 0) return true\n\n  // Prefer the Node built-in when present — it's implemented in C and\n  // matches the contract exactly. node:crypto.timingSafeEqual throws on\n  // length mismatch, which we've already filtered above.\n  const nodeImpl = resolveNodeImpl()\n  if (nodeImpl) return nodeImpl(a, b)\n\n  // Fallback: XOR-accumulate every byte into one accumulator. NEVER\n  // short-circuit. The compiler / V8 will not constant-fold this loop\n  // because the inputs are dynamic.\n  let diff = 0\n  for (let i = 0; i < a.length; i++) {\n    diff |= a[i] ^ b[i]\n  }\n  return diff === 0\n}\n","/**\n * Read a Web `Request` body as a raw string EXACTLY ONCE and expose it\n * alongside the original request (which remains readable by downstream\n * code). Enforces a configurable `maxBodyBytes` cap to prevent OOM via\n * pathological POST.\n *\n * MUST be called FIRST in the webhook pipeline, before any other code\n * touches the body (`request.text()`, `request.json()`, parsers). Once\n * the body is consumed, `Request.clone()` throws and this function fails.\n *\n * EC-101: default `maxBodyBytes = 1_000_000` (1 MB) covers Stripe\n * (256 KB max), Slack (4 MB but compressed), and is well below Node\n * memory thresholds. GitHub webhooks up to 25 MB MUST opt in\n * (`maxBodyBytes: 25_000_000`).\n *\n * @see https://docs.stripe.com/webhooks/signatures\n * @see https://docs.github.com/en/webhooks/using-webhooks/best-practices-for-using-webhooks\n */\n\nexport const DEFAULT_MAX_BODY_BYTES = 1_000_000\n\nexport interface ReadRawBodyOptions {\n  /** Maximum bytes to read before throwing `BodyTooLargeError`. Defaults to 1 MB. */\n  maxBodyBytes?: number\n}\n\nexport interface RawBodyResult {\n  /** UTF-8 decoded body (or empty string when no body present). */\n  rawBody: string\n  /** The ORIGINAL request, still readable by downstream code. */\n  bodyClone: Request\n}\n\n/**\n * Thrown when the request body exceeds `maxBodyBytes`. Carries status\n * 413 (Payload Too Large) and stable code `BODY_TOO_LARGE` so callers\n * can map it to an HTTP response without sniffing the message.\n */\nexport class BodyTooLargeError extends Error {\n  readonly status = 413\n  readonly code = 'BODY_TOO_LARGE'\n\n  constructor(\n    public readonly limit: number,\n    public readonly actualSeen: number,\n  ) {\n    super(`Request body exceeds maxBodyBytes: seen ${actualSeen} bytes, limit ${limit} bytes`)\n    this.name = 'BodyTooLargeError'\n  }\n}\n\nexport async function readRawBody(\n  request: Request,\n  options: ReadRawBodyOptions = {},\n): Promise<RawBodyResult> {\n  const maxBodyBytes = options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES\n\n  // Clone the request so the original remains readable. `.clone()` throws\n  // synchronously (TypeError) if the body was already consumed — we let\n  // that propagate so callers fail fast with a clear error.\n  const clone = request.clone()\n\n  // No body at all (GET, HEAD, or empty POST). Both clone.body and\n  // clone.text() handle this gracefully but we short-circuit for clarity\n  // and to avoid an unnecessary stream read.\n  if (clone.body === null) {\n    return { rawBody: '', bodyClone: request }\n  }\n\n  const reader = clone.body.getReader()\n  const chunks: Uint8Array[] = []\n  let total = 0\n\n  try {\n    for (;;) {\n      const { value, done } = await reader.read()\n      if (done) break\n      total += value.byteLength\n      if (total > maxBodyBytes) {\n        // Cancel the stream without awaiting (avoids deadlock on some\n        // ReadableStream impls). The finally block releases the lock.\n        void reader.cancel()\n        throw new BodyTooLargeError(maxBodyBytes, total)\n      }\n      chunks.push(value)\n    }\n  } finally {\n    try {\n      reader.releaseLock()\n    } catch {\n      // lock may already be released by cancel()\n    }\n  }\n\n  // Concat all chunks into a single Uint8Array, then UTF-8 decode.\n  const bytes = new Uint8Array(total)\n  let offset = 0\n  for (const chunk of chunks) {\n    bytes.set(chunk, offset)\n    offset += chunk.byteLength\n  }\n  const rawBody = new TextDecoder().decode(bytes)\n\n  return { rawBody, bodyClone: request }\n}\n","import {\n  extractTraceContext,\n  generateNewTraceContext,\n} from '../observability/trace-context-propagation.js'\n\nimport { BodyTooLargeError, readRawBody } from './raw-body.js'\nimport type {\n  DefineWebhookOptions,\n  VerifyResult,\n  WebhookContext,\n  WebhookDefinition,\n} from './webhook-types.js'\n\n/**\n * Declare a webhook handler with first-class signature verification\n * (R0.5.10, ADR-0005). Pure identity helper — returns the definition\n * unchanged for downstream dispatch.\n *\n * @example\n * ```ts\n * // server/webhooks/stripe.ts\n * import { defineWebhook } from 'theokit/server'\n * import { stripe } from 'theokit/server/webhook/providers'\n *\n * export default defineWebhook({\n *   verify: stripe({ secret: process.env.STRIPE_WEBHOOK_SECRET! }),\n *   async handler({ rawBody }) {\n *     const event = JSON.parse(rawBody)\n *     // ...\n *     return new Response('ok')\n *   },\n * })\n * ```\n */\nexport function defineWebhook(opts: DefineWebhookOptions): WebhookDefinition {\n  return {\n    verify: opts.verify,\n    handler: opts.handler,\n    maxBodyBytes: opts.maxBodyBytes,\n    __theokit_kind: 'webhook',\n  }\n}\n\n/**\n * Dispatch a webhook request through the definition's verify → handler\n * pipeline. Returns the handler's `Response` (or a wrapped one), or a\n * 401/413 response when verification or body size guards trip.\n *\n * EC-101: enforces `maxBodyBytes` (default 1MB via readRawBody).\n * EC-103: every throw from `verify` (sync or async) is treated as\n * `{ok: false, reason: 'verify threw: <message>'}`. Handler NEVER\n * invoked on verify failure.\n */\nexport async function dispatchWebhook(def: WebhookDefinition, request: Request): Promise<Response> {\n  let rawBody: string\n  let bodyClone: Request\n  try {\n    const result = await readRawBody(request, { maxBodyBytes: def.maxBodyBytes })\n    rawBody = result.rawBody\n    bodyClone = result.bodyClone\n  } catch (err) {\n    if (err instanceof BodyTooLargeError) {\n      return new Response(JSON.stringify({ error: err.code, message: err.message }), {\n        status: 413,\n        headers: { 'content-type': 'application/json' },\n      })\n    }\n    return new Response(\n      JSON.stringify({\n        error: 'BAD_REQUEST',\n        message: err instanceof Error ? err.message : 'failed to read body',\n      }),\n      { status: 400, headers: { 'content-type': 'application/json' } },\n    )\n  }\n\n  // Resolve traceId — propagate or generate.\n  const incomingTrace = extractTraceContext(request.headers)\n  const traceId = incomingTrace?.trace_id ?? generateNewTraceContext().trace_id\n\n  // EC-103: verify exception MUST close the door, never let handler run.\n  let verifyResult: VerifyResult\n  try {\n    verifyResult = await def.verify(bodyClone)\n  } catch (err) {\n    verifyResult = {\n      ok: false,\n      reason: `verify threw: ${err instanceof Error ? err.message : String(err)}`,\n    }\n  }\n\n  if (!verifyResult.ok) {\n    return new Response(\n      JSON.stringify({ error: 'WEBHOOK_VERIFY_FAILED', message: verifyResult.reason }),\n      { status: 401, headers: { 'content-type': 'application/json' } },\n    )\n  }\n\n  const ctx: WebhookContext = {\n    request: bodyClone,\n    rawBody,\n    traceId,\n    signal: request.signal,\n  }\n\n  const result = await def.handler(ctx)\n  if (result instanceof Response) return result\n  if (result === undefined || result === null) {\n    return new Response(null, { status: 204 })\n  }\n  return new Response(JSON.stringify(result), {\n    status: 200,\n    headers: { 'content-type': 'application/json' },\n  })\n}\n"],"mappings":"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","names":["result"]}

package/dist/{chunk-SNDZQ64K.js → chunk-VBZCVFSA.js}

@@ -2,7 +2,7 @@
 import "tsx/esm";
 import {
   walkSourceFiles
-} from "./chunk-5OFPQK6N.js";
+} from "./chunk-COXLEZCN.js";
 
 // src/core/contracts/http-methods.ts
 var HTTP_METHODS = [
@@ -18,7 +18,7 @@ var HTTP_METHOD_LOWERCASE = HTTP_METHODS.map((m) => m.toLowerCase());
 
 // src/server/scan/scan.ts
 import { existsSync, statSync } from "fs";
-import { extname, join, relative } from "path";
+import { basename, extname, join, relative } from "path";
 
 // src/server/scan/detect-http-methods.ts
 import { readFileSync } from "fs";
@@ -73,6 +73,31 @@ function detectExportedHttpMethods(filePath, content) {
   return [...found].sort();
 }
 
+// src/server/scan/errors.ts
+var ROUTER_MIGRATION_GUIDE_URL = "https://theokit.dev/migration/0.3-to-0.4-router";
+var RouterConventionError = class extends Error {
+  name = "RouterConventionError";
+  file;
+  suggestion;
+  migrationUrl;
+  constructor(opts) {
+    const migrationUrl = opts.migrationUrl ?? ROUTER_MIGRATION_GUIDE_URL;
+    const message = [
+      `Router convention violation: dotted route basename is not supported in theokit 0.4+.`,
+      ``,
+      `  File: ${opts.file}`,
+      `  Use directory-nested form: ${opts.suggestion}`,
+      ``,
+      `Migration guide: ${migrationUrl}`,
+      `Run \`theokit migrate router\` to convert all dotted basenames automatically.`
+    ].join("\n");
+    super(message);
+    this.file = opts.file;
+    this.suggestion = opts.suggestion;
+    this.migrationUrl = migrationUrl;
+  }
+};
+
 // src/server/scan/match.ts
 function compilePattern(routePath) {
   const paramNames = [];
@@ -102,6 +127,61 @@ function matchRoute(url, routes) {
 
 // src/server/scan/scan.ts
 var ROUTE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+var TEST_OR_SPEC_RE = /\.(test|spec)\.[jt]sx?$/;
+function isTestOrSpecFile(filePath) {
+  return TEST_OR_SPEC_RE.test(basename(filePath));
+}
+function hasDotOutsideBrackets(segment) {
+  let depth = 0;
+  for (const ch of segment) {
+    if (ch === "[") depth++;
+    else if (ch === "]") depth--;
+    else if (ch === "." && depth === 0) return true;
+  }
+  return false;
+}
+function splitDottedSegmentOutsideBrackets(segment) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (const ch of segment) {
+    if (ch === "[") {
+      depth++;
+      current += ch;
+    } else if (ch === "]") {
+      depth--;
+      current += ch;
+    } else if (ch === "." && depth === 0) {
+      if (current) parts.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current) parts.push(current);
+  return parts;
+}
+function buildDirectoryNestedSuggestion(filePath, routesDir) {
+  const rel = relative(routesDir, filePath).replace(/\\/g, "/");
+  const ext = extname(rel);
+  const withoutExt = rel.slice(0, -ext.length);
+  const segments = withoutExt.split("/").flatMap(splitDottedSegmentOutsideBrackets);
+  return `routes/${segments.join("/")}${ext}`;
+}
+function assertNoDottedSegment(filePath, routesDir) {
+  const rel = relative(routesDir, filePath).replace(/\\/g, "/");
+  const ext = extname(rel);
+  const withoutExt = rel.slice(0, -ext.length);
+  const segments = withoutExt.split("/");
+  for (const seg of segments) {
+    if (hasDotOutsideBrackets(seg)) {
+      throw new RouterConventionError({
+        file: filePath,
+        suggestion: buildDirectoryNestedSuggestion(filePath, routesDir)
+      });
+    }
+  }
+}
 function fileToRoutePath(filePath, routesDir) {
   let rel = relative(routesDir, filePath);
   const ext = extname(rel);
@@ -123,6 +203,8 @@ function scanServerRoutes(serverDir) {
   }
   const results = [];
   walkSourceFiles(routesDir, { extensions: ROUTE_EXTENSIONS }, (absPath) => {
+    if (isTestOrSpecFile(absPath)) return;
+    assertNoDottedSegment(absPath, routesDir);
     const routePath = fileToRoutePath(absPath, routesDir);
     const { pattern, paramNames } = compilePattern(routePath);
     const methods = detectExportedHttpMethods(absPath);
@@ -186,4 +268,4 @@ export {
   scanServerRoutes,
   scanWebSocketRoutes
 };
-//# sourceMappingURL=chunk-SNDZQ64K.js.map
+//# sourceMappingURL=chunk-VBZCVFSA.js.map

package/dist/chunk-VBZCVFSA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/contracts/http-methods.ts","../src/server/scan/scan.ts","../src/server/scan/detect-http-methods.ts","../src/server/scan/errors.ts","../src/server/scan/match.ts","../src/server/scan/ws-scan.ts"],"sourcesContent":["/**\n * Canonical HTTP method set used by the typed client codegen + Proxy runtime.\n * Kept here (under `server/scan/`) because the SCAN is the first consumer —\n * `vite-plugin/app-typed-client.ts` (Phase 2) and `client/app-client.ts` (Phase 3)\n * import from here to ensure a single source of truth.\n *\n * Lowercase variants are derived via `.toLowerCase()` at call sites; we do not\n * export them separately to avoid drift between the two lists.\n */\n\nexport const HTTP_METHODS = [\n  'GET',\n  'POST',\n  'PUT',\n  'PATCH',\n  'DELETE',\n  'HEAD',\n  'OPTIONS',\n] as const\n\nexport type HttpMethod = (typeof HTTP_METHODS)[number]\n\nexport const HTTP_METHOD_LOWERCASE = HTTP_METHODS.map((m) => m.toLowerCase()) as readonly string[]\n","/* eslint-disable security/detect-non-literal-fs-filename --\n * Build-time scanner: walks `serverDir/routes/` derived from cwd.\n * No HTTP input ever reaches these fs calls.\n */\nimport { existsSync, statSync } from 'node:fs'\nimport { basename, extname, join, relative } from 'node:path'\n\nimport { walkSourceFiles } from '../_internal/scan-walker.js'\n\nimport { detectExportedHttpMethods } from './detect-http-methods.js'\nimport { RouterConventionError } from './errors.js'\nimport { compilePattern, type ServerRouteNode } from './match.js'\n\nconst ROUTE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx'])\n\n// EC-4: Co-located unit/spec tests must be silently skipped by the scanner,\n// BEFORE the dotted-basename check fires. Matches `*.test.ts|tsx|js|jsx`\n// and `*.spec.ts|tsx|js|jsx`.\nconst TEST_OR_SPEC_RE = /\\.(test|spec)\\.[jt]sx?$/\n\nfunction isTestOrSpecFile(filePath: string): boolean {\n  return TEST_OR_SPEC_RE.test(basename(filePath))\n}\n\nfunction hasDotOutsideBrackets(segment: string): boolean {\n  let depth = 0\n  for (const ch of segment) {\n    if (ch === '[') depth++\n    else if (ch === ']') depth--\n    else if (ch === '.' && depth === 0) return true\n  }\n  return false\n}\n\nfunction splitDottedSegmentOutsideBrackets(segment: string): string[] {\n  const parts: string[] = []\n  let current = ''\n  let depth = 0\n  for (const ch of segment) {\n    if (ch === '[') {\n      depth++\n      current += ch\n    } else if (ch === ']') {\n      depth--\n      current += ch\n    } else if (ch === '.' && depth === 0) {\n      if (current) parts.push(current)\n      current = ''\n    } else {\n      current += ch\n    }\n  }\n  if (current) parts.push(current)\n  return parts\n}\n\nfunction buildDirectoryNestedSuggestion(filePath: string, routesDir: string): string {\n  const rel = relative(routesDir, filePath).replace(/\\\\/g, '/')\n  const ext = extname(rel)\n  const withoutExt = rel.slice(0, -ext.length)\n  const segments = withoutExt.split('/').flatMap(splitDottedSegmentOutsideBrackets)\n  return `routes/${segments.join('/')}${ext}`\n}\n\nfunction assertNoDottedSegment(filePath: string, routesDir: string): void {\n  const rel = relative(routesDir, filePath).replace(/\\\\/g, '/')\n  const ext = extname(rel)\n  const withoutExt = rel.slice(0, -ext.length)\n  const segments = withoutExt.split('/')\n  for (const seg of segments) {\n    if (hasDotOutsideBrackets(seg)) {\n      throw new RouterConventionError({\n        file: filePath,\n        suggestion: buildDirectoryNestedSuggestion(filePath, routesDir),\n      })\n    }\n  }\n}\n\nfunction fileToRoutePath(filePath: string, routesDir: string): string {\n  let rel = relative(routesDir, filePath)\n  // Strip extension\n  const ext = extname(rel)\n  rel = rel.slice(0, -ext.length)\n  // Normalize separators\n  rel = rel.replace(/\\\\/g, '/')\n  // Strip index suffix\n  if (rel.endsWith('/index')) {\n    rel = rel.slice(0, -6)\n  } else if (rel === 'index') {\n    rel = ''\n  }\n  // Replace [...param] with :...param (catch-all, before regular params).\n  // Replace [param] with :param. Inputs are file paths bounded by the\n  // OS filename limit; the bracket capture is bounded by `]`.\n  rel = rel.replace(/\\[\\.\\.\\.([^\\]]+)\\]/g, ':...$1')\n  // eslint-disable-next-line sonarjs/slow-regex -- bounded by `]`; input is a single filename\n  rel = rel.replace(/\\[([^\\]]+)\\]/g, ':$1')\n  return `/api/${rel}`\n}\n\nexport function scanServerRoutes(serverDir: string): ServerRouteNode[] {\n  const routesDir = join(serverDir, 'routes')\n  if (!existsSync(routesDir) || !statSync(routesDir).isDirectory()) {\n    return []\n  }\n\n  const results: ServerRouteNode[] = []\n  walkSourceFiles(routesDir, { extensions: ROUTE_EXTENSIONS }, (absPath) => {\n    // EC-4: skip co-located test/spec files BEFORE the dotted-basename check\n    if (isTestOrSpecFile(absPath)) return\n\n    // G6 T1.1: reject dotted basenames (legacy convention that produced wrong\n    // paramNames due to greedy `:(?:\\.\\.\\.)?([^/]+)` regex in compilePattern).\n    assertNoDottedSegment(absPath, routesDir)\n\n    const routePath = fileToRoutePath(absPath, routesDir)\n    const { pattern, paramNames } = compilePattern(routePath)\n    const methods = detectExportedHttpMethods(absPath)\n    results.push({\n      filePath: absPath,\n      routePath,\n      paramNames,\n      pattern,\n      methods,\n    })\n  })\n\n  // T1.4 / EC-2 — refuse to scan if a user route collides with the reserved\n  // batch endpoint path. User must rename or disable batching.\n  const conflicting = results.find((r) => r.routePath === '/api/__theo_batch__')\n  if (conflicting) {\n    throw new Error(\n      `Server route ${conflicting.filePath} resolves to '/api/__theo_batch__' which is reserved for the batch endpoint. Rename the route or disable batching in theo.config.ts.`,\n    )\n  }\n\n  // Sort: static first, then dynamic, then catch-all last\n  const isCatchAll = (route: ServerRouteNode) => route.routePath.includes(':...')\n  results.sort((a, b) => {\n    const aStatic = a.paramNames.length === 0\n    const bStatic = b.paramNames.length === 0\n    const aCatchAll = isCatchAll(a)\n    const bCatchAll = isCatchAll(b)\n\n    // Static routes first\n    if (aStatic && !bStatic) return -1\n    if (!aStatic && bStatic) return 1\n    // Catch-all routes last\n    if (aCatchAll && !bCatchAll) return 1\n    if (!aCatchAll && bCatchAll) return -1\n    return a.routePath.localeCompare(b.routePath)\n  })\n\n  return results\n}\n","/**\n * Detect which HTTP-method named exports a route file declares.\n *\n * Uses the TypeScript compiler API (not regex) per G1 edge-case review EC-4:\n * regex over file content emits false positives for `// export const GET = ...`\n * in comments and `` `export const GET = ...` `` in template literals. AST\n * walking avoids both classes of bug.\n *\n * `typescript` ships as CommonJS with internal dynamic `require('fs')`.\n * When loaded via ESM `import`, the dynamic requires fail at module-bootstrap.\n * We use `createRequire(import.meta.url)` to keep the package on its native\n * CJS path. The type-only namespace import gives us the AST helpers shape.\n *\n * Returns the set of HTTP methods (uppercase) the file exports. Empty array\n * means the file has no HTTP exports (the route file is util-only).\n */\n\nimport { readFileSync } from 'node:fs'\nimport { createRequire } from 'node:module'\n\nimport type * as TS from 'typescript'\n\nimport { HTTP_METHODS, type HttpMethod } from '../../core/contracts/http-methods.js'\n\nconst require_ = createRequire(import.meta.url)\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst ts = require_('typescript') as typeof TS\n\nconst HTTP_METHOD_NAMES = new Set<string>(HTTP_METHODS)\n\nfunction hasExportModifier(modifiers: readonly TS.Modifier[] | undefined): boolean {\n  if (!modifiers) return false\n  for (const m of modifiers) {\n    if (m.kind === ts.SyntaxKind.ExportKeyword) return true\n  }\n  return false\n}\n\nfunction collectFromStatement(stmt: TS.Statement, found: Set<HttpMethod>): void {\n  // `export const GET = ...` / `export function GET ...` / `export async function GET ...`\n  if (ts.isVariableStatement(stmt) && hasExportModifier(ts.getModifiers(stmt))) {\n    for (const decl of stmt.declarationList.declarations) {\n      if (ts.isIdentifier(decl.name) && HTTP_METHOD_NAMES.has(decl.name.text)) {\n        found.add(decl.name.text as HttpMethod)\n      }\n    }\n    return\n  }\n\n  if (\n    (ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt)) &&\n    hasExportModifier(ts.getModifiers(stmt))\n  ) {\n    if (stmt.name && HTTP_METHOD_NAMES.has(stmt.name.text)) {\n      found.add(stmt.name.text as HttpMethod)\n    }\n    return\n  }\n\n  // `export { GET }` / `export { handler as GET } from './shared'` (EC-5)\n  if (ts.isExportDeclaration(stmt) && stmt.exportClause && ts.isNamedExports(stmt.exportClause)) {\n    for (const spec of stmt.exportClause.elements) {\n      // spec.name is the exported (re-)name; spec.propertyName is the original (when renamed)\n      if (HTTP_METHOD_NAMES.has(spec.name.text)) {\n        found.add(spec.name.text as HttpMethod)\n      }\n    }\n  }\n}\n\nexport function detectExportedHttpMethods(filePath: string, content?: string): HttpMethod[] {\n  const src = content ?? readFileSync(filePath, 'utf-8')\n  const sourceFile = ts.createSourceFile(\n    filePath,\n    src,\n    ts.ScriptTarget.Latest,\n    /* setParentNodes */ false,\n    ts.ScriptKind.TS,\n  )\n  const found = new Set<HttpMethod>()\n  for (const stmt of sourceFile.statements) {\n    collectFromStatement(stmt, found)\n  }\n  return [...found].sort()\n}\n","/**\n * Router-convention errors thrown by the server-route scanner.\n *\n * Plan: .claude/knowledge-base/plans/g6-router-convention-plan.md v1.1\n *\n * theokit 0.4.0+ enforces directory-nested file-system routing\n * (`auth/[provider]/login.ts`) and REJECTS dotted-basename routes\n * (`auth.[provider].login.ts`) because the legacy regex extracted the\n * dotted basename incorrectly — `params.provider` was undefined at request\n * time. See ADR-XXX (router-convention-decision) in CHANGELOG 0.4.0.\n */\n\n/**\n * Canonical migration guide URL. T4.2 establishes this as the authoritative\n * landing page. EC-3: error message uses this constant so the URL never\n * drifts from the doc location.\n */\nexport const ROUTER_MIGRATION_GUIDE_URL = 'https://theokit.dev/migration/0.3-to-0.4-router'\n\nexport interface RouterConventionErrorOptions {\n  /** Absolute path of the offending route file. */\n  file: string\n  /** Suggested directory-nested replacement path (relative, e.g. `routes/auth/[provider]/login.ts`). */\n  suggestion: string\n  /** Migration guide URL (defaults to `ROUTER_MIGRATION_GUIDE_URL`). */\n  migrationUrl?: string\n}\n\n/**\n * Thrown by `scanServerRoutes` when a route file uses the legacy\n * dotted-basename convention (`auth.[provider].login.ts`).\n *\n * The error is FAIL-FAST by design — running with a route that has wrong\n * `paramNames` produces silent 404s at request time, which is strictly\n * worse than a build-time error.\n */\nexport class RouterConventionError extends Error {\n  override readonly name = 'RouterConventionError'\n  readonly file: string\n  readonly suggestion: string\n  readonly migrationUrl: string\n\n  constructor(opts: RouterConventionErrorOptions) {\n    const migrationUrl = opts.migrationUrl ?? ROUTER_MIGRATION_GUIDE_URL\n    const message = [\n      `Router convention violation: dotted route basename is not supported in theokit 0.4+.`,\n      ``,\n      `  File: ${opts.file}`,\n      `  Use directory-nested form: ${opts.suggestion}`,\n      ``,\n      `Migration guide: ${migrationUrl}`,\n      `Run \\`theokit migrate router\\` to convert all dotted basenames automatically.`,\n    ].join('\\n')\n    super(message)\n    this.file = opts.file\n    this.suggestion = opts.suggestion\n    this.migrationUrl = migrationUrl\n  }\n}\n","export interface ServerRouteNode {\n  filePath: string\n  routePath: string\n  paramNames: string[]\n  pattern: RegExp\n  /** HTTP methods (uppercase) the route file exports. Optional for backward\n   * compatibility with manifests generated before G1. Empty array means the\n   * file has no HTTP exports (util-only); undefined means \"not detected\". */\n  methods?: string[]\n}\n\nexport function compilePattern(routePath: string): {\n  pattern: RegExp\n  paramNames: string[]\n} {\n  const paramNames: string[] = []\n  // Single pass: handle both catch-all (:...name) and regular (:name) params\n  const regexStr = routePath.replace(/:(?:\\.\\.\\.)?([^/]+)/g, (match: string, name: string) => {\n    paramNames.push(name)\n    // Catch-all matches across slashes, regular matches single segment\n    return match.startsWith(':...') ? '(.+)' : '([^/]+)'\n  })\n  // `regexStr` is derived from a developer-authored route path (build-time\n  // input, not HTTP-controlled). The `security/detect-non-literal-regexp`\n  // rule cannot see this constraint — disable narrowly.\n  // eslint-disable-next-line security/detect-non-literal-regexp -- route pattern from build-time scan, never HTTP input\n  return { pattern: new RegExp(`^${regexStr}$`), paramNames }\n}\n\nexport function matchRoute(\n  url: string,\n  routes: ServerRouteNode[],\n): { route: ServerRouteNode; params: Record<string, string> } | null {\n  // Strip query string and trailing slash\n  let path = url.split('?')[0]\n  if (path.length > 1 && path.endsWith('/')) {\n    path = path.slice(0, -1)\n  }\n\n  for (const route of routes) {\n    const match = route.pattern.exec(path)\n    if (match) {\n      const params: Record<string, string> = {}\n      route.paramNames.forEach((name, i) => {\n        params[name] = match[i + 1]\n      })\n      return { route, params }\n    }\n  }\n  return null\n}\n","/* eslint-disable security/detect-non-literal-fs-filename --\n * Build-time scanner: walks `serverDir/ws/` derived from cwd.\n * No HTTP input ever reaches these fs calls.\n */\nimport { existsSync, statSync } from 'node:fs'\nimport { extname, join, relative } from 'node:path'\n\nimport { walkSourceFiles } from '../_internal/scan-walker.js'\n\nconst WS_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx'])\n\nexport interface WebSocketRouteNode {\n  filePath: string\n  wsPath: string\n}\n\nexport function scanWebSocketRoutes(serverDir: string): WebSocketRouteNode[] {\n  const wsDir = join(serverDir, 'ws')\n  if (!existsSync(wsDir) || !statSync(wsDir).isDirectory()) {\n    return []\n  }\n\n  const results: WebSocketRouteNode[] = []\n  walkSourceFiles(wsDir, { extensions: WS_EXTENSIONS }, (absPath) => {\n    let rel = relative(wsDir, absPath)\n    rel = rel.replace(/\\\\/g, '/')\n    rel = rel.slice(0, -extname(rel).length)\n    if (rel.endsWith('/index')) rel = rel.slice(0, -6)\n    else if (rel === 'index') rel = ''\n    results.push({\n      filePath: absPath,\n      wsPath: `/ws/${rel}`,\n    })\n  })\n  return results\n}\n"],"mappings":"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","names":["existsSync","statSync","extname","join","relative","join","existsSync","statSync","relative","extname"]}

package/dist/chunk-VMEWD57H.js

@@ -0,0 +1,137 @@
+// src/server/rate-limit/rate-limit-store.ts
+var InMemoryStore = class _InMemoryStore {
+  store = /* @__PURE__ */ new Map();
+  /** Bound the map to prevent unbounded growth from pathological inputs. */
+  static MAX_ENTRIES = 1e5;
+  /** GC sweep interval, milliseconds. */
+  static GC_INTERVAL_MS = 3e4;
+  gcTimer = null;
+  constructor() {
+    if (typeof setInterval !== "undefined") {
+      const timer = setInterval(() => {
+        this.sweepExpired();
+      }, _InMemoryStore.GC_INTERVAL_MS);
+      this.gcTimer = timer;
+      const maybeUnref = timer.unref;
+      if (typeof maybeUnref === "function") maybeUnref.call(timer);
+    }
+  }
+  /**
+   * Synchronous fast-path used by the legacy sync `createRateLimiter`
+   * surface (`api-middleware.ts` is sync). The async `incr` delegates to
+   * this for in-memory; external adapters override `incr` directly.
+   */
+  incrSync(key, windowMs) {
+    if (!Number.isFinite(windowMs) || windowMs <= 0) {
+      throw new Error(
+        `InMemoryStore.incr: windowMs must be a positive finite number (got ${windowMs})`
+      );
+    }
+    const now = Date.now();
+    if (this.store.size >= _InMemoryStore.MAX_ENTRIES) {
+      const first = this.store.keys().next().value;
+      if (first !== void 0) this.store.delete(first);
+    }
+    const entry = this.store.get(key);
+    if (!entry || now >= entry.resetAt) {
+      const fresh = { count: 1, resetAt: now + windowMs };
+      this.store.set(key, fresh);
+      return { ...fresh };
+    }
+    entry.count++;
+    return { count: entry.count, resetAt: entry.resetAt };
+  }
+  /** Sweep expired entries. Called by the GC timer; safe to call manually. */
+  sweepExpired() {
+    const now = Date.now();
+    for (const [k, v] of this.store) {
+      if (v.resetAt <= now) this.store.delete(k);
+    }
+  }
+  /**
+   * Stop the GC timer. Call from tests or when discarding the store. After
+   * `dispose`, the store still works but no longer auto-sweeps.
+   */
+  dispose() {
+    if (this.gcTimer) {
+      clearInterval(this.gcTimer);
+      this.gcTimer = null;
+    }
+  }
+  // The async surface is required by the `RateLimitStore` interface
+  // (Redis/etc. adapters are inherently async). For the in-memory case
+  // we just adapt the sync implementations to Promises.
+  // eslint-disable-next-line @typescript-eslint/require-await -- interface contract: async return
+  async incr(key, windowMs) {
+    return this.incrSync(key, windowMs);
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await -- interface contract: async return
+  async get(key) {
+    const now = Date.now();
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    if (now >= entry.resetAt) return null;
+    return { count: entry.count, resetAt: entry.resetAt };
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await -- interface contract: async return
+  async reset(key) {
+    this.store.delete(key);
+  }
+};
+
+// src/server/rate-limit/rate-limit.ts
+function createRateLimiter(config, opts = {}) {
+  const store = opts.store ?? new InMemoryStore();
+  const isInMemory = store instanceof InMemoryStore;
+  return function checkRateLimit(req) {
+    const key = req.socket?.remoteAddress ?? "unknown";
+    if (isInMemory) {
+      const state = store.incrSync(key, config.windowMs);
+      return resultFromState(state, config);
+    }
+    throw new Error(
+      "createRateLimiter: async RateLimitStore implementations are not supported by this sync fa\xE7ade. Use the InMemoryStore default or build a custom middleware around the async store directly."
+    );
+  };
+}
+function resultFromState(state, config) {
+  if (state.count > config.max) {
+    const retryAfter = Math.ceil((state.resetAt - Date.now()) / 1e3);
+    return {
+      limited: true,
+      headers: {
+        "X-RateLimit-Limit": String(config.max),
+        "X-RateLimit-Remaining": "0",
+        "Retry-After": String(retryAfter)
+      }
+    };
+  }
+  return {
+    limited: false,
+    headers: {
+      "X-RateLimit-Limit": String(config.max),
+      "X-RateLimit-Remaining": String(Math.max(0, config.max - state.count))
+    }
+  };
+}
+function createRateLimiterWeb(config, opts = {}) {
+  const store = opts.store ?? new InMemoryStore();
+  const isInMemory = store instanceof InMemoryStore;
+  return function checkRateLimitWeb(clientIp) {
+    const key = clientIp.length > 0 ? clientIp : "unknown";
+    if (isInMemory) {
+      const state = store.incrSync(key, config.windowMs);
+      return resultFromState(state, config);
+    }
+    throw new Error(
+      "createRateLimiterWeb: async RateLimitStore implementations are not supported by this sync fa\xE7ade. Use the InMemoryStore default or build a custom middleware around the async store directly."
+    );
+  };
+}
+
+export {
+  InMemoryStore,
+  createRateLimiter,
+  createRateLimiterWeb
+};
+//# sourceMappingURL=chunk-VMEWD57H.js.map

package/dist/chunk-VMEWD57H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server/rate-limit/rate-limit-store.ts","../src/server/rate-limit/rate-limit.ts"],"sourcesContent":["/**\n * T2.1 — RateLimitStore interface.\n *\n * Pluggable backend for the rate limiter. The default `InMemoryStore`\n * preserves current single-instance behavior. Multi-instance deployments\n * (TheoCloud canary, K8s replicas) opt in to a distributed adapter\n * (Redis, Cloudflare KV) without bloating single-instance apps.\n *\n * Contract per ADR D1:\n *   - `incr` is atomic — concurrent calls for the same key both observe\n *     the same `resetAt` and increment count by 1.\n *   - `get` returns `null` for expired entries (not just absent — checks\n *     `now > resetAt`).\n *   - `reset` removes the key entirely; next `incr` creates fresh.\n *\n * Async signature is honest about Redis adapters even though in-memory\n * implementation is synchronous. Callers MUST await.\n */\n\nexport interface RateLimitState {\n  /** Number of requests counted in the current window. */\n  count: number\n  /** Absolute timestamp (ms since epoch) when this window expires. */\n  resetAt: number\n}\n\nexport interface RateLimitStore {\n  /**\n   * Atomic increment-and-get. If the key is missing OR the previous\n   * window expired (`now >= resetAt`), create with `count=1, resetAt=now+windowMs`.\n   * Otherwise increment count by 1, preserving the original resetAt.\n   */\n  incr(key: string, windowMs: number): Promise<RateLimitState>\n\n  /** Read current state. Returns `null` for missing or expired entries. */\n  get(key: string): Promise<RateLimitState | null>\n\n  /** Remove a key. Used by login throttling on success (T6.1). */\n  reset(key: string): Promise<void>\n}\n\n/**\n * Default in-memory store. Backed by `Map<string, RateLimitState>`.\n *\n * GC: every 1000 `incr` calls, expired entries are removed. Pathological\n * key explosion is bounded by `MAX_ENTRIES` (LRU-evict oldest insertion).\n *\n * Single-thread by virtue of Node's event loop — `incr` is atomic at the\n * JavaScript level (no preemption between Map.get and Map.set).\n */\nexport class InMemoryStore implements RateLimitStore {\n  private store = new Map<string, RateLimitState>()\n  /** Bound the map to prevent unbounded growth from pathological inputs. */\n  static readonly MAX_ENTRIES = 100_000\n  /** GC sweep interval, milliseconds. */\n  static readonly GC_INTERVAL_MS = 30_000\n\n  private gcTimer: ReturnType<typeof setInterval> | null = null\n\n  constructor() {\n    // CR-007 fix: GC runs on a timer OUTSIDE the request hot path.\n    // Pre-fix, every 1000th `incrSync` triggered a synchronous Map sweep\n    // of up to 100K entries — an attacker with diverse client IPs could\n    // keep the Map full and force a blocking sweep predictably.\n    if (typeof setInterval !== 'undefined') {\n      const timer = setInterval(() => {\n        this.sweepExpired()\n      }, InMemoryStore.GC_INTERVAL_MS)\n      this.gcTimer = timer\n      // Allow the process to exit even with the timer pending. `unref` is\n      // Node-only; not present on browser/Cloudflare `setInterval`.\n      const maybeUnref = (timer as { unref?: () => void }).unref\n      if (typeof maybeUnref === 'function') maybeUnref.call(timer)\n    }\n  }\n\n  /**\n   * Synchronous fast-path used by the legacy sync `createRateLimiter`\n   * surface (`api-middleware.ts` is sync). The async `incr` delegates to\n   * this for in-memory; external adapters override `incr` directly.\n   */\n  incrSync(key: string, windowMs: number): RateLimitState {\n    if (!Number.isFinite(windowMs) || windowMs <= 0) {\n      throw new Error(\n        `InMemoryStore.incr: windowMs must be a positive finite number (got ${windowMs})`,\n      )\n    }\n    const now = Date.now()\n\n    // Bounded LRU-ish: when over cap, drop oldest insertion.\n    if (this.store.size >= InMemoryStore.MAX_ENTRIES) {\n      const first = this.store.keys().next().value\n      if (first !== undefined) this.store.delete(first)\n    }\n\n    const entry = this.store.get(key)\n    if (!entry || now >= entry.resetAt) {\n      const fresh = { count: 1, resetAt: now + windowMs }\n      this.store.set(key, fresh)\n      return { ...fresh }\n    }\n    entry.count++\n    return { count: entry.count, resetAt: entry.resetAt }\n  }\n\n  /** Sweep expired entries. Called by the GC timer; safe to call manually. */\n  sweepExpired(): void {\n    const now = Date.now()\n    for (const [k, v] of this.store) {\n      if (v.resetAt <= now) this.store.delete(k)\n    }\n  }\n\n  /**\n   * Stop the GC timer. Call from tests or when discarding the store. After\n   * `dispose`, the store still works but no longer auto-sweeps.\n   */\n  dispose(): void {\n    if (this.gcTimer) {\n      clearInterval(this.gcTimer)\n      this.gcTimer = null\n    }\n  }\n\n  // The async surface is required by the `RateLimitStore` interface\n  // (Redis/etc. adapters are inherently async). For the in-memory case\n  // we just adapt the sync implementations to Promises.\n  // eslint-disable-next-line @typescript-eslint/require-await -- interface contract: async return\n  async incr(key: string, windowMs: number): Promise<RateLimitState> {\n    return this.incrSync(key, windowMs)\n  }\n\n  // eslint-disable-next-line @typescript-eslint/require-await -- interface contract: async return\n  async get(key: string): Promise<RateLimitState | null> {\n    const now = Date.now()\n    const entry = this.store.get(key)\n    if (!entry) return null\n    if (now >= entry.resetAt) return null\n    return { count: entry.count, resetAt: entry.resetAt }\n  }\n\n  // eslint-disable-next-line @typescript-eslint/require-await -- interface contract: async return\n  async reset(key: string): Promise<void> {\n    this.store.delete(key)\n  }\n}\n","import type { IncomingMessage } from 'node:http'\n\nimport { InMemoryStore, type RateLimitStore } from './rate-limit-store.js'\n\n/**\n * Rate limit configuration — basic single-bucket shape. Per ADR D2, the\n * per-route + per-user variant is layered on top via T2.2; this base\n * struct is the smallest unit.\n */\nexport interface RateLimitConfig {\n  windowMs: number\n  max: number\n}\n\nexport interface RateLimitResult {\n  limited: boolean\n  headers: Record<string, string>\n}\n\n/**\n * Create a rate limiter that consumes a pluggable `RateLimitStore`.\n *\n * Backwards-compatible signature: callers passing only `config` get the\n * default `InMemoryStore`. Distributed deployments pass a Redis adapter\n * (or any other `RateLimitStore` implementation) via `opts.store`.\n *\n * T2.1: synchronous return for back-compat with the current\n * `api-middleware.ts` integration point. The async store contract is\n * exercised lazily — we use a sync fast-path against the in-memory store\n * (single-thread JS makes this safe). External stores remain async and\n * would require a different async wrapper at the middleware layer.\n */\nexport function createRateLimiter(config: RateLimitConfig, opts: { store?: RateLimitStore } = {}) {\n  const store = opts.store ?? new InMemoryStore()\n  const isInMemory = store instanceof InMemoryStore\n\n  return function checkRateLimit(req: IncomingMessage): RateLimitResult {\n    // `req.socket` is typed as always-present in Node typings; defensive\n    // for test doubles (object literals without `socket`).\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- defensive for test doubles\n    const key = req.socket?.remoteAddress ?? 'unknown'\n\n    if (isInMemory) {\n      // Sync fast-path: the in-memory store exposes a sync incr.\n      const state = store.incrSync(key, config.windowMs)\n      return resultFromState(state, config)\n    }\n\n    // External stores are NOT supported via this synchronous façade in\n    // 0.3.x. Users plugging Redis adapters today must wire it via a\n    // dedicated async middleware path (out-of-scope for T2.1; tracked\n    // for the follow-up `@theokit/rate-limit-redis` package).\n    throw new Error(\n      'createRateLimiter: async RateLimitStore implementations are not supported by this sync façade. ' +\n        'Use the InMemoryStore default or build a custom middleware around the async store directly.',\n    )\n  }\n}\n\nfunction resultFromState(\n  state: { count: number; resetAt: number },\n  config: RateLimitConfig,\n): RateLimitResult {\n  if (state.count > config.max) {\n    const retryAfter = Math.ceil((state.resetAt - Date.now()) / 1000)\n    return {\n      limited: true,\n      headers: {\n        'X-RateLimit-Limit': String(config.max),\n        'X-RateLimit-Remaining': '0',\n        'Retry-After': String(retryAfter),\n      },\n    }\n  }\n  return {\n    limited: false,\n    headers: {\n      'X-RateLimit-Limit': String(config.max),\n      'X-RateLimit-Remaining': String(Math.max(0, config.max - state.count)),\n    },\n  }\n}\n\n/**\n * T5a.2 Phase D slice 2/3 — Web-Standards single-bucket rate limiter.\n *\n * Mirror of `createRateLimiter(config, opts)` returning a checker that\n * accepts `(clientIp: string)` instead of `(req: IncomingMessage)`. Web\n * `Request` has no `req.socket.remoteAddress` — the IP is resolved by\n * the caller per-runtime (Node adapter from socket; CF Workers from\n * `cf-connecting-ip`; etc., same convention as Phase D slice 1/3's\n * `DeriveKeyRequestContext.clientIp`).\n *\n * Same `RateLimitConfig`, same `InMemoryStore` default, same async\n * store rejection (use a dedicated async middleware for external stores).\n * Same `RateLimitResult` return shape.\n *\n * **Signature difference from `createRateLimiter`:** this Web factory's\n * checker takes a raw IP string instead of a Request object. The IP is\n * the ONLY input the bucket needs; passing a Request object would force\n * the caller to populate `request.headers.get('x-forwarded-for')` or\n * similar without giving us any safer extraction. KISS — accept the IP\n * directly, document the per-runtime resolution at the adapter boundary.\n */\nexport function createRateLimiterWeb(\n  config: RateLimitConfig,\n  opts: { store?: RateLimitStore } = {},\n) {\n  const store = opts.store ?? new InMemoryStore()\n  const isInMemory = store instanceof InMemoryStore\n\n  return function checkRateLimitWeb(clientIp: string): RateLimitResult {\n    const key = clientIp.length > 0 ? clientIp : 'unknown'\n    if (isInMemory) {\n      const state = store.incrSync(key, config.windowMs)\n      return resultFromState(state, config)\n    }\n    throw new Error(\n      'createRateLimiterWeb: async RateLimitStore implementations are not supported by this sync façade. ' +\n        'Use the InMemoryStore default or build a custom middleware around the async store directly.',\n    )\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-BE2LKDI7.js → chunk-WEGALZEU.js}

@@ -4,10 +4,10 @@ import {
   compilePattern,
   scanServerRoutes,
   scanWebSocketRoutes
-} from "./chunk-SNDZQ64K.js";
+} from "./chunk-VBZCVFSA.js";
 import {
   scanServerActions
-} from "./chunk-5OFPQK6N.js";
+} from "./chunk-COXLEZCN.js";
 
 // src/server/scan/manifest.ts
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
@@ -72,4 +72,4 @@ export {
   writeManifest,
   loadManifest
 };
-//# sourceMappingURL=chunk-BE2LKDI7.js.map
+//# sourceMappingURL=chunk-WEGALZEU.js.map

package/dist/{chunk-ZOXNJV2O.js → chunk-WGHJD6I7.js}

@@ -6,12 +6,7 @@ import { mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
 
 // src/vite-plugin/openapi-emit/zod-to-openapi.ts
-var ZodToOpenApiError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ZodToOpenApiError";
-  }
-};
+import { z } from "zod";
 function zodToOpenApiSchema(schema, options = {}) {
   const ctx = options.ctx ?? { seen: /* @__PURE__ */ new Map(), components: {} };
   const name = options.name;
@@ -21,150 +16,52 @@ function zodToOpenApiSchema(schema, options = {}) {
     }
     ctx.seen.set(schema, name);
     ctx.components[name] = {};
-    const body = convert(schema, ctx);
+    const body = convertSchema(schema, ctx);
     ctx.components[name] = body;
     return { $ref: `#/components/schemas/${name}` };
   }
-  return convert(schema, ctx);
+  return convertSchema(schema, ctx);
 }
-function convert(schema, ctx) {
+function convertSchema(schema, ctx) {
   const existing = ctx.seen.get(schema);
   if (existing !== void 0) {
     return { $ref: `#/components/schemas/${existing}` };
   }
-  const def = schema._def;
-  const typeName = def.typeName ?? "";
-  switch (typeName) {
-    case "ZodString":
-      return convertString(schema);
-    case "ZodNumber":
-      return convertNumber(schema);
-    case "ZodBoolean":
-      return { type: "boolean" };
-    case "ZodLiteral":
-      return convertLiteral(schema);
-    case "ZodEnum":
-      return convertEnum(schema);
-    case "ZodArray":
-      return convertArray(schema, ctx);
-    case "ZodObject":
-      return convertObject(schema, ctx);
-    case "ZodUnion":
-      return convertUnion(schema, ctx);
-    case "ZodDiscriminatedUnion":
-      return convertDiscriminatedUnion(schema, ctx);
-    case "ZodOptional":
-      return convert(schema._def.innerType, ctx);
-    case "ZodNullable": {
-      const inner = convert(
-        schema._def.innerType,
-        ctx
-      );
-      return { ...inner, nullable: true };
-    }
-    case "ZodEffects":
-    case "ZodTransform":
-      return convert(schema._def.schema, ctx);
-    case "ZodDefault":
-      return convert(schema._def.innerType, ctx);
-    case "ZodLazy": {
-      const getter = schema._def.getter;
-      return convert(getter(), ctx);
-    }
-    case "ZodRecord": {
-      const valueType = schema._def.valueType;
-      return { type: "object", additionalProperties: convert(valueType, ctx) };
-    }
-    case "ZodAny":
-    case "ZodUnknown":
-      return {};
-    // no constraint
-    case "ZodNull":
-      return { type: "null" };
-    case "ZodFunction":
-      throw new ZodToOpenApiError(
-        "Unsupported Zod type: z.function() cannot be represented in OpenAPI Schema. Remove from the route schema."
-      );
-    case "ZodPromise":
-      throw new ZodToOpenApiError(
-        "Unsupported Zod type: z.promise() cannot be represented in OpenAPI Schema. Unwrap the value before passing to defineRoute."
-      );
-    default:
-      throw new ZodToOpenApiError(
-        `Unsupported Zod type: ${typeName || "(unknown)"}. Open an issue if this construct should be supported.`
-      );
-  }
-}
-function convertString(schema) {
-  const def = schema._def;
-  const checks = def.checks ?? [];
-  const out = { type: "string" };
-  for (const c of checks) {
-    if (c.kind === "email") out.format = "email";
-    else if (c.kind === "uuid") out.format = "uuid";
-    else if (c.kind === "url") out.format = "uri";
-    else if (c.kind === "datetime") out.format = "date-time";
-  }
-  return out;
-}
-function convertNumber(schema) {
-  const def = schema._def;
-  const checks = def.checks ?? [];
-  const isInt = checks.some((c) => c.kind === "int");
-  return { type: isInt ? "integer" : "number" };
-}
-function convertLiteral(schema) {
-  const value = schema._def.value;
-  const typed = literalTypeOf(value);
-  if (typed === null) {
-    return { type: "null", enum: [null] };
+  try {
+    const jsonSchema = z.toJSONSchema(schema);
+    return toOpenApi3(jsonSchema);
+  } catch {
+    return {};
   }
-  return { type: typed, enum: [value] };
-}
-function literalTypeOf(value) {
-  if (value === null) return null;
-  if (typeof value === "string") return "string";
-  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
-  if (typeof value === "boolean") return "boolean";
-  return "string";
 }
-function convertEnum(schema) {
-  const values = schema._def.values;
-  return { type: "string", enum: [...values] };
-}
-function convertArray(schema, ctx) {
-  const inner = schema._def.type;
-  return { type: "array", items: convert(inner, ctx) };
-}
-function convertObject(schema, ctx) {
-  const shape = schema.shape;
-  const properties = {};
-  const required = [];
-  for (const [key, child] of Object.entries(shape)) {
-    properties[key] = convert(child, ctx);
-    const childDef = child._def;
-    const isOptional = childDef.typeName === "ZodOptional" || childDef.typeName === "ZodDefault";
-    if (!isOptional) required.push(key);
+function toOpenApi3(js) {
+  const { $schema: _, $defs: _defs, ...rest } = js;
+  const out = {};
+  for (const [key, value] of Object.entries(rest)) {
+    if (key === "type" && Array.isArray(value)) {
+      const types = value;
+      const hasNull = types.includes("null");
+      const nonNull = types.filter((t) => t !== "null");
+      out.type = nonNull.length === 1 ? nonNull[0] : nonNull;
+      if (hasNull) out.nullable = true;
+    } else if (key === "properties" && value && typeof value === "object") {
+      const props = {};
+      for (const [pk, pv] of Object.entries(value)) {
+        props[pk] = pv && typeof pv === "object" ? toOpenApi3(pv) : pv;
+      }
+      out.properties = props;
+    } else if (key === "items" && value && typeof value === "object") {
+      out.items = toOpenApi3(value);
+    } else if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
+      out[key] = value.map((v) => toOpenApi3(v));
+    } else if (key === "additionalProperties" && value && typeof value === "object") {
+      out.additionalProperties = toOpenApi3(value);
+    } else {
+      out[key] = value;
+    }
   }
-  const out = {
-    type: "object",
-    properties,
-    additionalProperties: false
-  };
-  if (required.length > 0) out.required = required;
   return out;
 }
-function convertUnion(schema, ctx) {
-  const options = schema._def.options;
-  return { oneOf: options.map((o) => convert(o, ctx)) };
-}
-function convertDiscriminatedUnion(schema, ctx) {
-  const def = schema._def;
-  return {
-    oneOf: def.options.map((o) => convert(o, ctx)),
-    discriminator: { propertyName: def.discriminator }
-  };
-}
 
 // src/vite-plugin/openapi-emit/emit.ts
 var METHOD_TO_KEY = {
@@ -355,4 +252,4 @@ export {
   emitOpenApi,
   loadRoutesForOpenApi
 };
-//# sourceMappingURL=chunk-ZOXNJV2O.js.map
+//# sourceMappingURL=chunk-WGHJD6I7.js.map