@cosmicdrift/kumiko-samples 0.369.0 → 0.370.0

package/packages/bundled-features/src/host-routing/README.md

@@ -0,0 +1,89 @@
+# host-routing
+
+Tenant routing by host or path for apps with tenant subdomains, a tenant path
+prefix or locale-prefixed marketing pages. Two halves:
+
+- `createHostRoutingFeature(options)`: the server half. In `tenantBy: "host"` it
+  registers an authoritative tenant resolver (`<key>.<baseDomain>` → tenant),
+  so anonymous API calls get their tenant from the Host header only; a
+  disagreeing `X-Tenant` header or cookie answers `400 tenant_mismatch`, and the
+  apex or an unknown host answers `400 tenant_required`. Set
+  `apexAnonymousTenantId` and the apex answers as that tenant instead (host
+  mode: authoritative; path mode: only when the client names no tenant). Path
+  keys may be any 1 to 50 unreserved URL characters, subdomain keys must be
+  one lowercase DNS label. In both modes it
+  registers a tenant existence check: a client-named tenant must exist, be
+  enabled and be active. It also owns the anonymous, rate-limited
+  `host-routing:query:tenant-key-exists` query.
+- `createHostDispatch(options)`: the page half for `runProdApp({ hostDispatch })`.
+  It picks the HTML file and optional CSP per host, answers the locale redirect
+  and returns 404 for unknown tenants and unknown hosts.
+
+The dev server uses the same decision through
+`toDevHostDispatch(dispatch, { entries, staticDir })` from
+`@cosmicdrift/kumiko-dev-server`.
+
+## Setup
+
+```typescript
+import {
+  createHostDispatch,
+  createHostRoutingFeature,
+  type HostRoutingOptions,
+} from "@cosmicdrift/kumiko-bundled-features/host-routing";
+import { resolveAnonymousAccessFromRegistry } from "@cosmicdrift/kumiko-bundled-features/auth-foundation";
+
+const routing: HostRoutingOptions = {
+  tenantBy: "host",
+  baseDomain: "example.com",
+  apex: { file: "index.html", localeFiles: { en: "en/index.html" } },
+  tenant: { file: "app.html", csp: "default-src 'self'; frame-ancestors 'none'" },
+  unknownTenant: { file: "unknown-tenant.html" },
+  hosts: { "admin.example.com": { file: "admin.html" } },
+  locales: { default: "de", prefixed: ["en"] },
+};
+
+runProdApp({
+  features: [...FEATURES, createHostRoutingFeature(routing)],
+  anonymousAccess: () => ({}),
+  hostDispatch: createHostDispatch(routing),
+});
+```
+
+`anonymousAccess` stays an app opt-in: the providers are merged in only when
+the app sets it.
+
+## Options
+
+| Option | Meaning |
+|---|---|
+| `tenantBy` | `"host"` (`<key>.<baseDomain>`) or `"path"` with `tenantPathPrefix` (`/t/<key>/...` on the apex) |
+| `baseDomain` | Apex hostname, lowercase, no port. `www.<baseDomain>` counts as apex |
+| `apex` | `{ file, csp?, localeFiles? }` for the apex |
+| `tenant` | `{ file, csp? }` for a known tenant and for the bare path prefix |
+| `unknownTenant` | `{ file, csp? }` served with 404; omit for a bare 404 |
+| `hosts` | Further fixed hostnames with their own surface, checked first |
+| `apexAnonymousTenantId` | Tenant for anonymous API calls on the apex (e.g. `SYSTEM_TENANT_ID` for public signup); omit and the apex has none |
+| `locales` | `{ default, prefixed }`: `/<default>/...` answers 301 to the unprefixed path, `/<prefixed>/...` serves `apex.localeFiles[locale]` |
+
+A `csp` replaces runProdApp's default CSP for that surface; without it the
+default applies. Options are validated when the feature or dispatch is built.
+
+## Security
+
+- Only plain DNS names (optional port) are routed. `X-Forwarded-Host` is never
+  read; userinfo, IPv6 literals, lists or nested subdomains fall to a bare 404
+  without a lookup.
+- Redirect targets are same-origin paths; leading slashes and backslashes are
+  collapsed, so `/de//evil.example` never becomes a protocol-relative URL.
+- The key query returns only `{ exists }`, which the 404 page makes public
+  anyway. Over its rate limit the dispatch serves the tenant shell; the API
+  behind it still resolves the tenant itself.
+- In `tenantBy: "path"` no resolver is registered, so the client names its
+  tenant with `X-Tenant`; the existence check still rejects unknown, disabled
+  and destroyed tenants.
+
+## Not covered
+
+Custom domains per tenant, legacy host redirects and app-specific query
+allowlists stay in the app: wrap the dispatch function and fall through to it.

package/packages/bundled-features/src/host-routing/changes.json

@@ -0,0 +1,8 @@
+[
+  {
+    "version": "0.370.0",
+    "type": "improvement",
+    "title": "createHostRoutingFeature and createHostDispatch route tenants by host or path",
+    "detail": "One HostRoutingOptions object ({ tenantBy: \"host\" } or { tenantBy: \"path\", tenantPathPrefix }, plus baseDomain, apex, tenant, unknownTenant?, hosts?, locales?) drives both halves. createHostRoutingFeature registers an authoritative Host-header tenant resolver in host mode and, in both modes, an existence check that admits only enabled, active tenants. apexAnonymousTenantId gives anonymous apex calls a tenant (e.g. SYSTEM_TENANT_ID); without it the apex answers tenant_required. createHostDispatch is a runProdApp hostDispatch: HTML file and optional CSP per surface (without csp the runProdApp default applies), a 301 from the default-locale prefix to the unprefixed path, and 404 for unknown tenants and hosts. toDevHostDispatch(dispatch, { entries, staticDir }) from @cosmicdrift/kumiko-dev-server plugs the same decision into the dev server. Apps with their own routing feature and hostDispatch move to these; app-specific redirects or custom domains wrap the dispatch function."
+  }
+]

package/packages/bundled-features/src/host-routing/constants.ts

@@ -0,0 +1,24 @@
+export const HOST_ROUTING_FEATURE = "host-routing";
+
+export const HostRoutingQueries = {
+  tenantKeyExists: `${HOST_ROUTING_FEATURE}:query:tenant-key-exists`,
+} as const;
+
+// Matches tenant:write:create's key limit; keeps lookups for absurd keys out
+// of the database.
+export const TENANT_KEY_MAX_LENGTH = 50;
+// A subdomain is one lowercase DNS label, so tenant keys outside this shape
+// are only reachable in path mode.
+export const TENANT_KEY_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,48}[a-z0-9])?$/;
+
+export function isTenantKeyCandidate(value: string): boolean {
+  return value.length <= TENANT_KEY_MAX_LENGTH && TENANT_KEY_PATTERN.test(value);
+}
+
+// Path mode takes any key made of unreserved URL characters, since the tenant
+// feature itself only limits the length.
+const PATH_TENANT_KEY_PATTERN = /^[A-Za-z0-9._~-]+$/;
+
+export function isPathTenantKeyCandidate(value: string): boolean {
+  return value.length <= TENANT_KEY_MAX_LENGTH && PATH_TENANT_KEY_PATTERN.test(value);
+}

package/packages/bundled-features/src/host-routing/dispatch.ts

@@ -0,0 +1,130 @@
+import { SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
+import { RateLimitError, ValidationError } from "@cosmicdrift/kumiko-framework/errors";
+import type { PageHeadSystemQuery } from "@cosmicdrift/kumiko-headless/apex";
+import * as z from "zod";
+import { HostRoutingQueries, isPathTenantKeyCandidate, isTenantKeyCandidate } from "./constants.ts";
+import { classifyHost } from "./host.ts";
+import type { HostRoutingOptions, HostRoutingSurface } from "./options.ts";
+import { validateHostRoutingOptions } from "./validate-options.ts";
+
+// Structurally identical to server-runtime's HostDispatchResult. Defined here
+// because server-runtime depends on bundled-features, not the other way round;
+// dev-server pins the compatibility with a type test.
+export type HostRoutingDispatchResult =
+  | { readonly kind: "html"; readonly file: string; readonly csp?: string }
+  | { readonly kind: "redirect"; readonly to: string; readonly status?: 301 | 302 }
+  | { readonly kind: "not-found"; readonly file?: string; readonly csp?: string };
+
+export type HostRoutingRequest = {
+  readonly host: string;
+  readonly path: string;
+  // Query string incl. leading "?", "" if none.
+  readonly search: string;
+};
+
+export type HostRoutingDispatchFn = (
+  req: HostRoutingRequest,
+  deps: { readonly systemQuery: PageHeadSystemQuery },
+) => Promise<HostRoutingDispatchResult>;
+
+const tenantKeyExistsResultSchema = z.object({ exists: z.boolean() });
+
+async function isTenantKeyKnown(systemQuery: PageHeadSystemQuery, key: string): Promise<boolean> {
+  let result: unknown;
+  try {
+    result = await systemQuery(HostRoutingQueries.tenantKeyExists, { key }, SYSTEM_TENANT_ID);
+  } catch (error) {
+    if (error instanceof ValidationError) return false;
+    // Over the rate limit every key looks the same: serve the tenant shell,
+    // which leaks nothing; the API behind it still resolves the tenant itself.
+    if (error instanceof RateLimitError) return true;
+    throw error;
+  }
+  return tenantKeyExistsResultSchema.parse(result).exists;
+}
+
+function serve(
+  surface: HostRoutingSurface,
+  file: string = surface.file,
+): HostRoutingDispatchResult {
+  return surface.csp === undefined
+    ? { kind: "html", file }
+    : { kind: "html", file, csp: surface.csp };
+}
+
+function notFound(surface: HostRoutingSurface | undefined): HostRoutingDispatchResult {
+  if (surface === undefined) return { kind: "not-found" };
+  return surface.csp === undefined
+    ? { kind: "not-found", file: surface.file }
+    : { kind: "not-found", file: surface.file, csp: surface.csp };
+}
+
+// Redirect targets are always same-origin paths. Collapsing leading slashes
+// and backslashes keeps "/de//evil.example" from turning into the
+// protocol-relative "//evil.example".
+function sameOriginPath(path: string): string {
+  return `/${path.replace(/^[/\\]+/, "")}`;
+}
+
+function splitFirstSegment(path: string): { readonly segment: string; readonly rest: string } {
+  const withoutLeading = path.replace(/^\/+/, "");
+  const slash = withoutLeading.indexOf("/");
+  if (slash === -1) return { segment: withoutLeading, rest: "/" };
+  return { segment: withoutLeading.slice(0, slash), rest: withoutLeading.slice(slash) };
+}
+
+function apexPage(options: HostRoutingOptions, req: HostRoutingRequest): HostRoutingDispatchResult {
+  const { apex, locales } = options;
+  if (locales === undefined) return serve(apex);
+  const { segment, rest } = splitFirstSegment(req.path);
+  if (segment === locales.default) {
+    return { kind: "redirect", to: `${sameOriginPath(rest)}${req.search}`, status: 301 };
+  }
+  const locale = locales.prefixed.includes(segment) ? segment : locales.default;
+  return serve(apex, apex.localeFiles?.[locale] ?? apex.file);
+}
+
+async function tenantPage(
+  options: HostRoutingOptions,
+  key: string | null,
+  systemQuery: PageHeadSystemQuery,
+): Promise<HostRoutingDispatchResult> {
+  // No key (bare tenant prefix): the shell handles login and tenant choice.
+  if (key === null) return serve(options.tenant);
+  const isCandidate = options.tenantBy === "path" ? isPathTenantKeyCandidate : isTenantKeyCandidate;
+  if (!isCandidate(key)) return notFound(options.unknownTenant);
+  return (await isTenantKeyKnown(systemQuery, key))
+    ? serve(options.tenant)
+    : notFound(options.unknownTenant);
+}
+
+function tenantKeyFromPath(prefix: string, path: string): string | null | undefined {
+  if (path !== prefix && !path.startsWith(`${prefix}/`)) return undefined;
+  const { segment } = splitFirstSegment(path.slice(prefix.length));
+  return segment === "" ? null : segment;
+}
+
+// The routing decision for runProdApp's `hostDispatch` (and, via
+// toDevHostDispatch, the dev server). Unknown hosts fail closed with 404.
+export function createHostDispatch(options: HostRoutingOptions): HostRoutingDispatchFn {
+  validateHostRoutingOptions(options);
+  return async (req, { systemQuery }) => {
+    const host = classifyHost(req.host, options);
+    switch (host.kind) {
+      case "fixed":
+        return serve(host.surface);
+      case "unknown":
+        return notFound(undefined);
+      case "subdomain":
+        if (options.tenantBy !== "host") return notFound(undefined);
+        return tenantPage(options, host.key, systemQuery);
+      case "apex": {
+        if (options.tenantBy === "path") {
+          const key = tenantKeyFromPath(options.tenantPathPrefix, req.path);
+          if (key !== undefined) return tenantPage(options, key, systemQuery);
+        }
+        return apexPage(options, req);
+      }
+    }
+  };
+}

package/packages/bundled-features/src/host-routing/feature.ts

@@ -0,0 +1,146 @@
+import type { DbConnection, TenantDb } from "@cosmicdrift/kumiko-framework/db";
+import { fetchOne } from "@cosmicdrift/kumiko-framework/db";
+import {
+  defineFeature,
+  defineQueryHandler,
+  type FeatureDefinition,
+  isSystemTenant,
+  type TenantId,
+} from "@cosmicdrift/kumiko-framework/engine";
+import { InternalError } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import {
+  EXT_TENANT_EXISTENCE,
+  EXT_TENANT_RESOLVER,
+  type TenantExistenceProvider,
+  type TenantResolverProvider,
+} from "../auth-foundation/index.ts";
+import {
+  isTenantServingPublicContent,
+  type TenantLifecycleStatus,
+  tenantTable,
+} from "../tenant/index.ts";
+import { HOST_ROUTING_FEATURE, TENANT_KEY_MAX_LENGTH } from "./constants.ts";
+import { classifyHost } from "./host.ts";
+import type { HostRoutingOptions } from "./options.ts";
+import { validateHostRoutingOptions } from "./validate-options.ts";
+
+type TenantRow = {
+  readonly id: TenantId;
+  readonly isEnabled: boolean;
+  readonly status: TenantLifecycleStatus;
+};
+
+// Disabled tenants and tenants in any destroy phase are not routable, the same
+// rule public files and pages follow.
+async function servingTenantIdByKey(
+  db: DbConnection | TenantDb,
+  key: string,
+): Promise<TenantId | null> {
+  const row = await fetchOne<TenantRow>(db, tenantTable, { key });
+  return row !== undefined && isTenantServingPublicContent(row) ? row.id : null;
+}
+
+async function isTenantServing(db: DbConnection, id: TenantId): Promise<boolean> {
+  const row = await fetchOne<TenantRow>(db, tenantTable, { id });
+  return row !== undefined && isTenantServingPublicContent(row);
+}
+
+type HostHeaderReader = { readonly req: { readonly header: (name: string) => string | undefined } };
+
+// auth-foundation types the Hono context as unknown to stay free of a hono dep.
+function isHostHeaderReader(c: unknown): c is HostHeaderReader {
+  return (
+    typeof c === "object" &&
+    c !== null &&
+    "req" in c &&
+    typeof c.req === "object" &&
+    c.req !== null &&
+    "header" in c.req &&
+    typeof c.req.header === "function"
+  );
+}
+
+// Returns only { exists }: the same fact the tenant 404 page already makes
+// public, never other tenant fields. Rate-limited so it is no cheap oracle.
+const tenantKeyExistsQuery = defineQueryHandler({
+  name: "tenant-key-exists",
+  schema: z.object({ key: z.string().min(1).max(TENANT_KEY_MAX_LENGTH) }),
+  access: { roles: ["anonymous"] },
+  rateLimit: { per: "ip+handler", limit: 120, windowSeconds: 60 },
+  // Page-routing plumbing, not a task an agent performs.
+  agent: { expose: false },
+  description:
+    "Anonymous existence check for a tenant key, backing the unknown-tenant 404 of the host-routing hostDispatch. Returns only { exists }.",
+  handler: async (query, ctx) => {
+    if (!ctx.systemDb) {
+      throw new InternalError({
+        message: "host-routing:query:tenant-key-exists requires ctx.systemDb (r.systemScope())",
+      });
+    }
+    const db = ctx.systemDb.acknowledgeCrossTenant(
+      "tenant-key existence check for the host-routing 404 — publicly observable via the 404 itself",
+    );
+    return { exists: (await servingTenantIdByKey(db, query.payload.key)) !== null };
+  },
+});
+
+function tenantResolverFor(options: HostRoutingOptions): TenantResolverProvider | undefined {
+  const apexTenantId = options.apexAnonymousTenantId ?? null;
+  if (options.tenantBy === "host") {
+    return {
+      trust: "authoritative",
+      build:
+        ({ db }) =>
+        async (c: unknown): Promise<TenantId | null> => {
+          if (!isHostHeaderReader(c)) return null;
+          const host = classifyHost(c.req.header("Host") ?? "", options);
+          if (host.kind === "subdomain") return servingTenantIdByKey(db, host.key);
+          // Fixed and unknown hosts have no anonymous tenant: an authoritative
+          // null answers tenant_required, whatever X-Tenant says.
+          return host.kind === "apex" ? apexTenantId : null;
+        },
+    };
+  }
+  if (apexTenantId === null) return undefined;
+  // Path mode: the client names its tenant; the apex default only fills in
+  // when it does not.
+  return {
+    trust: "fallback-only",
+    build: () => async (c: unknown) => {
+      if (!isHostHeaderReader(c)) return null;
+      return classifyHost(c.req.header("Host") ?? "", options).kind === "apex"
+        ? apexTenantId
+        : null;
+    },
+  };
+}
+
+// Server half of host routing: the tenant for anonymous API requests comes
+// from the Host header only (never from X-Tenant), and a client-named tenant
+// must exist, be enabled and be active. The page half is createHostDispatch.
+export function createHostRoutingFeature(options: HostRoutingOptions): FeatureDefinition {
+  validateHostRoutingOptions(options);
+  return defineFeature(HOST_ROUTING_FEATURE, (r) => {
+    r.describe(
+      "Host- and path-based tenant routing: an authoritative tenant resolver from the subdomain (tenantBy host), a tenant existence check against enabled, active tenants, and the tenant-key query behind createHostDispatch, which picks the HTML file, CSP, locale redirect or 404 per host for runProdApp's hostDispatch.",
+    );
+    r.requires({ features: ["auth-foundation", "tenant"] });
+    r.systemScope();
+    r.queryHandler(tenantKeyExistsQuery);
+
+    const resolver = tenantResolverFor(options);
+    if (resolver !== undefined) {
+      // biome-ignore lint/correctness/useHookAtTopLevel: r.useExtension is a registrar method, not a React hook; path mode without an apex tenant must leave the resolver slot free.
+      r.useExtension(EXT_TENANT_RESOLVER, "host", resolver);
+    }
+
+    const existence: TenantExistenceProvider = {
+      build:
+        ({ db }) =>
+        (tenantId: string) =>
+          isSystemTenant(tenantId) ? true : isTenantServing(db, tenantId),
+    };
+    r.useExtension(EXT_TENANT_EXISTENCE, "active-tenant", existence);
+  });
+}

package/packages/bundled-features/src/host-routing/host.ts

@@ -0,0 +1,42 @@
+import { isTenantKeyCandidate } from "./constants.ts";
+import type { HostRoutingOptions, HostRoutingSurface } from "./options.ts";
+
+// Only plain DNS names (plus an optional port) are routable. Anything else,
+// e.g. userinfo ("a@b"), IPv6 literals or stray characters, never matches a
+// configured domain and must not reach URL parsing or a DB lookup.
+const HOST_HEADER_PATTERN = /^[a-z0-9.-]+(?::[0-9]{1,5})?$/;
+
+export function normalizeHostname(host: string): string | null {
+  const lower = host.trim().toLowerCase();
+  if (!HOST_HEADER_PATTERN.test(lower)) return null;
+  const colon = lower.indexOf(":");
+  const hostname = colon === -1 ? lower : lower.slice(0, colon);
+  const withoutTrailingDot = hostname.endsWith(".") ? hostname.slice(0, -1) : hostname;
+  return withoutTrailingDot === "" ? null : withoutTrailingDot;
+}
+
+export type HostClass =
+  | { readonly kind: "fixed"; readonly surface: HostRoutingSurface }
+  | { readonly kind: "apex" }
+  | { readonly kind: "subdomain"; readonly key: string }
+  | { readonly kind: "unknown" };
+
+export function classifyHost(host: string, options: HostRoutingOptions): HostClass {
+  const hostname = normalizeHostname(host);
+  if (hostname === null) return { kind: "unknown" };
+  // Own-property check: the Host header is attacker-controlled, and a plain
+  // "constructor" would otherwise resolve through Object.prototype.
+  const fixed =
+    options.hosts !== undefined && Object.hasOwn(options.hosts, hostname)
+      ? options.hosts[hostname]
+      : undefined;
+  if (fixed !== undefined) return { kind: "fixed", surface: fixed };
+  const baseDomain = options.baseDomain.toLowerCase();
+  if (hostname === baseDomain || hostname === `www.${baseDomain}`) return { kind: "apex" };
+  const suffix = `.${baseDomain}`;
+  if (!hostname.endsWith(suffix)) return { kind: "unknown" };
+  const label = hostname.slice(0, -suffix.length);
+  // Exactly one label: "a.b.<baseDomain>" is not a tenant host.
+  if (!isTenantKeyCandidate(label)) return { kind: "unknown" };
+  return { kind: "subdomain", key: label };
+}

package/packages/bundled-features/src/host-routing/index.ts

@@ -0,0 +1,21 @@
+export {
+  HOST_ROUTING_FEATURE,
+  HostRoutingQueries,
+  isTenantKeyCandidate,
+  TENANT_KEY_MAX_LENGTH,
+} from "./constants.ts";
+export {
+  createHostDispatch,
+  type HostRoutingDispatchFn,
+  type HostRoutingDispatchResult,
+  type HostRoutingRequest,
+} from "./dispatch.ts";
+export { createHostRoutingFeature } from "./feature.ts";
+export { normalizeHostname } from "./host.ts";
+export type {
+  HostRoutingApexSurface,
+  HostRoutingLocales,
+  HostRoutingOptions,
+  HostRoutingSurface,
+  HostRoutingTenantMode,
+} from "./options.ts";

package/packages/bundled-features/src/host-routing/options.ts

@@ -0,0 +1,43 @@
+import type { TenantId } from "@cosmicdrift/kumiko-framework/engine";
+
+// What a host (or a tenant) gets served on the HTML fallback.
+export type HostRoutingSurface = {
+  // HTML file relative to the prod staticDir, e.g. "index.html" or "admin.html".
+  readonly file: string;
+  // Replaces the default CSP for this surface. Omit to keep runProdApp's default.
+  readonly csp?: string;
+};
+
+export type HostRoutingApexSurface = HostRoutingSurface & {
+  // Per-locale file for the apex, keyed by locale; falls back to `file`.
+  readonly localeFiles?: Readonly<Record<string, string>>;
+};
+
+export type HostRoutingLocales = {
+  // Served unprefixed; "/<default>/..." answers 301 to the unprefixed path.
+  readonly default: string;
+  // Served under "/<locale>/...".
+  readonly prefixed: readonly string[];
+};
+
+export type HostRoutingTenantMode =
+  // <key>.<baseDomain> names the tenant.
+  | { readonly tenantBy: "host" }
+  // <baseDomain><tenantPathPrefix>/<key>/... names the tenant.
+  | { readonly tenantBy: "path"; readonly tenantPathPrefix: string };
+
+export type HostRoutingOptions = HostRoutingTenantMode & {
+  // Apex host without port, e.g. "example.com". "www.<baseDomain>" counts as apex.
+  readonly baseDomain: string;
+  readonly apex: HostRoutingApexSurface;
+  // Served for a known, enabled tenant (and for the bare tenant path prefix).
+  readonly tenant: HostRoutingSurface;
+  // Served with status 404 for an unknown or disabled tenant. Omit for a bare 404.
+  readonly unknownTenant?: HostRoutingSurface;
+  // Further fixed hosts (full hostname, lowercase, without port), checked first.
+  readonly hosts?: Readonly<Record<string, HostRoutingSurface>>;
+  readonly locales?: HostRoutingLocales;
+  // Tenant for anonymous API calls on the apex (e.g. SYSTEM_TENANT_ID for
+  // public signup forms). Omit and the apex answers tenant_required.
+  readonly apexAnonymousTenantId?: TenantId;
+};

package/packages/bundled-features/src/host-routing/validate-options.ts

@@ -0,0 +1,38 @@
+import type { HostRoutingOptions } from "./options.ts";
+
+const DOMAIN_PATTERN = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const PATH_PREFIX_PATTERN = /^\/[a-z0-9-]+(?:\/[a-z0-9-]+)*$/;
+const LOCALE_PATTERN = /^[a-z]{2}(?:-[a-z]{2})?$/;
+
+// Checked once when the app composes its features, so a config typo fails
+// the boot instead of routing every request to a 404.
+export function validateHostRoutingOptions(options: HostRoutingOptions): void {
+  if (!DOMAIN_PATTERN.test(options.baseDomain)) {
+    throw new Error(
+      `host-routing: baseDomain must be a lowercase hostname without port, got "${options.baseDomain}"`,
+    );
+  }
+  for (const host of Object.keys(options.hosts ?? {})) {
+    if (!DOMAIN_PATTERN.test(host)) {
+      throw new Error(`host-routing: hosts key must be a lowercase hostname, got "${host}"`);
+    }
+  }
+  if (options.tenantBy === "path" && !PATH_PREFIX_PATTERN.test(options.tenantPathPrefix)) {
+    throw new Error(
+      `host-routing: tenantPathPrefix must look like "/app" (leading slash, no trailing slash), got "${options.tenantPathPrefix}"`,
+    );
+  }
+  const { locales } = options;
+  if (locales !== undefined) {
+    for (const locale of [locales.default, ...locales.prefixed]) {
+      if (!LOCALE_PATTERN.test(locale)) {
+        throw new Error(`host-routing: locale must look like "de" or "de-at", got "${locale}"`);
+      }
+    }
+    if (locales.prefixed.includes(locales.default)) {
+      throw new Error(
+        `host-routing: default locale "${locales.default}" is served unprefixed and must not be in prefixed`,
+      );
+    }
+  }
+}

package/packages/bundled-features/src/inbound-mail-foundation/changes.json

@@ -1,4 +1,12 @@
 [
+  {
+    "version": "0.370.0",
+    "type": "breaking",
+    "title": "The deprecated inboundMailFoundationFeature constant is removed",
+    "detail": "inboundMailFoundationFeature was kept next to createInboundMailFoundationFeature() for one release. Mount the feature by calling createInboundMailFoundationFeature().",
+    "migration": "Run bun kumiko-upgrade --apply. It replaces inboundMailFoundationFeature with createInboundMailFoundationFeature().",
+    "codemod": "scripts/codemod/feature-factory.ts"
+  },
   {
     "version": "0.366.0",
     "type": "improvement",

package/packages/bundled-features/src/inbound-mail-foundation/connect-routes.ts

@@ -23,14 +23,14 @@ import {
   InboundMailAuthMethods,
   InboundMailFoundationHandlers,
   inboundCredentialSecretKey,
-} from "./constants.js";
+} from "./constants.ts";
 import {
   inboundRefreshTokenSecretOptions,
   type OAuthAccessTokenManager,
-} from "./oauth-access-token.js";
-import { type OAuthStatePayload, signOAuthState, verifyOAuthState } from "./oauth-state.js";
-import { resolveInboundProviderForKey } from "./provider-factory.js";
-import type { InboundMailContext } from "./types.js";
+} from "./oauth-access-token.ts";
+import { type OAuthStatePayload, signOAuthState, verifyOAuthState } from "./oauth-state.ts";
+import { resolveInboundProviderForKey } from "./provider-factory.ts";
+import type { InboundMailContext } from "./types.ts";
 
 const DEFAULT_STATE_TTL_MINUTES = 15;
 const DEFAULT_CONNECT_PATH = "/api/inbound-mail/connect";

package/packages/bundled-features/src/inbound-mail-foundation/events.ts

@@ -20,7 +20,7 @@
 //     (crypto-shredding, Muster billing-foundation #800).
 
 import * as z from "zod";
-import { INBOUND_MAIL_FOUNDATION_FEATURE, InboundMailAccountStatuses } from "./constants.js";
+import { INBOUND_MAIL_FOUNDATION_FEATURE, InboundMailAccountStatuses } from "./constants.ts";
 
 // Aggregate-types für den event-store.
 export const MAIL_ACCOUNT_AGGREGATE_TYPE = "mail-account" as const;

package/packages/bundled-features/src/inbound-mail-foundation/feature.ts

@@ -47,14 +47,14 @@ import {
   createFileProviderForTenant,
   type FileStorageProvider,
 } from "@cosmicdrift/kumiko-framework/files";
-import { INBOUND_MAIL_FOUNDATION_FEATURE, INBOUND_MAIL_PROVIDER_EXTENSION } from "./constants.js";
+import { INBOUND_MAIL_FOUNDATION_FEATURE, INBOUND_MAIL_PROVIDER_EXTENSION } from "./constants.ts";
 import {
   inboundMessageEntity,
   mailAccountEntity,
   mailThreadEntity,
   seenMessageTable,
   syncCursorTable,
-} from "./entities.js";
+} from "./entities.ts";
 import {
   INBOUND_MESSAGE_AGGREGATE_TYPE,
   INBOUND_MESSAGE_RECEIVED_EVENT_QN,
@@ -72,13 +72,13 @@ import {
   MAIL_THREAD_UPDATED_EVENT_SHORT,
   mailAccountEventPayloadSchema,
   mailThreadEventPayloadSchema,
-} from "./events.js";
-import { connectAccountHandler } from "./handlers/connect-account.write.js";
-import { disconnectAccountHandler } from "./handlers/disconnect-account.write.js";
-import { ingestMessageHandler } from "./handlers/ingest-message.write.js";
-import { listAccountsQuery } from "./handlers/list-accounts.query.js";
-import { listMessagesQuery } from "./handlers/list-messages.query.js";
-import { updateAccountHandler } from "./handlers/update-account.write.js";
+} from "./events.ts";
+import { connectAccountHandler } from "./handlers/connect-account.write.ts";
+import { disconnectAccountHandler } from "./handlers/disconnect-account.write.ts";
+import { ingestMessageHandler } from "./handlers/ingest-message.write.ts";
+import { listAccountsQuery } from "./handlers/list-accounts.query.ts";
+import { listMessagesQuery } from "./handlers/list-messages.query.ts";
+import { updateAccountHandler } from "./handlers/update-account.write.ts";
 import {
   applyInboundMessageReceived,
   applyMailAccountConnected,
@@ -88,14 +88,14 @@ import {
   inboundMessagesProjectionTable,
   mailAccountsProjectionTable,
   mailThreadsProjectionTable,
-} from "./projection.js";
-import { runInboundMailRetention } from "./retention-sweep.js";
+} from "./projection.ts";
+import { runInboundMailRetention } from "./retention-sweep.ts";
 import {
   INBOUND_MAIL_TENANT_DESTROY_ARCHIVE_REASON,
   inboundMessageTenantDestroyHook,
   mailAccountTenantDestroyHook,
   mailThreadTenantDestroyHook,
-} from "./tenant-destroy-hook.js";
+} from "./tenant-destroy-hook.ts";
 
 export function createInboundMailFoundationFeature() {
   return defineFeature(
@@ -271,6 +271,3 @@ export function createInboundMailFoundationFeature() {
     { dedupeOptions: {} },
   );
 }
-
-/** @deprecated Use createInboundMailFoundationFeature(). Run `bun kumiko-upgrade --apply`. Removed in the first release after 2026-10-29. */
-export const inboundMailFoundationFeature = createInboundMailFoundationFeature();