@12-apps/routing 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,98 @@
-# Temporary Holding Version
+# @12-apps/routing
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Road routes through an ordered list of stops, and a map that draws them.
+
+- **The routing service is configuration.** A host lists the providers it
+  wants, in order: openrouteservice, OSRM, Google Routes, or its own adapter.
+  The planner keeps the first one that answers.
+- **There is always a route.** When every provider fails, times out or is not
+  configured, the answer is straight segments between the points, flagged
+  `fallback: true`. It has distances and no durations, because a time computed
+  from a straight line would be an invention.
+- **The map draws what it is given.** `RouteMap` (MapLibre GL, OpenFreeMap by
+  default) renders markers, places, numbered stops, a dashed planned line and
+  a solid travelled line. It fetches nothing, and every word and colour comes
+  from the host.
+
+## Server
+
+```ts
+import { createApiRouting, openRouteServiceProvider, osrmProvider } from "@12-apps/routing/server";
+
+const routing = createApiRouting({
+  providers: [
+    openRouteServiceProvider({ apiKey: secrets.ROUTING_ORS_API_KEY }),
+    osrmProvider({ baseUrl: secrets.ROUTING_OSRM_URL }),
+  ],
+  timeoutMs: 6_000,
+  authorize: (actor) => actor.canPlanRoutes,
+});
+
+// In-process (a job that saves a trip's route):
+const route = await routing.planRoute({ origin: shop, stops: [a, b], returnTo: shop });
+// route.geometry, route.legs[i].durationS (null on fallback), route.provider, route.fallback
+
+// Or mount `routing.routes` (one POST /route) behind your own router.
+```
+
+The planner keeps the stop order it is given; sequencing stops is the host's
+job. It never throws for provider trouble. It throws `RouteRequestError` only
+for a request that cannot be routed (fewer than two points, or an invalid
+point or 0,0) and for a provider listed twice.
+
+### Adding a provider
+
+Implement `RoutingProvider`:
+
+```ts
+const myProvider: RoutingProvider = {
+  name: "my-service",
+  async route(request, { fetch, signal }) {
+    // …call the service with `fetch` and `signal`…
+    return { ok: true, geometry, legs }; // or { ok: false, kind: "http", status }
+  },
+};
+```
+
+Add it to the host's list. Nothing else changes.
+
+### Google Routes
+
+Google's Maps Platform terms do not allow its route content to be displayed on
+a non-Google map. Do not list `googleRoutesProvider` if you draw with
+`RouteMap` over OpenFreeMap or any other non-Google basemap.
+
+## Web
+
+```tsx
+import { createWebRouting, ROUTE_MAP_COPY } from "@12-apps/routing/react";
+
+const { RouteMap } = createWebRouting({
+  copy: ROUTE_MAP_COPY["pt-BR"],
+  theme: { planned, travelled, done, next, pending, ink, paper, place, control, controlBorder },
+});
+
+<RouteMap
+  height={480}
+  markers={couriers.map((c) => ({ id: c.id, position: c.point, text: c.initials, ariaLabel: c.label, color: c.color, onSelect: () => select(c.id) }))}
+  places={[{ id: "shop", position: shop, label: "Loja" }]}
+  stops={stops}
+  planned={route?.geometry}
+  travelled={fixes}
+  fitKey={tenantSlug}
+/>;
+```
+
+- `maplibre-gl` is an optional peer dependency: install it in the web host.
+  It is imported the first time a map mounts, so a page without a map never
+  downloads it.
+- The map fits its content once, and again only when `fitKey` changes or the
+  fit control is pressed. A data refresh never moves a map someone panned.
+- Markers that overlap on screen fold into one group button. `onGroupSelect`
+  receives their ids; without that callback, the map zooms in on them.
+- No WebGL, or a style that does not load, shows `copy.mapError` with a retry.
+
+## Wiring
+
+`./manifest` declares `server: ["http"]` and `web: ["surface"]`. `http.create`
+is `createApiRouting` and `surface.create` is `createWebRouting`.

package/package.json

@@ -1,6 +1,78 @@
 {
   "name": "@12-apps/routing",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "type": "module",
+  "sideEffects": false,
+  "description": "Road routes through an ordered list of stops, with the routing service chosen by host configuration (openrouteservice, OSRM, Google Routes, or your own adapter) and a straight-line fallback when none answers, plus a MapLibre route map for web hosts that draws markers, stops, a planned and a travelled line.",
+  "exports": {
+    ".": "./src/index.ts",
+    "./server": "./src/server/index.ts",
+    "./react": "./src/react/index.ts",
+    "./manifest": "./src/manifest/index.ts",
+    "./manifest/server": "./src/manifest/server.ts",
+    "./manifest/web": "./src/manifest/web.ts",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rm -rf node_modules coverage dist",
+    "test": "node ../../scripts/vitest-with-teardown.mjs run",
+    "test:watch": "vitest watch",
+    "lint": "eslint src --max-warnings 0",
+    "check-types": "tsc --noEmit",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@12-apps/wiring": ">=1.17.0",
+    "maplibre-gl": ">=5.0.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@12-apps/wiring": {
+      "optional": true
+    },
+    "maplibre-gl": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@12-apps/eslint-config": "^1.22.0",
+    "@12-apps/typescript-config": "^1.21.0",
+    "@12-apps/wiring": "^1.17.0",
+    "@testing-library/react": "^16.3.1",
+    "@types/node": "^22.10.6",
+    "@types/react": "19.2.2",
+    "@types/react-dom": "^19.2.0",
+    "@vitejs/plugin-react": "^4.5.2",
+    "eslint": "^9.39.1",
+    "eslint-plugin-test-flakiness": "^1.4.0",
+    "jsdom": "^26.1.0",
+    "maplibre-gl": "6.13.0",
+    "react": "19.2.0",
+    "react-dom": "19.2.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/12-apps/shared-packages.git",
+    "directory": "packages/routing"
+  },
+  "files": [
+    "src",
+    "*.md",
+    "!eslint.config.js",
+    "!**/__tests__/**",
+    "!**/*.test.*"
+  ]
+}

package/src/core/fallback.ts

@@ -0,0 +1,16 @@
+/**
+ * The route every request gets when no service answered: straight segments
+ * between the points, in the order given, with great-circle distances and NO
+ * durations. A straight line is an honest picture of the order of stops; a
+ * time computed from it would be an invention, so there is none.
+ */
+
+import { haversineM, toPosition } from "./geo";
+import { waypointsOf } from "./provider";
+import type { PlannedRoute, ProviderFailure, RouteRequest } from "./types";
+
+export function straightRoute(request: RouteRequest, failures: ProviderFailure[] = []): PlannedRoute {
+  const points = waypointsOf(request);
+  const legs = points.slice(1).map((point, i) => ({ distanceM: haversineM(points[i]!, point), durationS: null }));
+  return { geometry: points.map(toPosition), legs, provider: null, fallback: true, failures };
+}

package/src/core/geo.ts

@@ -0,0 +1,97 @@
+/**
+ * The little geometry the package needs, and nothing more: the great-circle
+ * distance the fallback measures with, the distance from a point to a drawn
+ * line (how far someone is from the route they were given), and the decoder
+ * for Google's encoded polyline.
+ */
+
+import type { LngLat, Position } from "./types";
+
+const EARTH_RADIUS_M = 6_371_008.8;
+
+const toRad = (deg: number): number => (deg * Math.PI) / 180;
+
+/** Great-circle distance between two points, in metres. */
+export function haversineM(a: LngLat, b: LngLat): number {
+  const dLat = toRad(b.lat - a.lat);
+  const dLng = toRad(b.lng - a.lng);
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(a.lat)) * Math.cos(toRad(b.lat)) * Math.sin(dLng / 2) ** 2;
+  return 2 * EARTH_RADIUS_M * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+
+/** `true` for a finite WGS84 point — and never the 0,0 a missing value turns into. */
+export function isValidPoint(point: LngLat | null | undefined): point is LngLat {
+  if (!point) return false;
+  const { lng, lat } = point;
+  if (!Number.isFinite(lng) || !Number.isFinite(lat)) return false;
+  if (lng < -180 || lng > 180 || lat < -90 || lat > 90) return false;
+  return !(lng === 0 && lat === 0);
+}
+
+export const toPosition = (point: LngLat): Position => [point.lng, point.lat];
+
+const fromPosition = ([lng, lat]: Position): LngLat => ({ lng, lat });
+
+/**
+ * Shortest distance, in metres, from `point` to the polyline `line`.
+ *
+ * Each segment is projected in a local equirectangular plane around the point
+ * — exact enough at street scale (a few metres over a city), and far cheaper
+ * than the spherical formula a per-fix check would otherwise pay. An empty line
+ * is infinitely far; a one-point line is that point.
+ */
+export function distanceToLineM(point: LngLat, line: readonly Position[]): number {
+  if (line.length === 0) return Number.POSITIVE_INFINITY;
+  if (line.length === 1) return haversineM(point, fromPosition(line[0]!));
+  const cosLat = Math.cos(toRad(point.lat));
+  const project = ([lng, lat]: Position): [number, number] => [
+    toRad(lng - point.lng) * cosLat * EARTH_RADIUS_M,
+    toRad(lat - point.lat) * EARTH_RADIUS_M,
+  ];
+  let best = Number.POSITIVE_INFINITY;
+  for (let i = 1; i < line.length; i += 1) {
+    const [ax, ay] = project(line[i - 1]!);
+    const [bx, by] = project(line[i]!);
+    const dx = bx - ax;
+    const dy = by - ay;
+    const lengthSq = dx * dx + dy * dy;
+    const t = lengthSq === 0 ? 0 : Math.max(0, Math.min(1, -(ax * dx + ay * dy) / lengthSq));
+    best = Math.min(best, Math.hypot(ax + t * dx, ay + t * dy));
+  }
+  return best;
+}
+
+/**
+ * Decode an encoded polyline (precision 5) into `[lng, lat]` positions.
+ * Returns `null` on a malformed string rather than a half-decoded line.
+ */
+export function decodePolyline(encoded: string, precision = 5): Position[] | null {
+  const factor = 10 ** precision;
+  const positions: Position[] = [];
+  let index = 0;
+  let lat = 0;
+  let lng = 0;
+  const next = (): number | null => {
+    let result = 0;
+    let shift = 0;
+    let byte: number;
+    do {
+      if (index >= encoded.length) return null;
+      byte = encoded.charCodeAt(index) - 63;
+      index += 1;
+      if (byte < 0 || byte > 63) return null;
+      result |= (byte & 0x1f) << shift;
+      shift += 5;
+    } while (byte >= 0x20);
+    return result & 1 ? ~(result >> 1) : result >> 1;
+  };
+  while (index < encoded.length) {
+    const dLat = next();
+    const dLng = next();
+    if (dLat === null || dLng === null) return null;
+    lat += dLat;
+    lng += dLng;
+    positions.push([lng / factor, lat / factor]);
+  }
+  return positions;
+}

package/src/core/planner.ts

@@ -0,0 +1,106 @@
+/**
+ * The planner: try each configured provider in the host's order, keep the
+ * first route that comes back, and fall back to straight segments when none
+ * does. It never throws for a provider's trouble — the only refusals are a
+ * request that cannot be routed at all (fewer than two valid points), which is
+ * the caller's bug, and a provider list with two adapters of the same name.
+ */
+
+import { straightRoute } from "./fallback";
+import { isValidPoint } from "./geo";
+import { failureOfThrown, legCountOf, waypointsOf, type ProviderOutcome, type RoutingProvider } from "./provider";
+import type { PlannedRoute, ProviderFailure, RouteRequest } from "./types";
+
+export const DEFAULT_PROVIDER_TIMEOUT_MS = 6_000;
+
+export interface RoutePlannerConfig {
+  /** Tried in this order; the first that answers wins. Empty = always the fallback. */
+  providers: readonly RoutingProvider[];
+  /** Per-provider budget. A provider that exceeds it is a `timeout` failure. */
+  timeoutMs?: number;
+  /** The host's fetch. Defaults to the global one. */
+  fetch?: typeof fetch;
+}
+
+export type RoutePlanner = (request: RouteRequest) => Promise<PlannedRoute>;
+
+export class RouteRequestError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "RouteRequestError";
+  }
+}
+
+export function createRoutePlanner(config: RoutePlannerConfig): RoutePlanner {
+  assertUniqueNames(config.providers);
+  const timeoutMs = config.timeoutMs ?? DEFAULT_PROVIDER_TIMEOUT_MS;
+  const doFetch = config.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  return async (request) => {
+    assertRoutable(request);
+    const failures: ProviderFailure[] = [];
+    for (const provider of config.providers) {
+      const outcome = await attempt(provider, request, doFetch, timeoutMs);
+      if (outcome.ok) return { geometry: outcome.geometry, legs: outcome.legs, provider: provider.name, fallback: false, failures };
+      failures.push({
+        provider: provider.name,
+        kind: outcome.kind,
+        ...(outcome.status === undefined ? {} : { status: outcome.status }),
+        ...(outcome.detail === undefined ? {} : { detail: outcome.detail }),
+      });
+    }
+    return straightRoute(request, failures);
+  };
+}
+
+async function attempt(
+  provider: RoutingProvider,
+  request: RouteRequest,
+  doFetch: typeof fetch,
+  timeoutMs: number,
+): Promise<ProviderOutcome> {
+  const controller = new AbortController();
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  // The timer RACES the adapter rather than only aborting it: an adapter (or
+  // a host fetch wrapper) that ignores the signal must not hang the planner,
+  // or "there is always a route" stops being true.
+  const timedOut = new Promise<ProviderOutcome>((resolve) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      resolve({ ok: false, kind: "timeout" });
+    }, timeoutMs);
+  });
+  // `Promise.resolve().then` so an adapter that throws synchronously is
+  // caught like one that rejects.
+  const answered = Promise.resolve()
+    .then(() => provider.route(request, { fetch: doFetch, signal: controller.signal }))
+    .then((outcome) => (outcome.ok ? checkShape(outcome, request) : outcome))
+    .catch((error: unknown) => failureOfThrown(error, controller.signal));
+  try {
+    return await Promise.race([answered, timedOut]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/** A 2xx with the wrong number of legs, or no line, is an unreadable body. */
+function checkShape(outcome: Extract<ProviderOutcome, { ok: true }>, request: RouteRequest): ProviderOutcome {
+  if (outcome.geometry.length < 2) return { ok: false, kind: "body", detail: "empty geometry" };
+  if (outcome.legs.length !== legCountOf(request)) {
+    return { ok: false, kind: "body", detail: `expected ${legCountOf(request)} legs, got ${outcome.legs.length}` };
+  }
+  return outcome;
+}
+
+function assertRoutable(request: RouteRequest): void {
+  const points = waypointsOf(request);
+  if (points.length < 2) throw new RouteRequestError("a route needs an origin and at least one stop");
+  if (!points.every((point) => isValidPoint(point))) throw new RouteRequestError("every waypoint must be a valid point");
+}
+
+function assertUniqueNames(providers: readonly RoutingProvider[]): void {
+  const seen = new Set<string>();
+  for (const provider of providers) {
+    if (seen.has(provider.name)) throw new RouteRequestError(`provider "${provider.name}" is listed twice`);
+    seen.add(provider.name);
+  }
+}

package/src/core/provider.ts

@@ -0,0 +1,67 @@
+/**
+ * The adapter port. A routing service plugs in by implementing this — one
+ * file under `providers/`, one entry in the host's provider list — and nothing
+ * else in the package, or the host, changes.
+ *
+ * ## An adapter never throws for trouble it can name
+ *
+ * A routing service being down, slow, out of quota or unable to connect two
+ * points is the EXPECTED case the fallback exists for, not an exception. So an
+ * adapter answers a discriminated outcome; the planner walks to the next
+ * provider on any `ok: false`. A thrown error is still caught (and recorded as
+ * a `transport` failure) — a bug in an adapter must not cost the host its
+ * route — but no shipped adapter throws on purpose.
+ *
+ * ## An adapter is stateless and reads no environment
+ *
+ * Credentials and base URLs arrive in the adapter's own factory options from
+ * the HOST, which owns where secrets live. Nothing here reads `process.env`.
+ */
+
+import type { ProviderFailureKind, Position, RouteLeg, RouteRequest } from "./types";
+
+/** What the planner hands an adapter for one attempt. */
+export interface ProviderContext {
+  /** The host's fetch (egress guard, user agent, tracing). */
+  fetch: typeof fetch;
+  /** Aborts when the planner's per-provider timeout elapses. */
+  signal: AbortSignal;
+}
+
+export type ProviderOutcome =
+  | { ok: true; geometry: Position[]; legs: RouteLeg[] }
+  | { ok: false; kind: ProviderFailureKind; status?: number; detail?: string };
+
+export interface RoutingProvider {
+  /** Stable identifier, recorded on every route it plans (`"openrouteservice"`). */
+  readonly name: string;
+  route(request: RouteRequest, context: ProviderContext): Promise<ProviderOutcome>;
+}
+
+/** The points of a request in travel order: origin, every stop, the return. */
+export function waypointsOf(request: RouteRequest): RouteRequest["origin"][] {
+  return [request.origin, ...request.stops, ...(request.returnTo ? [request.returnTo] : [])];
+}
+
+/**
+ * Turn a fetch into an outcome failure, or `null` when it answered 2xx.
+ * Shared by the adapters so every one names timeouts and transport errors
+ * the same way.
+ */
+export async function failureOfResponse(response: Response): Promise<ProviderOutcome | null> {
+  if (response.ok) return null;
+  const text = await response.text().catch(() => "");
+  return { ok: false, kind: "http", status: response.status, detail: text.slice(0, 200) };
+}
+
+/** Classify an error a fetch threw: an abort is the planner's timeout. */
+export function failureOfThrown(error: unknown, signal: AbortSignal): ProviderOutcome {
+  if (signal.aborted) return { ok: false, kind: "timeout" };
+  const detail = error instanceof Error ? error.message.slice(0, 200) : undefined;
+  return { ok: false, kind: "transport", ...(detail ? { detail } : {}) };
+}
+
+/** The number of legs a request has — what a provider's answer must match. */
+export function legCountOf(request: RouteRequest): number {
+  return waypointsOf(request).length - 1;
+}

package/src/core/types.ts

@@ -0,0 +1,77 @@
+/**
+ * The vocabulary every half of `@12-apps/routing` speaks. No provider word
+ * escapes an adapter: whatever a routing service calls its pieces, the planner
+ * hands the host these shapes and nothing else.
+ */
+
+/** A point on the map, WGS84 degrees. Longitude first in every array form. */
+export interface LngLat {
+  lng: number;
+  lat: number;
+}
+
+/** `[lng, lat]` — the GeoJSON order, which is also what MapLibre draws. */
+export type Position = readonly [number, number];
+
+/**
+ * What to route: from `origin`, through every stop IN THE ORDER GIVEN, and
+ * optionally back to `returnTo`. The planner never reorders stops — sequencing
+ * is the host's decision (a dispatcher may have moved one by hand).
+ */
+export interface RouteRequest {
+  origin: LngLat;
+  stops: readonly LngLat[];
+  returnTo?: LngLat;
+}
+
+/**
+ * One leg between consecutive points: origin → stop 1, stop 1 → stop 2, …,
+ * last stop → `returnTo`. `durationS` is `null` when nobody measured it — the
+ * straight-line fallback knows a distance, never a time.
+ */
+export interface RouteLeg {
+  distanceM: number;
+  durationS: number | null;
+}
+
+/** A failure the planner recorded on its way to an answer. */
+export interface ProviderFailure {
+  provider: string;
+  kind: ProviderFailureKind;
+  /** HTTP status when the service answered with one. */
+  status?: number;
+  /** A short, non-secret explanation for logs — never shown to an end user. */
+  detail?: string;
+}
+
+export type ProviderFailureKind =
+  /** No credential or base URL was configured for this provider. */
+  | "unconfigured"
+  /** The service answered with a non-2xx status. */
+  | "http"
+  /** The request did not finish inside the planner's timeout. */
+  | "timeout"
+  /** The request never got an answer (DNS, refused, reset, egress guard). */
+  | "transport"
+  /** The service answered 2xx with a body this adapter cannot read. */
+  | "body"
+  /** The service found no route between the points. */
+  | "no-route";
+
+/**
+ * The planner's answer. Always present: when every provider failed (or none
+ * is configured) it is the straight-line fallback, flagged as such, with the
+ * failures that led there.
+ */
+export interface PlannedRoute {
+  /** The drawn line, `[lng, lat][]`, origin first. */
+  geometry: Position[];
+  /** One entry per leg, in request order. */
+  legs: RouteLeg[];
+  /** The provider that answered, or `null` for the fallback. */
+  provider: string | null;
+  /** `true` when the line is straight segments between the points. */
+  fallback: boolean;
+  /** Every provider that was tried and failed, in the order tried. */
+  failures: ProviderFailure[];
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+/**
+ * `@12-apps/routing` — the runtime-neutral core: the vocabulary, the provider
+ * port, the planner with its straight-line fallback, and the small geometry
+ * both halves share. Backend hosts import `./server`, web hosts `./react`.
+ */
+
+export type { LngLat, PlannedRoute, Position, ProviderFailure, ProviderFailureKind, RouteLeg, RouteRequest } from "./core/types";
+export type { ProviderContext, ProviderOutcome, RoutingProvider } from "./core/provider";
+export { waypointsOf } from "./core/provider";
+export { straightRoute } from "./core/fallback";
+export { createRoutePlanner, DEFAULT_PROVIDER_TIMEOUT_MS, RouteRequestError } from "./core/planner";
+export type { RoutePlanner, RoutePlannerConfig } from "./core/planner";
+export { decodePolyline, distanceToLineM, haversineM, isValidPoint } from "./core/geo";

package/src/manifest/index.ts

@@ -0,0 +1,18 @@
+/**
+ * `@12-apps/routing/manifest` — the SHARED wiring manifest.
+ *
+ * Identity and the runtime inventory: one HTTP route set (and the in-process
+ * planner beside it) for a server host, the map surface for a web host.
+ * `@12-apps/wiring` is a TYPE-ONLY devDependency; the producer assertions run
+ * in this package's own suite.
+ */
+
+import type { PackageManifest } from "@12-apps/wiring";
+
+export const routingManifest = {
+  name: "@12-apps/routing",
+  contract: 1,
+  observability: { namespace: "routing" },
+  server: ["http"],
+  web: ["surface"],
+} as const satisfies PackageManifest;

package/src/manifest/server.ts

@@ -0,0 +1,14 @@
+/**
+ * `@12-apps/routing/manifest/server` — `http.create` IS `createApiRouting`.
+ * A host that only plans in-process still binds it (the routes are inert until
+ * mounted) or declines the capability with its reason.
+ */
+
+import type { AnyServerManifest } from "@12-apps/wiring";
+
+import { createApiRouting } from "../server/index";
+
+export const routingServerManifest = {
+  name: "@12-apps/routing",
+  http: { create: createApiRouting },
+} as const satisfies AnyServerManifest;

package/src/manifest/web.ts

@@ -0,0 +1,14 @@
+/**
+ * `@12-apps/routing/manifest/web` — `surface.create` IS `createWebRouting`.
+ * No `areas`: a route map is not a page of its own, it sits inside whatever
+ * screen shows the trip, which only the host knows.
+ */
+
+import type { AnyWebManifest } from "@12-apps/wiring";
+
+import { createWebRouting } from "../react/index";
+
+export const routingWebManifest = {
+  name: "@12-apps/routing",
+  surface: { create: createWebRouting },
+} as const satisfies AnyWebManifest;