@katajs/core 0.1.0

package/dist/index.js

@@ -0,0 +1,838 @@
+// src/module.ts
+function defineModule(spec) {
+  if (spec.routes && spec.prefix) {
+    return {
+      name: spec.name,
+      provides: spec.provides,
+      requires: spec.requires,
+      routes: spec.routes,
+      prefix: spec.prefix,
+      consumer: spec.consumer
+    };
+  }
+  return {
+    name: spec.name,
+    provides: spec.provides,
+    requires: spec.requires,
+    consumer: spec.consumer
+  };
+}
+
+// src/app.ts
+import { Hono } from "hono";
+
+// src/container.ts
+function makeResolver(registry, containerView) {
+  const cache = /* @__PURE__ */ new Map();
+  const inProgress = /* @__PURE__ */ new Set();
+  return function resolve(key) {
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    if (inProgress.has(key)) {
+      const stack = [...inProgress, key].join(" -> ");
+      throw new Error(
+        `[katajs] Circular dependency detected while resolving '${key}'. Resolution stack: ${stack}`
+      );
+    }
+    const factory = registry.get(key);
+    if (!factory) {
+      const known = [...registry.keys()].sort().join(", ") || "(none)";
+      throw new Error(
+        `[katajs] No service registered for key '${key}'. Registered keys: ${known}`
+      );
+    }
+    inProgress.add(key);
+    try {
+      const instance = factory(containerView);
+      cache.set(key, instance);
+      return instance;
+    } finally {
+      inProgress.delete(key);
+    }
+  };
+}
+function buildRegistry(providesMaps) {
+  const registry = /* @__PURE__ */ new Map();
+  for (const provides of providesMaps) {
+    for (const [key, factory] of Object.entries(provides)) {
+      registry.set(key, factory);
+    }
+  }
+  return registry;
+}
+var queueContextStub = new Proxy({}, {
+  get(_, prop) {
+    throw new Error(
+      `[katajs] This service tried to access Hono Context property '${String(prop)}', but it's running in a queue handler (no HTTP context exists). Refactor the service to read what it needs from \`container.env\` / \`container.requestId\` instead.`
+    );
+  }
+});
+function buildContainer(args) {
+  const container = {
+    env: args.env,
+    c: args.c ?? queueContextStub,
+    requestId: args.requestId,
+    db: args.db
+  };
+  container.resolve = makeResolver(
+    args.registry,
+    container
+  );
+  container.withTransaction = async (fn) => {
+    if (args.inTransaction) {
+      return fn(container);
+    }
+    if (!args.runTransaction) {
+      throw new Error(
+        "[katajs] withTransaction was called but the configured db adapter does not support transactions. Use an adapter with a 'runTransaction' method."
+      );
+    }
+    return args.runTransaction(args.db, async (txDb) => {
+      const txContainer = buildContainer({
+        ...args,
+        db: txDb,
+        inTransaction: true
+      });
+      return fn(txContainer);
+    });
+  };
+  return container;
+}
+
+// src/errors.ts
+var AppError = class extends Error {
+  /**
+   * Optional structured payload merged into the response body. Subclasses may
+   * override as either a property or a getter.
+   */
+  get publicPayload() {
+    return void 0;
+  }
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+};
+var ValidationError = class extends AppError {
+  constructor(issues) {
+    super(`Validation failed: ${issues.length} issue(s)`);
+    this.issues = issues;
+  }
+  issues;
+  status = 400;
+  code = "validation_failed";
+  publicMessage = "Request validation failed";
+  get publicPayload() {
+    return { issues: this.issues };
+  }
+};
+function errorMapper(opts = {}) {
+  return (err, c) => {
+    const requestId = c.get("requestId") ?? c.req.header("X-Request-Id") ?? "unknown";
+    if (err instanceof AppError) {
+      return c.json(
+        {
+          error: err.code,
+          message: err.publicMessage,
+          ...err.publicPayload ?? {},
+          requestId
+        },
+        err.status
+      );
+    }
+    opts.onUnhandled?.(err, { c, requestId });
+    return c.json(
+      {
+        error: "internal_error",
+        message: "Something went wrong. Please try again.",
+        requestId
+      },
+      500
+    );
+  };
+}
+
+// src/queues-producer.ts
+function buildTypedQueues(declarations, env) {
+  const out = {};
+  for (const [name, decl] of Object.entries(declarations)) {
+    out[name] = makeTypedQueue(name, decl, env);
+  }
+  return out;
+}
+function makeTypedQueue(name, decl, env) {
+  const binding = env?.[decl.binding];
+  return {
+    async send(body, options) {
+      const validated = validateOrThrow(name, decl, body);
+      assertBinding(name, decl.binding, binding);
+      await binding.send(validated, options);
+    },
+    async sendBatch(bodies, options) {
+      const validated = bodies.map((b) => validateOrThrow(name, decl, b));
+      assertBinding(name, decl.binding, binding);
+      if (typeof binding.sendBatch === "function") {
+        const messages = validated.map((body) => ({ body }));
+        await binding.sendBatch(messages, options);
+        return;
+      }
+      for (const body of validated) {
+        await binding.send(body, options);
+      }
+    }
+  };
+}
+function validateOrThrow(queueName, decl, body) {
+  try {
+    return decl.schema.parse(body);
+  } catch (err) {
+    const issues = err && typeof err === "object" && "issues" in err && Array.isArray(err.issues) ? err.issues.map((i) => ({
+      path: [
+        `queues.${queueName}`,
+        ...Array.isArray(i.path) ? i.path : []
+      ],
+      message: typeof i.message === "string" ? i.message : "Invalid"
+    })) : [
+      {
+        path: [`queues.${queueName}`],
+        message: err instanceof Error ? err.message : String(err)
+      }
+    ];
+    throw new ValidationError(issues);
+  }
+}
+function assertBinding(queueName, bindingName, binding) {
+  if (!binding || typeof binding.send !== "function") {
+    throw new Error(
+      `[katajs] Queue '${queueName}': binding '${bindingName}' is not registered as a producer in wrangler.jsonc, or env doesn't have it. Add a producer entry for this binding in your wrangler config.`
+    );
+  }
+}
+
+// src/middleware.ts
+function containerMiddleware(config) {
+  return async (c, next) => {
+    const requestId = config.generateRequestId ? config.generateRequestId() : crypto.randomUUID();
+    const db = config.db.create(c.env);
+    const container = buildContainer({
+      env: c.env,
+      c,
+      requestId,
+      db,
+      registry: config.registry,
+      runTransaction: config.db.runTransaction,
+      inTransaction: false
+    });
+    c.set("container", container);
+    c.set("requestId", requestId);
+    c.set("resolve", container.resolve);
+    c.set("withTransaction", container.withTransaction);
+    if (config.queues && Object.keys(config.queues).length > 0) {
+      c.set(
+        "queues",
+        buildTypedQueues(config.queues, c.env)
+      );
+    } else {
+      c.set("queues", {});
+    }
+    c.header("X-Request-Id", requestId);
+    await next();
+  };
+}
+function defineMiddleware(handler) {
+  return handler;
+}
+
+// src/queue.ts
+function defineConsumer(spec) {
+  return spec;
+}
+var DEFAULT_MAX_RETRIES = 3;
+function buildQueueHandler(config) {
+  const consumersByQueue = /* @__PURE__ */ new Map();
+  for (const m of config.modules) {
+    if (!m.consumer) continue;
+    if (consumersByQueue.has(m.consumer.queue)) {
+      const owner = consumersByQueue.get(m.consumer.queue).module.name;
+      throw new Error(
+        `[katajs] Duplicate queue consumer for binding '${m.consumer.queue}': modules '${owner}' and '${m.name}' both consume it.`
+      );
+    }
+    consumersByQueue.set(m.consumer.queue, { module: m, consumer: m.consumer });
+  }
+  if (consumersByQueue.size === 0) return void 0;
+  return async function queue(batch, env) {
+    const entry = consumersByQueue.get(batch.queue);
+    if (!entry) {
+      const known = [...consumersByQueue.keys()].join(", ") || "(none)";
+      throw new Error(
+        `[katajs] No consumer registered for queue '${batch.queue}'. Known consumer bindings: ${known}.`
+      );
+    }
+    const { consumer } = entry;
+    const db = config.db.create(env);
+    const sharedContainerArgs = {
+      env,
+      registry: config.registry,
+      db,
+      runTransaction: config.db.runTransaction,
+      inTransaction: false
+    };
+    if ("handleBatch" in consumer && consumer.handleBatch) {
+      const requestId = config.generateRequestId?.() ?? cryptoRandomUUID();
+      const validated = [];
+      for (const msg of batch.messages) {
+        try {
+          const body = consumer.schema.parse(msg.body);
+          validated.push(makeValidatedMessage(msg, body));
+        } catch (err) {
+          await onMessageFailure(msg, consumer, env, err, config.errorMapper, batch.queue);
+        }
+      }
+      if (validated.length === 0) return;
+      const container = buildContainer({
+        ...sharedContainerArgs,
+        requestId
+      });
+      const validatedBatch = {
+        queue: batch.queue,
+        messages: validated,
+        ackAll: () => batch.ackAll(),
+        retryAll: (opts) => batch.retryAll(opts)
+      };
+      try {
+        await consumer.handleBatch(validatedBatch, container);
+      } catch (err) {
+        config.errorMapper?.onUnhandled?.(err, { queue: batch.queue });
+        batch.retryAll();
+      }
+      return;
+    }
+    if (!("handle" in consumer) || !consumer.handle) {
+      throw new Error(
+        `[katajs] Consumer for '${batch.queue}' (module '${entry.module.name}') has neither 'handle' nor 'handleBatch'.`
+      );
+    }
+    const handle = consumer.handle;
+    for (const msg of batch.messages) {
+      let body;
+      try {
+        body = consumer.schema.parse(msg.body);
+      } catch (err) {
+        const wrapped = err instanceof ValidationError ? err : err;
+        await onMessageFailure(msg, consumer, env, wrapped, config.errorMapper, batch.queue);
+        continue;
+      }
+      const container = buildContainer({
+        ...sharedContainerArgs,
+        requestId: msg.id
+      });
+      try {
+        await handle(makeValidatedMessage(msg, body), container);
+        msg.ack();
+      } catch (err) {
+        await onMessageFailure(msg, consumer, env, err, config.errorMapper, batch.queue);
+      }
+    }
+  };
+}
+function makeValidatedMessage(raw, body) {
+  return {
+    id: raw.id,
+    timestamp: raw.timestamp,
+    body,
+    attempts: raw.attempts,
+    ack: () => raw.ack(),
+    retry: (opts) => raw.retry(opts)
+  };
+}
+async function onMessageFailure(msg, consumer, env, err, errorMapper2, queue) {
+  errorMapper2?.onUnhandled?.(err, {
+    queue,
+    messageId: msg.id,
+    attempts: msg.attempts
+  });
+  const maxRetries = consumer.maxRetries ?? DEFAULT_MAX_RETRIES;
+  if (msg.attempts >= maxRetries) {
+    if (consumer.dlq) {
+      const dlqBinding = env?.[consumer.dlq];
+      if (dlqBinding && typeof dlqBinding.send === "function") {
+        try {
+          await dlqBinding.send({
+            originalQueue: queue,
+            messageId: msg.id,
+            body: msg.body,
+            error: err instanceof Error ? err.message : String(err),
+            attempts: msg.attempts,
+            failedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          msg.ack();
+          return;
+        } catch (dlqErr) {
+          errorMapper2?.onUnhandled?.(dlqErr, {
+            queue: consumer.dlq,
+            messageId: msg.id
+          });
+        }
+      } else {
+        errorMapper2?.onUnhandled?.(
+          new Error(
+            `[katajs] DLQ binding '${consumer.dlq}' not found on env. Acking message ${msg.id} to avoid loops.`
+          ),
+          { queue, messageId: msg.id }
+        );
+        msg.ack();
+        return;
+      }
+    } else {
+      msg.ack();
+      return;
+    }
+  }
+  msg.retry();
+}
+function cryptoRandomUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+
+// src/app.ts
+function createApp(config) {
+  validateModules(config.modules);
+  const registry = buildRegistry(config.modules.map((m) => m.provides));
+  const base = new Hono();
+  base.use(
+    "*",
+    containerMiddleware({
+      registry,
+      db: config.db,
+      generateRequestId: config.generateRequestId,
+      queues: config.queues
+    })
+  );
+  for (const mw of config.middleware ?? []) {
+    base.use("*", mw);
+  }
+  base.onError(errorMapper(config.errorMapper));
+  const app = config.routes ? config.routes(base) : base;
+  const queue = buildQueueHandler({
+    modules: config.modules,
+    registry,
+    db: config.db,
+    errorMapper: config.queueErrorMapper,
+    generateRequestId: config.generateRequestId
+  });
+  return { app, modules: config.modules, queue };
+}
+function validateModules(modules) {
+  const provideOwners = /* @__PURE__ */ new Map();
+  for (const m of modules) {
+    for (const key of Object.keys(m.provides)) {
+      const existing = provideOwners.get(key);
+      if (existing) {
+        throw new Error(
+          `[katajs] Duplicate provides key '${key}'.
+Provided by: '${existing}' and '${m.name}'.
+Pick one module to own this key.`
+        );
+      }
+      provideOwners.set(key, m.name);
+    }
+  }
+  const allKeys = [...provideOwners.keys()];
+  const moduleNames = modules.map((m) => m.name);
+  for (const m of modules) {
+    for (const key of m.requires) {
+      if (!provideOwners.has(key)) {
+        throw new Error(
+          `[katajs] Module '${m.name}' requires '${key}', but no module provides it.
+Modules registered: ${moduleNames.join(", ") || "(none)"}.
+Provided keys: ${allKeys.join(", ") || "(none)"}.
+Did you forget to add the providing module to createApp({ modules: [...] })?`
+        );
+      }
+    }
+  }
+  const moduleByName = new Map(modules.map((m) => [m.name, m]));
+  const edges = /* @__PURE__ */ new Map();
+  for (const m of modules) {
+    const deps = /* @__PURE__ */ new Set();
+    for (const key of m.requires) {
+      const ownerName = provideOwners.get(key);
+      if (ownerName && ownerName !== m.name) deps.add(ownerName);
+    }
+    edges.set(m.name, deps);
+  }
+  const cycle = findCycle(edges);
+  if (cycle) {
+    throw new Error(
+      `[katajs] Module dependency cycle detected.
+Cycle: ${cycle.join(" -> ")}.
+Modules cannot transitively require services from each other.`
+    );
+  }
+  void moduleByName;
+}
+function findCycle(edges) {
+  const VISITING = 1;
+  const VISITED = 2;
+  const state = /* @__PURE__ */ new Map();
+  const stack = [];
+  function visit(node) {
+    const s = state.get(node);
+    if (s === VISITED) return void 0;
+    if (s === VISITING) {
+      const idx = stack.indexOf(node);
+      return [...stack.slice(idx), node];
+    }
+    state.set(node, VISITING);
+    stack.push(node);
+    for (const next of edges.get(node) ?? []) {
+      const found = visit(next);
+      if (found) return found;
+    }
+    stack.pop();
+    state.set(node, VISITED);
+    return void 0;
+  }
+  for (const node of edges.keys()) {
+    const found = visit(node);
+    if (found) return found;
+  }
+  return void 0;
+}
+
+// src/validate.ts
+import { zValidator } from "@hono/zod-validator";
+var targetByLabel = {
+  body: "json",
+  query: "query",
+  param: "param"
+};
+function makeHook(label) {
+  return (result, _c) => {
+    if (!result.success && result.error) {
+      const issues = result.error.issues.map((i) => ({
+        path: [label, ...i.path],
+        message: i.message
+      }));
+      throw new ValidationError(issues);
+    }
+  };
+}
+function validate(opts) {
+  const middlewares = [];
+  if (opts.body) {
+    middlewares.push(zValidator(targetByLabel.body, opts.body, makeHook("body")));
+  }
+  if (opts.query) {
+    middlewares.push(zValidator(targetByLabel.query, opts.query, makeHook("query")));
+  }
+  if (opts.param) {
+    middlewares.push(zValidator(targetByLabel.param, opts.param, makeHook("param")));
+  }
+  return middlewares;
+}
+
+// src/inspect.ts
+function inspectModules(modules, options = {}) {
+  const provideOwners = /* @__PURE__ */ new Map();
+  for (const m of modules) {
+    for (const key of Object.keys(m.provides)) {
+      provideOwners.set(key, m.name);
+    }
+  }
+  const inspectedModules = modules.map((m) => {
+    const consumer = m.consumer ? { queue: m.consumer.queue, dlq: m.consumer.dlq } : void 0;
+    return {
+      name: m.name,
+      provides: Object.keys(m.provides).sort(),
+      requires: [...m.requires].sort(),
+      prefix: isRoutedModule(m) ? m.prefix : void 0,
+      hasRoutes: isRoutedModule(m),
+      ...consumer ? { consumer } : {}
+    };
+  });
+  const producers = options.producers ? Object.entries(options.producers).map(([name, p]) => ({ name, binding: p.binding })).sort((a, b) => a.name.localeCompare(b.name)) : [];
+  const edges = [];
+  for (const m of modules) {
+    for (const key of m.requires) {
+      const owner = provideOwners.get(key);
+      if (owner && owner !== m.name) {
+        edges.push({ from: m.name, to: owner, via: key });
+      }
+    }
+  }
+  const routes = [];
+  const seenRoutes = /* @__PURE__ */ new Set();
+  for (const m of modules) {
+    if (!isRoutedModule(m)) continue;
+    const honoRoutes = m.routes.routes;
+    if (!Array.isArray(honoRoutes)) continue;
+    for (const r of honoRoutes) {
+      if (typeof r.method !== "string" || typeof r.path !== "string") continue;
+      if (r.method === "ALL" && r.path === "*") continue;
+      const fullPath = mergePath(m.prefix, r.path);
+      const key = `${r.method} ${fullPath} ${m.name}`;
+      if (seenRoutes.has(key)) continue;
+      seenRoutes.add(key);
+      routes.push({ method: r.method, path: fullPath, module: m.name });
+    }
+  }
+  routes.sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+  edges.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+  return {
+    modules: inspectedModules,
+    edges,
+    routes,
+    producers,
+    mermaid: () => buildMermaid(inspectedModules, edges),
+    json: () => JSON.stringify(
+      { modules: inspectedModules, edges, routes, producers },
+      null,
+      2
+    ),
+    html: (opts) => buildHtml(inspectedModules, edges, routes, opts)
+  };
+}
+function isRoutedModule(m) {
+  return "routes" in m && "prefix" in m;
+}
+function mergePath(base, sub) {
+  if (!base || base === "/") return sub === "" ? "/" : sub;
+  if (!sub || sub === "/") return base;
+  const a = base.endsWith("/") ? base.slice(0, -1) : base;
+  const b = sub.startsWith("/") ? sub : `/${sub}`;
+  return `${a}${b}`;
+}
+function buildMermaid(modules, edges) {
+  const lines = ["graph TD"];
+  for (const m of modules) {
+    const meta = [];
+    if (m.prefix) meta.push(m.prefix);
+    if (m.provides.length > 0) meta.push(`+${m.provides.length} services`);
+    const sub = meta.length > 0 ? `<br/><small>${meta.join(" \u2022 ")}</small>` : "";
+    lines.push(`  ${m.name}["<b>${m.name}</b>${sub}"]`);
+  }
+  for (const e of edges) {
+    lines.push(`  ${e.from} -->|${e.via}| ${e.to}`);
+  }
+  return lines.join("\n");
+}
+function buildHtml(modules, edges, routes, opts = {}) {
+  const title = opts.title ?? "katajs \u2014 module graph";
+  const mermaidSrc = buildMermaid(modules, edges);
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escapeHtml(title)}</title>
+<style>
+  :root {
+    --bg: #0f1115;
+    --panel: #161922;
+    --panel-2: #1d2230;
+    --text: #e8ebf2;
+    --muted: #8b93a7;
+    --accent: #7aa2ff;
+    --accent-2: #57c7b9;
+    --border: #2a3041;
+    --get: #57c7b9;
+    --post: #7aa2ff;
+    --put: #f5a623;
+    --patch: #f5a623;
+    --delete: #ff6b6b;
+  }
+  * { box-sizing: border-box; }
+  body {
+    font: 14px/1.55 -apple-system, BlinkMacSystemFont, 'Segoe UI', system-ui, sans-serif;
+    margin: 0;
+    background: var(--bg);
+    color: var(--text);
+  }
+  header {
+    padding: 1.75rem 2rem 1.25rem;
+    border-bottom: 1px solid var(--border);
+  }
+  header h1 {
+    margin: 0;
+    font-size: 1.4rem;
+    font-weight: 600;
+  }
+  header .meta {
+    color: var(--muted);
+    margin-top: 0.25rem;
+    font-size: 0.85rem;
+  }
+  main {
+    padding: 1.5rem 2rem 4rem;
+    max-width: 1280px;
+    margin: 0 auto;
+  }
+  section + section { margin-top: 2.5rem; }
+  section h2 {
+    font-size: 0.85rem;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    color: var(--muted);
+    font-weight: 600;
+    margin: 0 0 0.75rem;
+  }
+  .graph {
+    background: var(--panel);
+    border: 1px solid var(--border);
+    border-radius: 12px;
+    padding: 1.5rem;
+    overflow: auto;
+  }
+  .graph .mermaid {
+    text-align: center;
+    color: var(--text);
+  }
+  table {
+    width: 100%;
+    border-collapse: collapse;
+    background: var(--panel);
+    border: 1px solid var(--border);
+    border-radius: 12px;
+    overflow: hidden;
+  }
+  th, td {
+    text-align: left;
+    padding: 0.7rem 1rem;
+    border-bottom: 1px solid var(--border);
+  }
+  tr:last-child td { border-bottom: none; }
+  th {
+    background: var(--panel-2);
+    color: var(--muted);
+    font-size: 0.75rem;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    font-weight: 600;
+  }
+  td.method { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-weight: 600; }
+  td.method[data-m="GET"] { color: var(--get); }
+  td.method[data-m="POST"] { color: var(--post); }
+  td.method[data-m="PUT"] { color: var(--put); }
+  td.method[data-m="PATCH"] { color: var(--patch); }
+  td.method[data-m="DELETE"] { color: var(--delete); }
+  code {
+    font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+    font-size: 0.9em;
+    background: var(--panel-2);
+    padding: 0.1rem 0.4rem;
+    border-radius: 4px;
+  }
+  .pill {
+    display: inline-block;
+    padding: 0.1rem 0.5rem;
+    background: var(--panel-2);
+    border: 1px solid var(--border);
+    border-radius: 999px;
+    font-size: 0.8rem;
+    margin-right: 0.25rem;
+    margin-bottom: 0.25rem;
+  }
+  .pill.requires { color: var(--accent); border-color: rgba(122, 162, 255, 0.3); }
+  .pill.provides { color: var(--accent-2); border-color: rgba(87, 199, 185, 0.3); }
+  .empty { color: var(--muted); font-style: italic; }
+  footer {
+    padding: 2rem;
+    text-align: center;
+    color: var(--muted);
+    font-size: 0.8rem;
+    border-top: 1px solid var(--border);
+  }
+</style>
+</head>
+<body>
+<header>
+  <h1>${escapeHtml(title)}</h1>
+  <div class="meta">${modules.length} modules \u2022 ${edges.length} dependencies \u2022 ${routes.length} routes</div>
+</header>
+<main>
+  <section>
+    <h2>Module graph</h2>
+    <div class="graph">
+      <pre class="mermaid">${escapeHtml(mermaidSrc)}</pre>
+    </div>
+  </section>
+
+  <section>
+    <h2>Modules</h2>
+    <table>
+      <thead><tr><th>Name</th><th>Prefix</th><th>Provides</th><th>Requires</th></tr></thead>
+      <tbody>
+${modules.map(
+    (m) => `        <tr>
+          <td><strong>${escapeHtml(m.name)}</strong></td>
+          <td>${m.prefix ? `<code>${escapeHtml(m.prefix)}</code>` : '<span class="empty">\u2014</span>'}</td>
+          <td>${m.provides.length === 0 ? '<span class="empty">\u2014</span>' : m.provides.map((p) => `<span class="pill provides">${escapeHtml(p)}</span>`).join("")}</td>
+          <td>${m.requires.length === 0 ? '<span class="empty">\u2014</span>' : m.requires.map((p) => `<span class="pill requires">${escapeHtml(p)}</span>`).join("")}</td>
+        </tr>`
+  ).join("\n")}
+      </tbody>
+    </table>
+  </section>
+
+  <section>
+    <h2>Routes</h2>
+    ${routes.length === 0 ? '<p class="empty">No routes mounted.</p>' : `<table>
+      <thead><tr><th>Method</th><th>Path</th><th>Module</th></tr></thead>
+      <tbody>
+${routes.map(
+    (r) => `        <tr>
+          <td class="method" data-m="${escapeHtml(r.method)}">${escapeHtml(r.method)}</td>
+          <td><code>${escapeHtml(r.path)}</code></td>
+          <td>${escapeHtml(r.module)}</td>
+        </tr>`
+  ).join("\n")}
+      </tbody>
+    </table>`}
+  </section>
+</main>
+<footer>
+  Generated by <code>inspectModules()</code> from <code>@katajs/core</code>
+</footer>
+<script type="module">
+  import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';
+  mermaid.initialize({
+    startOnLoad: true,
+    securityLevel: 'loose',
+    theme: 'dark',
+    themeVariables: {
+      darkMode: true,
+      background: '#161922',
+      primaryColor: '#1d2230',
+      primaryTextColor: '#e8ebf2',
+      primaryBorderColor: '#2a3041',
+      lineColor: '#7aa2ff',
+      secondaryColor: '#57c7b9',
+      tertiaryColor: '#1d2230',
+    },
+  });
+</script>
+</body>
+</html>
+`;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+export {
+  AppError,
+  ValidationError,
+  createApp,
+  defineConsumer,
+  defineMiddleware,
+  defineModule,
+  errorMapper,
+  inspectModules,
+  validate
+};
+//# sourceMappingURL=index.js.map