@vivero/stoma 0.1.0-rc.10

package/dist/adapters/testing.js

@@ -0,0 +1,33 @@
+class TestAdapter {
+  promises = [];
+  /**
+   * Add a promise to the background work queue.
+   */
+  waitUntil = (promise) => {
+    this.promises.push(promise);
+  };
+  /**
+   * Await all pending background work collected via `waitUntil`.
+   */
+  async waitAll() {
+    while (this.promises.length > 0) {
+      const batch = [...this.promises];
+      this.promises = [];
+      await Promise.all(batch);
+    }
+  }
+  /**
+   * Reset the collected promises.
+   */
+  reset() {
+    this.promises = [];
+  }
+}
+function createTestAdapter() {
+  return new TestAdapter();
+}
+export {
+  TestAdapter,
+  createTestAdapter
+};
+//# sourceMappingURL=testing.js.map

package/dist/adapters/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/testing.ts"],"sourcesContent":["import type { GatewayAdapter } from \"./types\";\n\n/**\n * A GatewayAdapter implementation for unit testing.\n *\n * Provides a `waitUntil` implementation that collects background promises,\n * allowing tests to `await adapter.waitAll()` before finishing.\n */\nexport class TestAdapter implements GatewayAdapter {\n  private promises: Promise<unknown>[] = [];\n\n  /**\n   * Add a promise to the background work queue.\n   */\n  waitUntil = (promise: Promise<unknown>): void => {\n    this.promises.push(promise);\n  };\n\n  /**\n   * Await all pending background work collected via `waitUntil`.\n   */\n  async waitAll(): Promise<void> {\n    while (this.promises.length > 0) {\n      const batch = [...this.promises];\n      this.promises = [];\n      await Promise.all(batch);\n    }\n  }\n\n  /**\n   * Reset the collected promises.\n   */\n  reset(): void {\n    this.promises = [];\n  }\n}\n\n/**\n * Create a new {@link TestAdapter}.\n */\nexport function createTestAdapter(): TestAdapter {\n  return new TestAdapter();\n}\n"],"mappings":"AAQO,MAAM,YAAsC;AAAA,EACzC,WAA+B,CAAC;AAAA;AAAA;AAAA;AAAA,EAKxC,YAAY,CAAC,YAAoC;AAC/C,SAAK,SAAS,KAAK,OAAO;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,UAAyB;AAC7B,WAAO,KAAK,SAAS,SAAS,GAAG;AAC/B,YAAM,QAAQ,CAAC,GAAG,KAAK,QAAQ;AAC/B,WAAK,WAAW,CAAC;AACjB,YAAM,QAAQ,IAAI,KAAK;AAAA,IACzB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,SAAK,WAAW,CAAC;AAAA,EACnB;AACF;AAKO,SAAS,oBAAiC;AAC/C,SAAO,IAAI,YAAY;AACzB;","names":[]}

package/dist/adapters/types.d.ts

@@ -0,0 +1,4 @@
+export { G as GatewayAdapter } from '../protocol-2fD3DJrL.js';
+import 'hono';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';

package/dist/adapters/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/adapters/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/config/index.d.ts

@@ -0,0 +1,11 @@
+export { ScopeConfig } from '../core/scope.js';
+export { GatewayConfig, PipelineConfig, RouteConfig, UpstreamConfig } from '../core/types.js';
+export { mergeConfigs } from './merge.js';
+export { GatewayConfigSchema, PipelineSchema, PolicySchema, RouteSchema, UpstreamSchema, safeValidateConfig, validateConfig } from './schema.js';
+import '../protocol-2fD3DJrL.js';
+import 'hono';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';
+import '../observability/metrics.js';
+import '../observability/tracing.js';
+import 'zod';

package/dist/config/index.js

@@ -0,0 +1,21 @@
+import { mergeConfigs } from "./merge";
+import {
+  GatewayConfigSchema,
+  PipelineSchema,
+  PolicySchema,
+  RouteSchema,
+  safeValidateConfig,
+  UpstreamSchema,
+  validateConfig
+} from "./schema";
+export {
+  GatewayConfigSchema,
+  PipelineSchema,
+  PolicySchema,
+  RouteSchema,
+  UpstreamSchema,
+  mergeConfigs,
+  safeValidateConfig,
+  validateConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/config/index.ts"],"sourcesContent":["/**\n * Configuration types and optional Zod validation for stoma gateway configs.\n *\n * Import from `@vivero/stoma/config` for gateway configuration types\n * and runtime validation utilities. The Zod schemas are **optional** - they\n * require the `zod` peer dependency. Consumers who only use the TypeScript\n * types never need to install Zod.\n *\n * @example\n * ```ts\n * import type { GatewayConfig } from \"@vivero/stoma/config\";\n * import { validateConfig, safeValidateConfig } from \"@vivero/stoma/config\";\n *\n * // Type-only usage (no zod required)\n * const config: GatewayConfig = { ... };\n *\n * // Runtime validation (requires zod peer dep)\n * const validated = validateConfig(untrustedConfig); // throws on invalid\n * const result = safeValidateConfig(untrustedConfig); // returns { success, data?, error? }\n * ```\n *\n * @module config\n */\n\nexport type {\n  /** Configuration for a route scope: prefix, shared policies, child routes, and metadata. */\n  ScopeConfig,\n} from \"../core/scope\";\nexport type {\n  /** Top-level gateway configuration: routes, global policies, error handling, debug, and adapter. */\n  GatewayConfig,\n  /** Pipeline definition: ordered policy chain leading to an upstream target. */\n  PipelineConfig,\n  /** Individual route definition: path, methods, and pipeline (policies + upstream). */\n  RouteConfig,\n  /** Discriminated union of upstream types: URL proxy, Service Binding, or custom handler. */\n  UpstreamConfig,\n} from \"../core/types\";\n\n/** Merge multiple partial gateway configs into a single complete config. */\nexport { mergeConfigs } from \"./merge\";\n\nexport {\n  /** Zod schema for the full GatewayConfig object. */\n  GatewayConfigSchema,\n  /** Zod schema for a PipelineConfig. */\n  PipelineSchema,\n  /** Zod schema for a single Policy object (name, handler, priority). */\n  PolicySchema,\n  /** Zod schema for a single RouteConfig. */\n  RouteSchema,\n  /** Validate a gateway config returning a Zod SafeParseResult instead of throwing (requires zod). */\n  safeValidateConfig,\n  /** Zod schema for the UpstreamConfig discriminated union. */\n  UpstreamSchema,\n  /** Validate a gateway config object at runtime, throwing on invalid input (requires zod). */\n  validateConfig,\n} from \"./schema\";\n"],"mappings":"AAwCA,SAAS,oBAAoB;AAE7B;AAAA,EAEE;AAAA,EAEA;AAAA,EAEA;AAAA,EAEA;AAAA,EAEA;AAAA,EAEA;AAAA,EAEA;AAAA,OACK;","names":[]}

package/dist/config/merge.d.ts

@@ -0,0 +1,48 @@
+import { GatewayConfig } from '../core/types.js';
+import 'hono';
+import '../protocol-2fD3DJrL.js';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';
+import '../observability/metrics.js';
+import '../observability/tracing.js';
+
+/**
+ * Configuration merging utilities for splitting gateway configs across files.
+ *
+ * {@link mergeConfigs} accepts any number of partial gateway configs and
+ * merges them left-to-right into a single complete {@link GatewayConfig}.
+ * This enables patterns like per-domain route files, shared policy sets,
+ * and environment-specific overrides.
+ *
+ * @example
+ * ```ts
+ * import { mergeConfigs, createGateway } from "@vivero/stoma";
+ *
+ * const base = { name: "my-gw", policies: [cors(), rateLimit({ max: 100 })] };
+ * const authRoutes = { routes: [{ path: "/auth/*", ... }] };
+ * const apiRoutes  = { routes: [{ path: "/api/*", ... }] };
+ *
+ * const gw = createGateway(mergeConfigs(base, authRoutes, apiRoutes));
+ * ```
+ *
+ * @module config/merge
+ */
+
+/**
+ * Merge multiple partial gateway configs into a single complete config.
+ *
+ * Merge semantics by field:
+ * - **routes** - concatenated (all routes from all configs, in order)
+ * - **policies** - deduplicated by `name` (later config wins on conflict)
+ * - **admin**, **debugHeaders** - shallow-merged when both are objects;
+ *   last-defined wins when types differ (boolean vs object)
+ * - All other scalar fields - last-defined wins (undefined values are skipped)
+ *
+ * @typeParam TBindings - Worker bindings type, propagated to routes.
+ * @param configs - Partial configs to merge (left to right, later wins).
+ * @returns A merged GatewayConfig.
+ * @throws {GatewayError} If the merged result has zero routes.
+ */
+declare function mergeConfigs<TBindings = Record<string, unknown>>(...configs: Array<Partial<GatewayConfig<TBindings>>>): GatewayConfig<TBindings>;
+
+export { mergeConfigs };

package/dist/config/merge.js

@@ -0,0 +1,83 @@
+import { GatewayError } from "../core/errors";
+function mergeConfigs(...configs) {
+  const mergedRoutes = [];
+  const policyMap = /* @__PURE__ */ new Map();
+  let name;
+  let basePath;
+  let debug;
+  let requestIdHeader;
+  let defaultErrorMessage;
+  let defaultPolicyPriority;
+  let defaultMethods;
+  let onError;
+  let adapter;
+  let admin;
+  let debugHeaders;
+  for (const cfg of configs) {
+    if (cfg.routes) {
+      mergedRoutes.push(...cfg.routes);
+    }
+    if (cfg.policies) {
+      for (const policy of cfg.policies) {
+        policyMap.set(policy.name, policy);
+      }
+    }
+    if (cfg.name !== void 0) name = cfg.name;
+    if (cfg.basePath !== void 0) basePath = cfg.basePath;
+    if (cfg.debug !== void 0) debug = cfg.debug;
+    if (cfg.requestIdHeader !== void 0)
+      requestIdHeader = cfg.requestIdHeader;
+    if (cfg.defaultErrorMessage !== void 0)
+      defaultErrorMessage = cfg.defaultErrorMessage;
+    if (cfg.defaultPolicyPriority !== void 0)
+      defaultPolicyPriority = cfg.defaultPolicyPriority;
+    if (cfg.defaultMethods !== void 0) defaultMethods = cfg.defaultMethods;
+    if (cfg.onError !== void 0) onError = cfg.onError;
+    if (cfg.adapter !== void 0) adapter = cfg.adapter;
+    if (cfg.admin !== void 0) {
+      admin = shallowMergeUnion(admin, cfg.admin);
+    }
+    if (cfg.debugHeaders !== void 0) {
+      debugHeaders = shallowMergeUnion(
+        debugHeaders,
+        cfg.debugHeaders
+      );
+    }
+  }
+  if (mergedRoutes.length === 0) {
+    throw new GatewayError(
+      500,
+      "config_error",
+      "mergeConfigs: merged config has zero routes"
+    );
+  }
+  const result = {
+    routes: mergedRoutes
+  };
+  const mergedPolicies = Array.from(policyMap.values());
+  if (mergedPolicies.length > 0) result.policies = mergedPolicies;
+  if (name !== void 0) result.name = name;
+  if (basePath !== void 0) result.basePath = basePath;
+  if (debug !== void 0) result.debug = debug;
+  if (requestIdHeader !== void 0) result.requestIdHeader = requestIdHeader;
+  if (defaultErrorMessage !== void 0)
+    result.defaultErrorMessage = defaultErrorMessage;
+  if (defaultPolicyPriority !== void 0)
+    result.defaultPolicyPriority = defaultPolicyPriority;
+  if (defaultMethods !== void 0) result.defaultMethods = defaultMethods;
+  if (onError !== void 0) result.onError = onError;
+  if (adapter !== void 0) result.adapter = adapter;
+  if (admin !== void 0) result.admin = admin;
+  if (debugHeaders !== void 0) result.debugHeaders = debugHeaders;
+  return result;
+}
+function shallowMergeUnion(existing, incoming) {
+  if (existing !== void 0 && typeof existing === "object" && typeof incoming === "object") {
+    return { ...existing, ...incoming };
+  }
+  return incoming;
+}
+export {
+  mergeConfigs
+};
+//# sourceMappingURL=merge.js.map

package/dist/config/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/config/merge.ts"],"sourcesContent":["/**\n * Configuration merging utilities for splitting gateway configs across files.\n *\n * {@link mergeConfigs} accepts any number of partial gateway configs and\n * merges them left-to-right into a single complete {@link GatewayConfig}.\n * This enables patterns like per-domain route files, shared policy sets,\n * and environment-specific overrides.\n *\n * @example\n * ```ts\n * import { mergeConfigs, createGateway } from \"@vivero/stoma\";\n *\n * const base = { name: \"my-gw\", policies: [cors(), rateLimit({ max: 100 })] };\n * const authRoutes = { routes: [{ path: \"/auth/*\", ... }] };\n * const apiRoutes  = { routes: [{ path: \"/api/*\", ... }] };\n *\n * const gw = createGateway(mergeConfigs(base, authRoutes, apiRoutes));\n * ```\n *\n * @module config/merge\n */\n\nimport { GatewayError } from \"../core/errors\";\nimport type {\n  AdminConfig,\n  DebugHeadersConfig,\n  GatewayConfig,\n} from \"../core/types\";\nimport type { Policy } from \"../policies/types\";\n\n/**\n * Merge multiple partial gateway configs into a single complete config.\n *\n * Merge semantics by field:\n * - **routes** - concatenated (all routes from all configs, in order)\n * - **policies** - deduplicated by `name` (later config wins on conflict)\n * - **admin**, **debugHeaders** - shallow-merged when both are objects;\n *   last-defined wins when types differ (boolean vs object)\n * - All other scalar fields - last-defined wins (undefined values are skipped)\n *\n * @typeParam TBindings - Worker bindings type, propagated to routes.\n * @param configs - Partial configs to merge (left to right, later wins).\n * @returns A merged GatewayConfig.\n * @throws {GatewayError} If the merged result has zero routes.\n */\nexport function mergeConfigs<TBindings = Record<string, unknown>>(\n  ...configs: Array<Partial<GatewayConfig<TBindings>>>\n): GatewayConfig<TBindings> {\n  const mergedRoutes: GatewayConfig<TBindings>[\"routes\"] = [];\n  const policyMap = new Map<string, Policy>();\n\n  // Scalar fields - last-defined wins\n  let name: GatewayConfig<TBindings>[\"name\"];\n  let basePath: GatewayConfig<TBindings>[\"basePath\"];\n  let debug: GatewayConfig<TBindings>[\"debug\"];\n  let requestIdHeader: GatewayConfig<TBindings>[\"requestIdHeader\"];\n  let defaultErrorMessage: GatewayConfig<TBindings>[\"defaultErrorMessage\"];\n  let defaultPolicyPriority: GatewayConfig<TBindings>[\"defaultPolicyPriority\"];\n  let defaultMethods: GatewayConfig<TBindings>[\"defaultMethods\"];\n  let onError: GatewayConfig<TBindings>[\"onError\"];\n  let adapter: GatewayConfig<TBindings>[\"adapter\"];\n\n  // Object/boolean union fields - shallow-merge when both objects\n  let admin: GatewayConfig<TBindings>[\"admin\"];\n  let debugHeaders: GatewayConfig<TBindings>[\"debugHeaders\"];\n\n  for (const cfg of configs) {\n    // Routes: concatenate\n    if (cfg.routes) {\n      mergedRoutes.push(...cfg.routes);\n    }\n\n    // Policies: deduplicate by name (later wins)\n    if (cfg.policies) {\n      for (const policy of cfg.policies) {\n        policyMap.set(policy.name, policy);\n      }\n    }\n\n    // Scalar fields: last-defined wins (skip undefined)\n    if (cfg.name !== undefined) name = cfg.name;\n    if (cfg.basePath !== undefined) basePath = cfg.basePath;\n    if (cfg.debug !== undefined) debug = cfg.debug;\n    if (cfg.requestIdHeader !== undefined)\n      requestIdHeader = cfg.requestIdHeader;\n    if (cfg.defaultErrorMessage !== undefined)\n      defaultErrorMessage = cfg.defaultErrorMessage;\n    if (cfg.defaultPolicyPriority !== undefined)\n      defaultPolicyPriority = cfg.defaultPolicyPriority;\n    if (cfg.defaultMethods !== undefined) defaultMethods = cfg.defaultMethods;\n    if (cfg.onError !== undefined) onError = cfg.onError;\n    if (cfg.adapter !== undefined) adapter = cfg.adapter;\n\n    // Admin: shallow-merge objects, last-defined wins for boolean/object mismatch\n    if (cfg.admin !== undefined) {\n      admin = shallowMergeUnion<AdminConfig>(admin, cfg.admin);\n    }\n\n    // DebugHeaders: same strategy as admin\n    if (cfg.debugHeaders !== undefined) {\n      debugHeaders = shallowMergeUnion<DebugHeadersConfig>(\n        debugHeaders,\n        cfg.debugHeaders\n      );\n    }\n  }\n\n  if (mergedRoutes.length === 0) {\n    throw new GatewayError(\n      500,\n      \"config_error\",\n      \"mergeConfigs: merged config has zero routes\"\n    );\n  }\n\n  const result: GatewayConfig<TBindings> = {\n    routes: mergedRoutes,\n  };\n\n  // Only set fields that were defined\n  const mergedPolicies = Array.from(policyMap.values());\n  if (mergedPolicies.length > 0) result.policies = mergedPolicies;\n  if (name !== undefined) result.name = name;\n  if (basePath !== undefined) result.basePath = basePath;\n  if (debug !== undefined) result.debug = debug;\n  if (requestIdHeader !== undefined) result.requestIdHeader = requestIdHeader;\n  if (defaultErrorMessage !== undefined)\n    result.defaultErrorMessage = defaultErrorMessage;\n  if (defaultPolicyPriority !== undefined)\n    result.defaultPolicyPriority = defaultPolicyPriority;\n  if (defaultMethods !== undefined) result.defaultMethods = defaultMethods;\n  if (onError !== undefined) result.onError = onError;\n  if (adapter !== undefined) result.adapter = adapter;\n  if (admin !== undefined) result.admin = admin;\n  if (debugHeaders !== undefined) result.debugHeaders = debugHeaders;\n\n  return result;\n}\n\n/**\n * Shallow-merge two values that may be boolean or object.\n *\n * - Both objects → shallow-merge (later wins on key conflicts)\n * - Either is boolean or types differ → last value wins entirely\n */\nfunction shallowMergeUnion<T extends object>(\n  existing: boolean | T | undefined,\n  incoming: boolean | T\n): boolean | T {\n  if (\n    existing !== undefined &&\n    typeof existing === \"object\" &&\n    typeof incoming === \"object\"\n  ) {\n    return { ...existing, ...incoming };\n  }\n  return incoming;\n}\n"],"mappings":"AAsBA,SAAS,oBAAoB;AAuBtB,SAAS,gBACX,SACuB;AAC1B,QAAM,eAAmD,CAAC;AAC1D,QAAM,YAAY,oBAAI,IAAoB;AAG1C,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AAGJ,MAAI;AACJ,MAAI;AAEJ,aAAW,OAAO,SAAS;AAEzB,QAAI,IAAI,QAAQ;AACd,mBAAa,KAAK,GAAG,IAAI,MAAM;AAAA,IACjC;AAGA,QAAI,IAAI,UAAU;AAChB,iBAAW,UAAU,IAAI,UAAU;AACjC,kBAAU,IAAI,OAAO,MAAM,MAAM;AAAA,MACnC;AAAA,IACF;AAGA,QAAI,IAAI,SAAS,OAAW,QAAO,IAAI;AACvC,QAAI,IAAI,aAAa,OAAW,YAAW,IAAI;AAC/C,QAAI,IAAI,UAAU,OAAW,SAAQ,IAAI;AACzC,QAAI,IAAI,oBAAoB;AAC1B,wBAAkB,IAAI;AACxB,QAAI,IAAI,wBAAwB;AAC9B,4BAAsB,IAAI;AAC5B,QAAI,IAAI,0BAA0B;AAChC,8BAAwB,IAAI;AAC9B,QAAI,IAAI,mBAAmB,OAAW,kBAAiB,IAAI;AAC3D,QAAI,IAAI,YAAY,OAAW,WAAU,IAAI;AAC7C,QAAI,IAAI,YAAY,OAAW,WAAU,IAAI;AAG7C,QAAI,IAAI,UAAU,QAAW;AAC3B,cAAQ,kBAA+B,OAAO,IAAI,KAAK;AAAA,IACzD;AAGA,QAAI,IAAI,iBAAiB,QAAW;AAClC,qBAAe;AAAA,QACb;AAAA,QACA,IAAI;AAAA,MACN;AAAA,IACF;AAAA,EACF;AAEA,MAAI,aAAa,WAAW,GAAG;AAC7B,UAAM,IAAI;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAEA,QAAM,SAAmC;AAAA,IACvC,QAAQ;AAAA,EACV;AAGA,QAAM,iBAAiB,MAAM,KAAK,UAAU,OAAO,CAAC;AACpD,MAAI,eAAe,SAAS,EAAG,QAAO,WAAW;AACjD,MAAI,SAAS,OAAW,QAAO,OAAO;AACtC,MAAI,aAAa,OAAW,QAAO,WAAW;AAC9C,MAAI,UAAU,OAAW,QAAO,QAAQ;AACxC,MAAI,oBAAoB,OAAW,QAAO,kBAAkB;AAC5D,MAAI,wBAAwB;AAC1B,WAAO,sBAAsB;AAC/B,MAAI,0BAA0B;AAC5B,WAAO,wBAAwB;AACjC,MAAI,mBAAmB,OAAW,QAAO,iBAAiB;AAC1D,MAAI,YAAY,OAAW,QAAO,UAAU;AAC5C,MAAI,YAAY,OAAW,QAAO,UAAU;AAC5C,MAAI,UAAU,OAAW,QAAO,QAAQ;AACxC,MAAI,iBAAiB,OAAW,QAAO,eAAe;AAEtD,SAAO;AACT;AAQA,SAAS,kBACP,UACA,UACa;AACb,MACE,aAAa,UACb,OAAO,aAAa,YACpB,OAAO,aAAa,UACpB;AACA,WAAO,EAAE,GAAG,UAAU,GAAG,SAAS;AAAA,EACpC;AACA,SAAO;AACT;","names":[]}

package/dist/config/schema.d.ts

@@ -0,0 +1,254 @@
+import { z } from 'zod';
+import { GatewayConfig } from '../core/types.js';
+import 'hono';
+import '../protocol-2fD3DJrL.js';
+import '../policies/sdk/trace.js';
+import '@vivero/stoma-core';
+import '../observability/metrics.js';
+import '../observability/tracing.js';
+
+/**
+ * Zod schemas for gateway configuration validation.
+ *
+ * These schemas mirror the TypeScript types in `core/types.ts` and can be used
+ * to validate untrusted configuration objects at runtime (e.g. config loaded
+ * from KV, environment variables, or external sources).
+ *
+ * **Scope**: Validates the structural shape of `GatewayConfig` (routes, upstream
+ * types, methods, admin config). Individual policy configs are **not** validated -
+ * each policy validates its own config internally via `resolveConfig()`. This
+ * means `validateConfig()` catches structural misconfigurations (missing routes,
+ * invalid upstream type) but won't catch typos in policy-specific options.
+ *
+ * Zod is an **optional** peer dependency. Consumers who only use the static
+ * TypeScript types never pay for it.
+ *
+ * @module config/schema
+ */
+
+/**
+ * Validates the Policy shape (name + handler + priority).
+ *
+ * This only checks that a policy _looks_ like a Policy - it does not validate
+ * the policy's own config options. Policy-specific validation happens inside
+ * each policy factory via `resolveConfig()` at construction time.
+ */
+declare const PolicySchema: z.ZodObject<{
+    name: z.ZodString;
+    handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    priority: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const UpstreamSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"url">;
+    target: z.ZodString;
+    rewritePath: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"service-binding">;
+    service: z.ZodString;
+    rewritePath: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"handler">;
+    handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+}, z.core.$strip>], "type">;
+declare const PipelineSchema: z.ZodObject<{
+    policies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    upstream: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"url">;
+        target: z.ZodString;
+        rewritePath: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"service-binding">;
+        service: z.ZodString;
+        rewritePath: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"handler">;
+        handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+declare const HttpMethodSchema: z.ZodEnum<{
+    POST: "POST";
+    GET: "GET";
+    PUT: "PUT";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+    HEAD: "HEAD";
+    OPTIONS: "OPTIONS";
+}>;
+declare const RouteSchema: z.ZodObject<{
+    path: z.ZodString;
+    methods: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        POST: "POST";
+        GET: "GET";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+    }>>>;
+    pipeline: z.ZodObject<{
+        policies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+            priority: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        upstream: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"url">;
+            target: z.ZodString;
+            rewritePath: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"service-binding">;
+            service: z.ZodString;
+            rewritePath: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"handler">;
+            handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        }, z.core.$strip>], "type">;
+    }, z.core.$strip>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const TracingConfigSchema: z.ZodOptional<z.ZodObject<{
+    exporter: z.ZodAny;
+    serviceName: z.ZodOptional<z.ZodString>;
+    serviceVersion: z.ZodOptional<z.ZodString>;
+    sampleRate: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>>;
+declare const ScopeConfigSchema: z.ZodObject<{
+    prefix: z.ZodString;
+    policies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    routes: z.ZodArray<z.ZodLazy<z.ZodObject<{
+        path: z.ZodString;
+        methods: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            POST: "POST";
+            GET: "GET";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+            HEAD: "HEAD";
+            OPTIONS: "OPTIONS";
+        }>>>;
+        pipeline: z.ZodObject<{
+            policies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+                priority: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            upstream: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"url">;
+                target: z.ZodString;
+                rewritePath: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"service-binding">;
+                service: z.ZodString;
+                rewritePath: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"handler">;
+                handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const GatewayConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    basePath: z.ZodOptional<z.ZodString>;
+    routes: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        methods: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            POST: "POST";
+            GET: "GET";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+            HEAD: "HEAD";
+            OPTIONS: "OPTIONS";
+        }>>>;
+        pipeline: z.ZodObject<{
+            policies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+                priority: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            upstream: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"url">;
+                target: z.ZodString;
+                rewritePath: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"service-binding">;
+                service: z.ZodString;
+                rewritePath: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"handler">;
+                handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    policies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        handler: z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    onError: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+    debug: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    requestIdHeader: z.ZodOptional<z.ZodString>;
+    defaultMethods: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        POST: "POST";
+        GET: "GET";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+    }>>>;
+    defaultErrorMessage: z.ZodOptional<z.ZodString>;
+    defaultPolicyPriority: z.ZodOptional<z.ZodNumber>;
+    admin: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        enabled: z.ZodBoolean;
+        prefix: z.ZodOptional<z.ZodString>;
+        auth: z.ZodOptional<z.ZodFunction<z.core.$ZodFunctionArgs, z.core.$ZodFunctionOut>>;
+        metrics: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>]>>;
+    debugHeaders: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        requestHeader: z.ZodOptional<z.ZodString>;
+        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>]>>;
+    tracing: z.ZodOptional<z.ZodObject<{
+        exporter: z.ZodAny;
+        serviceName: z.ZodOptional<z.ZodString>;
+        serviceVersion: z.ZodOptional<z.ZodString>;
+        sampleRate: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * Validate a gateway config object, throwing on failure.
+ *
+ * @throws {z.ZodError} with readable error messages
+ */
+declare function validateConfig(config: unknown): GatewayConfig;
+/**
+ * Safely validate a gateway config, returning success/error without throwing.
+ */
+declare function safeValidateConfig(config: unknown): {
+    success: true;
+    data: GatewayConfig;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+
+export { GatewayConfigSchema, HttpMethodSchema, PipelineSchema, PolicySchema, RouteSchema, ScopeConfigSchema, TracingConfigSchema, UpstreamSchema, safeValidateConfig, validateConfig };

package/dist/config/schema.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+const PolicySchema = z.object({
+  name: z.string().min(1, "Policy name is required"),
+  handler: z.function(),
+  priority: z.number().int().optional()
+});
+const UrlUpstreamSchema = z.object({
+  type: z.literal("url"),
+  target: z.string().url("Upstream target must be a valid URL"),
+  rewritePath: z.function().optional(),
+  headers: z.record(z.string(), z.string()).optional()
+});
+const ServiceBindingUpstreamSchema = z.object({
+  type: z.literal("service-binding"),
+  service: z.string().min(1, "Service binding name is required"),
+  rewritePath: z.function().optional()
+});
+const HandlerUpstreamSchema = z.object({
+  type: z.literal("handler"),
+  handler: z.function()
+});
+const UpstreamSchema = z.discriminatedUnion("type", [
+  UrlUpstreamSchema,
+  ServiceBindingUpstreamSchema,
+  HandlerUpstreamSchema
+]);
+const PipelineSchema = z.object({
+  policies: z.array(PolicySchema).optional(),
+  upstream: UpstreamSchema
+});
+const HttpMethodSchema = z.enum([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+]);
+const RouteSchema = z.object({
+  path: z.string().startsWith("/", "Route path must start with /"),
+  methods: z.array(HttpMethodSchema).optional(),
+  pipeline: PipelineSchema,
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+const TracingConfigSchema = z.object({
+  exporter: z.any(),
+  serviceName: z.string().optional(),
+  serviceVersion: z.string().optional(),
+  sampleRate: z.number().min(0).max(1).optional()
+}).optional();
+const ScopeConfigSchema = z.object({
+  prefix: z.string().min(1, "Scope prefix is required"),
+  policies: z.array(PolicySchema).optional(),
+  routes: z.array(z.lazy(() => RouteSchema)).min(1, "Scope requires at least one route"),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+const GatewayConfigSchema = z.object({
+  name: z.string().optional(),
+  basePath: z.string().optional(),
+  routes: z.array(RouteSchema).min(1, "At least one route is required"),
+  policies: z.array(PolicySchema).optional(),
+  onError: z.function().optional(),
+  debug: z.union([z.boolean(), z.string()]).optional(),
+  requestIdHeader: z.string().optional(),
+  defaultMethods: z.array(HttpMethodSchema).optional(),
+  defaultErrorMessage: z.string().optional(),
+  defaultPolicyPriority: z.number().int().optional(),
+  admin: z.union([
+    z.boolean(),
+    z.object({
+      enabled: z.boolean(),
+      prefix: z.string().optional(),
+      auth: z.function().optional(),
+      metrics: z.any().optional()
+    })
+  ]).optional(),
+  debugHeaders: z.union([
+    z.boolean(),
+    z.object({
+      requestHeader: z.string().optional(),
+      allow: z.array(z.string()).optional()
+    })
+  ]).optional(),
+  tracing: TracingConfigSchema
+});
+function validateConfig(config) {
+  return GatewayConfigSchema.parse(config);
+}
+function safeValidateConfig(config) {
+  const result = GatewayConfigSchema.safeParse(config);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+export {
+  GatewayConfigSchema,
+  HttpMethodSchema,
+  PipelineSchema,
+  PolicySchema,
+  RouteSchema,
+  ScopeConfigSchema,
+  TracingConfigSchema,
+  UpstreamSchema,
+  safeValidateConfig,
+  validateConfig
+};
+//# sourceMappingURL=schema.js.map

package/dist/config/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/config/schema.ts"],"sourcesContent":["/**\n * Zod schemas for gateway configuration validation.\n *\n * These schemas mirror the TypeScript types in `core/types.ts` and can be used\n * to validate untrusted configuration objects at runtime (e.g. config loaded\n * from KV, environment variables, or external sources).\n *\n * **Scope**: Validates the structural shape of `GatewayConfig` (routes, upstream\n * types, methods, admin config). Individual policy configs are **not** validated -\n * each policy validates its own config internally via `resolveConfig()`. This\n * means `validateConfig()` catches structural misconfigurations (missing routes,\n * invalid upstream type) but won't catch typos in policy-specific options.\n *\n * Zod is an **optional** peer dependency. Consumers who only use the static\n * TypeScript types never pay for it.\n *\n * @module config/schema\n */\nimport { z } from \"zod\";\nimport type { GatewayConfig } from \"../core/types\";\n\n// ---------------------------------------------------------------------------\n// Building blocks\n// ---------------------------------------------------------------------------\n\n/**\n * Validates the Policy shape (name + handler + priority).\n *\n * This only checks that a policy _looks_ like a Policy - it does not validate\n * the policy's own config options. Policy-specific validation happens inside\n * each policy factory via `resolveConfig()` at construction time.\n */\nconst PolicySchema = z.object({\n  name: z.string().min(1, \"Policy name is required\"),\n  handler: z.function(),\n  priority: z.number().int().optional(),\n});\n\nconst UrlUpstreamSchema = z.object({\n  type: z.literal(\"url\"),\n  target: z.string().url(\"Upstream target must be a valid URL\"),\n  rewritePath: z.function().optional(),\n  headers: z.record(z.string(), z.string()).optional(),\n});\n\nconst ServiceBindingUpstreamSchema = z.object({\n  type: z.literal(\"service-binding\"),\n  service: z.string().min(1, \"Service binding name is required\"),\n  rewritePath: z.function().optional(),\n});\n\nconst HandlerUpstreamSchema = z.object({\n  type: z.literal(\"handler\"),\n  handler: z.function(),\n});\n\nconst UpstreamSchema = z.discriminatedUnion(\"type\", [\n  UrlUpstreamSchema,\n  ServiceBindingUpstreamSchema,\n  HandlerUpstreamSchema,\n]);\n\nconst PipelineSchema = z.object({\n  policies: z.array(PolicySchema).optional(),\n  upstream: UpstreamSchema,\n});\n\nconst HttpMethodSchema = z.enum([\n  \"GET\",\n  \"POST\",\n  \"PUT\",\n  \"PATCH\",\n  \"DELETE\",\n  \"HEAD\",\n  \"OPTIONS\",\n]);\n\nconst RouteSchema = z.object({\n  path: z.string().startsWith(\"/\", \"Route path must start with /\"),\n  methods: z.array(HttpMethodSchema).optional(),\n  pipeline: PipelineSchema,\n  metadata: z.record(z.string(), z.unknown()).optional(),\n});\n\nconst TracingConfigSchema = z\n  .object({\n    exporter: z.any(),\n    serviceName: z.string().optional(),\n    serviceVersion: z.string().optional(),\n    sampleRate: z.number().min(0).max(1).optional(),\n  })\n  .optional();\n\nconst ScopeConfigSchema = z.object({\n  prefix: z.string().min(1, \"Scope prefix is required\"),\n  policies: z.array(PolicySchema).optional(),\n  routes: z\n    .array(z.lazy(() => RouteSchema))\n    .min(1, \"Scope requires at least one route\"),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n});\n\nconst GatewayConfigSchema = z.object({\n  name: z.string().optional(),\n  basePath: z.string().optional(),\n  routes: z.array(RouteSchema).min(1, \"At least one route is required\"),\n  policies: z.array(PolicySchema).optional(),\n  onError: z.function().optional(),\n  debug: z.union([z.boolean(), z.string()]).optional(),\n  requestIdHeader: z.string().optional(),\n  defaultMethods: z.array(HttpMethodSchema).optional(),\n  defaultErrorMessage: z.string().optional(),\n  defaultPolicyPriority: z.number().int().optional(),\n  admin: z\n    .union([\n      z.boolean(),\n      z.object({\n        enabled: z.boolean(),\n        prefix: z.string().optional(),\n        auth: z.function().optional(),\n        metrics: z.any().optional(),\n      }),\n    ])\n    .optional(),\n  debugHeaders: z\n    .union([\n      z.boolean(),\n      z.object({\n        requestHeader: z.string().optional(),\n        allow: z.array(z.string()).optional(),\n      }),\n    ])\n    .optional(),\n  tracing: TracingConfigSchema,\n});\n\n// ---------------------------------------------------------------------------\n// Exports - schemas\n// ---------------------------------------------------------------------------\n\nexport {\n  GatewayConfigSchema,\n  RouteSchema,\n  PipelineSchema,\n  UpstreamSchema,\n  PolicySchema,\n  HttpMethodSchema,\n  TracingConfigSchema,\n  ScopeConfigSchema,\n};\n\n// ---------------------------------------------------------------------------\n// Validation helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Validate a gateway config object, throwing on failure.\n *\n * @throws {z.ZodError} with readable error messages\n */\nexport function validateConfig(config: unknown): GatewayConfig {\n  return GatewayConfigSchema.parse(config) as GatewayConfig;\n}\n\n/**\n * Safely validate a gateway config, returning success/error without throwing.\n */\nexport function safeValidateConfig(\n  config: unknown\n):\n  | { success: true; data: GatewayConfig }\n  | { success: false; error: z.ZodError } {\n  const result = GatewayConfigSchema.safeParse(config);\n  if (result.success) {\n    return { success: true, data: result.data as GatewayConfig };\n  }\n  return { success: false, error: result.error };\n}\n"],"mappings":"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","names":[]}