@moku-labs/web 0.6.0 → 1.0.0

package/dist/browser.d.mts

@@ -1,8 +1,10 @@
 import { EmitFn } from "@moku-labs/core";
 import { ComponentChildren, VNode } from "preact";
+import { BundledTheme, ThemeRegistrationAny } from "shiki";
+import { Pluggable, Processor } from "unified";
 
 //#region src/plugins/log/types.d.ts
-declare namespace types_d_exports$3 {
+declare namespace types_d_exports$4 {
   export { ExpectChain, LogApi, LogConfig, LogEntry, LogLevel, LogSink, LogState };
 }
 /**
@@ -142,7 +144,7 @@ type LogApi = {
   addSink(sink: LogSink): void; /** Clear all recorded entries while keeping registered sinks. */
   reset(): void;
 };
-declare namespace types_d_exports$1 {
+declare namespace types_d_exports$2 {
   export { EnvApi, EnvConfig, EnvProvider, EnvState, EnvVarSpec };
 }
 /**
@@ -153,8 +155,9 @@ declare namespace types_d_exports$1 {
  *
  * Providers are walked in array order during resolution; the first provider to
  * return a non-`undefined` (and non-empty-string) value for a key wins. `load()`
- * is called once per resolution at `onInit` time — except for live, per-request
- * sources (e.g. {@link cloudflareBindings}) which read fresh on every call.
+ * is called exactly once per resolution at `onInit` time, after which both env
+ * maps are frozen. A provider like {@link cloudflareBindings} reads `globalThis`
+ * at that single `onInit` call (not per request).
  *
  * @example
  * ```ts
@@ -225,7 +228,8 @@ type EnvConfig = {
   /**
    * Ordered list of value sources. The first provider yielding a non-`undefined`
    * (and non-empty-string) value for a key wins. The plugin's own spec default is
-   * `[]`; the framework layer supplies the working default `[dotenv(), processEnv()]`.
+   * `[]`; the consumer supplies the providers per target (`[dotenv(), processEnv()]`
+   * on Node) — only the `/browser` entry pre-wires `browserEnv()` out of the box.
    */
   providers: EnvProvider[];
   /**
@@ -334,12 +338,25 @@ declare function browserEnv(options?: {
 declare const envPlugin: import("@moku-labs/core").CorePluginInstance<"env", EnvConfig, EnvState, EnvApi>;
 //#endregion
 //#region src/config.d.ts
+/**
+ * Deployment stage. Drives content draft visibility — drafts are suppressed
+ * only in `"production"`; `"development"` and `"test"` both surface them.
+ */
+type Stage = "production" | "development" | "test";
 /**
  * Global framework configuration. Minimal by design — per-plugin config is
  * resolved via `pluginConfigs`, not merged here.
  */
-type Config$4 = {
-  /** Runtime mode. Drives log sink defaults, content draft filtering, build minify. */mode: "production" | "development";
+type Config$5 = {
+  /** Deployment stage. Drives content draft visibility (drafts hidden only in `"production"`). */stage: Stage;
+  /**
+   * Render mode — the single SSG/DATA/SPA switch, read by the router (`ctx.global`)
+   * and consumed by `build`/`spa` via `router.mode()`.
+   * - `"ssg"` static generation only (no client router emitted).
+   * - `"spa"` client-side routing only.
+   * - `"hybrid"` static HTML + client navigation overlay (default).
+   */
+  mode: "ssg" | "spa" | "hybrid";
 };
 /**
  * Framework event contract. Empty base — each plugin declares its own events
@@ -373,7 +390,7 @@ type Events = {};
  * });
  * ```
  */
-type Config$3 = {
+type Config$4 = {
   /** Human-readable site name. Used in feeds, og:site_name, and titles. MUST be non-empty. */name: string; /** Absolute base URL of the site, e.g. "https://blog.dev". MUST be a valid absolute URL (http/https). */
   url: string; /** Default author/byline for the site. Used in feeds and article author meta. */
   author: string; /** Short site description. Used in feeds, the default meta description, and og:description fallbacks. */
@@ -383,7 +400,7 @@ type Config$3 = {
  * Public API of the site plugin — read-only accessors over frozen global
  * site metadata, plus canonical URL construction.
  */
-type Api$3 = {
+type Api$4 = {
   /**
    * Returns the configured site name.
    *
@@ -444,7 +461,7 @@ type Api$3 = {
  * @file i18n plugin — public type definitions (Config + Api).
  */
 /**
- * i18n plugin configuration. Mirrors the legacy `I18nConfig` shape.
+ * i18n plugin configuration.
  *
  * `locales` and `defaultLocale` are required and validated in `onInit`. The
  * optional maps default to empty objects so every lookup method is total —
@@ -461,7 +478,7 @@ type Api$3 = {
  * }
  * ```
  */
-type Config$2 = {
+type Config$3 = {
   readonly locales: readonly string[];
   readonly defaultLocale: string;
   readonly localeNames?: Record<string, string>;
@@ -472,7 +489,7 @@ type Config$2 = {
  * Public API of the i18n plugin. Injected as `app.i18n` and reachable from
  * other plugins via `ctx.require(i18nPlugin)`.
  */
-type Api$2 = {
+type Api$3 = {
   /**
    * Returns the configured supported locales in declared order.
    *
@@ -540,8 +557,8 @@ type Api$2 = {
    */
   t(locale: string, key: string): string;
 };
-declare namespace types_d_exports$4 {
-  export { Api$1 as Api, ClientRoute, CompileInput, CompiledRoute, Config$1 as Config, ExtractRouteParams, ExtractSegmentParameter, HeadConfig$1 as HeadConfig, LayoutContext, MatcherTable, Prettify, RouteBuilder, RouteContext, RouteDefinition, RouteHandlers, RouteMap, RouteState, RouterApi, RouterConfig, RouterState, State$1 as State, TypedRoute };
+declare namespace types_d_exports$5 {
+  export { Api$2 as Api, ClientRoute, CompileInput, CompiledRoute, Config$2 as Config, ExtractApi$1 as ExtractApi, ExtractRouteParams, ExtractSegmentParameter, GenerateContext, HeadConfig$1 as HeadConfig, LayoutContext, LoadContext, MatcherTable, Prettify, RouteBuilder, RouteContext, RouteDefinition, RouteHandlers, RouteMap, RouteRequire, RouteState, RouterApi, RouterConfig, RouterState, State$2 as State, TypedRoute, Urls };
 }
 /**
  * Param contribution of a single path segment. `{name:?}` / `:name?` → optional;
@@ -580,6 +597,84 @@ interface RouteContext<S extends RouteState> {
   readonly data: S["data"];
   /** Active locale for this render. */
   readonly locale: string;
+  /**
+   * Build a link to a named route by pattern substitution — the framework delivers
+   * this on the context (same output as `app.router.toUrl`), so render/head build
+   * links with no `app`/`createUrls` reference. Works identically at build and on
+   * client navigation.
+   */
+  readonly url: (name: string, params?: Record<string, string>) => string;
+}
+/**
+ * Structural extraction of a plugin instance's public API from its `_phantom`
+ * carrier (mirrors the kernel's `ExtractApi` / spec/09 §3). Lets the loader/generator
+ * `require` resolve a plugin instance to its typed public API.
+ *
+ * @example
+ * type ContentApi = ExtractApi<typeof contentPlugin>;
+ */
+type ExtractApi$1<PluginCandidate> = PluginCandidate extends {
+  readonly _phantom: {
+    readonly api: infer PluginApi;
+  };
+} ? PluginApi : never;
+/**
+ * Generic, instance-only `require` handed to a route's `.load()` / `.generate()` —
+ * the SAME shape as the kernel's `RequireFunction` (spec/08 §7) and the build's
+ * `PhaseRequire`, so the build forwards its own `ctx.require` straight through.
+ * Resolves a plugin INSTANCE to its public API; the consumer supplies the instance
+ * (e.g. `ctx.require(contentPlugin)`), so the router never names a sibling plugin.
+ *
+ * @example
+ * const content = ctx.require(contentPlugin); // ContentApi
+ */
+type RouteRequire = <PluginCandidate extends {
+  readonly name: string;
+  readonly spec: unknown;
+  readonly _phantom: {
+    readonly config: unknown;
+    readonly state: unknown;
+    readonly api: unknown;
+    readonly events: Record<string, unknown>;
+  };
+}>(plugin: PluginCandidate) => ExtractApi$1<PluginCandidate>;
+/**
+ * Build-time context handed to a route's `.load()`. Carries the resolved path
+ * `params` and active `locale`, plus the spec's `require`/`has` so a loader pulls
+ * sibling plugin APIs the canonical way — `ctx.require(contentPlugin)` — with no
+ * module global and no router→content coupling. Loaders run ONLY at build time
+ * (never on the client), inside the build plugin's context, so `require`/`has` are
+ * always live here.
+ *
+ * @example
+ * route("/{slug}/").load((ctx) => ctx.require(contentPlugin).load(ctx.params.slug, ctx.locale));
+ */
+interface LoadContext<S extends RouteState> {
+  /** Resolved path params for this page instance. */
+  readonly params: S["params"];
+  /** Active locale this page instance is built for. */
+  readonly locale: string;
+  /** Resolve a sibling plugin instance to its public API (spec/08 §7). */
+  readonly require: RouteRequire;
+  /** Whether a plugin is registered (by name) — branch on OPTIONAL plugins. */
+  readonly has: (name: string) => boolean;
+}
+/**
+ * Build-time context handed to a route's `.generate()` — the static-param producer.
+ * Carries the active `locale` plus `require`/`has` (no `params` yet — `.generate()`
+ * PRODUCES the param sets). Same build-only guarantee as {@link LoadContext}.
+ *
+ * @example
+ * route("/{slug}/").generate(async (ctx) =>
+ *   [...(await ctx.require(contentPlugin).loadAll()).get(ctx.locale) ?? []].map((a) => ({ slug: a.computed.slug })));
+ */
+interface GenerateContext {
+  /** Active locale to enumerate param sets for. */
+  readonly locale: string;
+  /** Resolve a sibling plugin instance to its public API (spec/08 §7). */
+  readonly require: RouteRequire;
+  /** Whether a plugin is registered (by name). */
+  readonly has: (name: string) => boolean;
 }
 /**
  * Context handed to a route's `.layout()` wrapper: the render-time
@@ -615,7 +710,7 @@ interface RouteBuilder<S extends RouteState> extends RouteDefinition {
    * Attach a data loader; widens the data generic (and ONLY the data generic) so
    * `.render()`/`.head()` see its return. Path params are preserved unchanged.
    */
-  load<D>(loader: (params: S["params"], locale: string) => D | Promise<D>): RouteBuilder<{
+  load<D>(loader: (ctx: LoadContext<S>) => D | Promise<D>): RouteBuilder<{
     readonly params: S["params"];
     readonly data: Awaited<D>;
   }>;
@@ -629,19 +724,10 @@ interface RouteBuilder<S extends RouteState> extends RouteDefinition {
   layout(component: (ctx: LayoutContext<S>, children: ComponentChildren) => VNode): RouteBuilder<S>;
   /** Attach the page render handler. */
   render(handler: (ctx: RouteContext<S>) => VNode): RouteBuilder<S>;
-  /**
-   * Attach the client-side validation gate: parse the raw `unknown` fetched from
-   * the persisted data file back into this route's data type `S["data"]`. Runs at
-   * the trust boundary before `render` on the client (and MUST return `S["data"]`,
-   * so a mismatched schema is a compile error). Throw inside it to reject malformed
-   * data — `spa` then falls back to HTML-over-fetch. Use a hand guard or any
-   * Standard-Schema validator (zod/valibot/arktype).
-   */
-  parse(handler: (raw: unknown) => S["data"]): RouteBuilder<S>;
   /** Attach the head/SEO handler. */
   head(handler: (ctx: RouteContext<S>) => HeadConfig$1): RouteBuilder<S>;
-  /** Attach a static-generation param producer. */
-  generate(handler: (locale: string) => S["params"][] | Promise<S["params"][]>): RouteBuilder<S>;
+  /** Attach a static-generation param producer (receives a {@link GenerateContext}). */
+  generate(handler: (ctx: GenerateContext) => S["params"][] | Promise<S["params"][]>): RouteBuilder<S>;
   /**
    * Attach an arbitrary metadata bag. The bag MUST be JSON-serializable: it is
    * projected verbatim into `clientManifest()` and shipped to the browser.
@@ -654,18 +740,16 @@ interface RouteBuilder<S extends RouteState> extends RouteDefinition {
 }
 /** Build-only handler bag captured by a `RouteBuilder` (consumed by `build` via `manifest()`). */
 interface RouteHandlers {
-  /** Data loader. */
-  readonly load?: (params: Record<string, string>, locale: string) => unknown;
+  /** Data loader (receives a {@link LoadContext}: params + locale + require/has). */
+  readonly load?: (ctx: LoadContext<RouteState>) => unknown;
   /** Layout wrapper (ctx-aware): frames the page in persistent chrome. SSG-only. */
   readonly layout?: (ctx: LayoutContext<RouteState>, children: ComponentChildren) => VNode;
   /** Page renderer. */
   readonly render?: (ctx: RouteContext<RouteState>) => VNode;
-  /** Client-side validation gate: `unknown` (fetched JSON) → the route's data type, or throw. */
-  readonly parse?: (raw: unknown) => unknown;
   /** Head/SEO producer. */
   readonly head?: (ctx: RouteContext<RouteState>) => HeadConfig$1;
-  /** Static-generation param producer. */
-  readonly generate?: (locale: string) => unknown[] | Promise<unknown[]>;
+  /** Static-generation param producer (receives a {@link GenerateContext}). */
+  readonly generate?: (ctx: GenerateContext) => unknown[] | Promise<unknown[]>;
   /** JSON serializer. */
   readonly toJson?: (ctx: RouteContext<RouteState>) => unknown;
   /** Output file-path producer. */
@@ -689,28 +773,45 @@ interface RouteDefinition {
  * base (erased) `RouteDefinition`; this is the documented generic-erasure boundary.
  */
 type RouteMap = Record<string, RouteDefinition>;
+/**
+ * A pure, app-free URL builder over a route map (the return type of `createUrls`).
+ * `toUrl` builds a route's path by name + params via pattern substitution — it needs
+ * NO running app, router instance, base URL, or i18n: just the route map the consumer
+ * already holds at module scope. Works identically at build, on client navigation,
+ * and inside hydrated islands. Reuses the SAME `buildUrl` as the runtime `RouterApi`,
+ * so the helper and the API can never diverge.
+ *
+ * @example
+ * const url = createUrls(routes);
+ * url.toUrl("article", { lang: "en", slug: "hello" }); // "/en/hello/"
+ */
+interface Urls<T extends RouteMap> {
+  /**
+   * Build a route's URL path from its name and params. The name is typed to the
+   * route map's keys — only declared routes are accepted.
+   *
+   * @param name - Route name key from the map (e.g. `"home"`, `"article"`).
+   * @param params - Path params to substitute into the pattern. Defaults to `{}`.
+   * @returns The resolved relative URL path.
+   * @throws {Error} If `name` is not present in the route map.
+   * @example
+   * url.toUrl("home", { lang: "en" }); // "/en/"
+   */
+  toUrl<K extends keyof T & string>(name: K, params?: Record<string, string>): string;
+}
 /**
  * Configuration for the router plugin.
  *
  * @remarks
- * `routes` is an OPAQUE carrier at the config boundary — the framework `Config`
- * generic erases the per-route element types (spec/05 §8, spec/09 §4). Downstream
- * plugins read the typed route set via `ctx.require(routerPlugin).manifest()`.
+ * `routes` is the declarative route map — registered the normal config way via
+ * `createApp({ pluginConfigs: { router: { routes } } })` and compiled into the matcher
+ * table in the router's `onInit`. An `import * as routes` namespace is a valid value. It is
+ * the SOLE registration path: omitting it leaves the matcher table empty, so every read
+ * (`match`/`toUrl`/`entries`/…) throws. The render `mode` is NOT here — it is a GLOBAL
+ * framework option (`createApp({ config: { mode } })`), read by the router via `ctx.global`.
  */
 type RouterConfig = {
-  /**
-   * Named route definitions. Element type erases to the base `RouteDefinition`
-   * at this config boundary; per-route call-site types are preserved only through
-   * `defineRoutes()` + `route()` at the consumer and re-exposed via `manifest()`.
-   */
-  routes: RouteMap;
-  /**
-   * Render mode for URL/file resolution. Defaults to `"hybrid"`.
-   * - `"ssg"` static generation only (no client router emitted).
-   * - `"spa"` client-side routing only.
-   * - `"hybrid"` static HTML + client navigation overlay.
-   */
-  mode?: "ssg" | "spa" | "hybrid";
+  /** Declarative route map (route name → `route(...)`); compiled at init. An `import * as` namespace works. */readonly routes?: RouteMap;
 };
 /** A resolved route exposing URL utilities with typed params (port of legacy TypedRoute). */
 interface TypedRoute<TParams = Record<string, string>> {
@@ -759,15 +860,14 @@ interface MatcherTable {
   readonly byName: ReadonlyMap<string, CompiledRoute>;
 }
 /**
- * Router plugin state. `createState` runs with minimal context and returns a
- * mutable holder whose `table` is `null` until `onInit` (which has full context)
- * compiles and assigns it. Keeps all mutable state in `ctx.state` (no singletons).
+ * Router plugin state — a mutable holder whose `table` is `null` until the router's
+ * `onInit` compiles `config.routes`. The render `mode` is NOT stored here; it is read
+ * from the global framework config via the API context. Keeps all mutable state in
+ * `ctx.state` (no singletons).
  */
 interface RouterState {
-  /** Compiled matcher table; `null` until `onInit` assigns it. */
+  /** Compiled matcher table; `null` until `onInit` compiles `config.routes`. */
   table: MatcherTable | null;
-  /** Resolved render mode (single source of truth; set in `onInit`). Defaults `"hybrid"`. */
-  mode: "ssg" | "spa" | "hybrid";
 }
 /** Plain-data input to `compileRoutes` — resolved DATA only, never the plugin ctx. */
 interface CompileInput {
@@ -800,7 +900,7 @@ interface ClientRoute {
   /** Route metadata bag from `.meta()`. MUST be JSON-serializable. */
   readonly meta: Record<string, unknown>;
 }
-/** Public API exposed via `ctx.require(routerPlugin)`. */
+/** Public API exposed via `ctx.require(routerPlugin)` and `app.router`. */
 type RouterApi = {
   /**
    * Match a pathname against the compiled route table (specificity-sorted).
@@ -839,7 +939,7 @@ type RouterApi = {
    *
    * @returns Read-only array of the typed route definitions, in declaration order.
    * @example
-   * for (const def of ctx.require(routerPlugin).manifest()) { def._handlers.load?.({}, "en"); }
+   * for (const def of ctx.require(routerPlugin).manifest()) def._handlers.render?.(routeContext);
    */
   manifest(): readonly RouteDefinition[];
   /**
@@ -865,13 +965,13 @@ type RouterApi = {
   mode(): "ssg" | "spa" | "hybrid";
 };
 /** Re-export under the canonical `Config` name for the plugin-types barrel. */
-type Config$1 = RouterConfig;
+type Config$2 = RouterConfig;
 /** Re-export under the canonical `State` name for the plugin-types barrel. */
-type State$1 = RouterState;
+type State$2 = RouterState;
 /** Re-export under the canonical `Api` name for the plugin-types barrel. */
-type Api$1 = RouterApi;
-declare namespace types_d_exports$2 {
-  export { Api, ArticleMeta, Config, HeadConfig, HeadDefaults, HeadElement, ResolvedRoute, State };
+type Api$2 = RouterApi;
+declare namespace types_d_exports$3 {
+  export { Api$1 as Api, ArticleMeta, Config$1 as Config, HeadConfig, HeadDefaults, HeadElement, ResolvedRoute, State$1 as State };
 }
 /**
  * @file head plugin — type definitions skeleton
@@ -887,7 +987,7 @@ declare namespace types_d_exports$2 {
  * const config: Config = { titleTemplate: "%s — Moku" };
  * ```
  */
-type Config = {
+type Config$1 = {
   /** Title template applied to per-route titles. `%s` is replaced by the route title. */titleTemplate?: string; /** Default Open Graph image URL used when a route does not supply one. */
   defaultOgImage?: string; /** Default Twitter card type emitted when og/twitter content is present. */
   twitterCard?: "summary" | "summary_large_image"; /** Default Twitter site handle (e.g. `"@moku_labs"`) emitted as `twitter:site`. */
@@ -905,7 +1005,7 @@ type Config = {
  * const state: State = { defaults: null };
  * ```
  */
-type State = {
+type State$1 = {
   /** Normalized head defaults, assigned once in `onInit` (initially `null`). */defaults: HeadDefaults | null;
 };
 /**
@@ -999,7 +1099,7 @@ type ResolvedRoute = {
  * const html: string = api.render(route, data);
  * ```
  */
-type Api = {
+type Api$1 = {
   /**
    * Compose the final `<head>` inner HTML for a route. Pulled synchronously by `build`.
    *
@@ -1013,7 +1113,7 @@ type Api = {
    */
   render(route: ResolvedRoute, data: unknown): string;
 };
-declare namespace types_d_exports$5 {
+declare namespace types_d_exports$6 {
   export { COMPONENT_HOOK_NAMES, ComponentContext, ComponentDef, ComponentHooks, ComponentInstance, ExtractApi, PageData, ResolvedSpaConfig, SpaApi, SpaConfig, SpaContext, SpaDataReader, SpaEmitFunction, SpaEvents, SpaKernel, SpaKernelDeps, SpaRequire, SpaState };
 }
 /** Payload map for the events `spa` emits, used to type the kernel's `emit` closure. */
@@ -1214,11 +1314,11 @@ interface SpaKernelDeps {
   /** Router plugin API — used for client-side route matching (`match`) + the resolved `mode`. */
   router: RouterApi;
   /** Head plugin API — its pure compose is reused for client head-sync. */
-  head: Api;
+  head: Api$1;
   /**
    * The OPTIONAL `data` reader. Present only when the `data` plugin is composed.
    * When present (and `router.mode() !== "ssg"`), navigation first tries the client
-   * DATA path (match → `dataAt(path)` → `route.parse` → `route.render`); otherwise
+   * DATA path (match → `dataAt(path)` → `route.render`); otherwise
    * it always uses HTML-over-fetch.
    */
   dataAt?: SpaDataReader;
@@ -1341,7 +1441,7 @@ type SpaApi = {
  * });
  * ```
  */
-declare const sitePlugin: import("@moku-labs/core").PluginInstance<"site", Config$3, Record<string, never>, Api$3, {}> & Record<never, never>;
+declare const sitePlugin: import("@moku-labs/core").PluginInstance<"site", Config$4, Record<string, never>, Api$4, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/i18n/index.d.ts
 /**
@@ -1363,7 +1463,7 @@ declare const sitePlugin: import("@moku-labs/core").PluginInstance<"site", Confi
  * });
  * ```
  */
-declare const i18nPlugin: import("@moku-labs/core").PluginInstance<"i18n", Config$2, Record<string, never>, Api$2, {}> & Record<never, never>;
+declare const i18nPlugin: import("@moku-labs/core").PluginInstance<"i18n", Config$3, Record<string, never>, Api$3, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/router/builders/route-builder.d.ts
 /**
@@ -1378,7 +1478,7 @@ declare const i18nPlugin: import("@moku-labs/core").PluginInstance<"i18n", Confi
  * @example
  * ```ts
  * route("/{lang:?}/{slug}/")
- *   .load(({ slug }) => loadArticle(slug))
+ *   .load((ctx) => loadArticle(ctx.params.slug))
  *   .render((ctx) => <Article a={ctx.data} />)
  *   .head((ctx) => ({ title: ctx.data.title }));
  * ```
@@ -1396,31 +1496,46 @@ declare function route<P extends string>(pattern: P): RouteBuilder<RouteState<P>
  * ```
  */
 declare function defineRoutes<T extends RouteMap>(routes: T): T;
+/**
+ * Build a pure, app-free URL builder from a route map. `toUrl(name, params)` resolves
+ * a route's path by pattern substitution using the SAME `buildUrl` as the runtime
+ * `RouterApi.toUrl`, so the helper and the API can never diverge. It needs no running
+ * app, router instance, base URL, or i18n — just the route map the consumer already
+ * holds at module scope. So components, layouts, and hydrated islands import it
+ * directly: no `app.router` reference, no manual "bind", no module global, no
+ * "not bound" guard, and no createApp ↔ routes cycle.
+ *
+ * @param routes - The route map (typically the value returned by {@link defineRoutes}).
+ * @returns A {@link Urls} builder whose `toUrl` accepts only this map's route names.
+ * @example
+ * ```ts
+ * const url = createUrls(routes);
+ * url.toUrl("article", { lang: "en", slug: "hello" }); // "/en/hello/"
+ * ```
+ */
+declare function createUrls<T extends RouteMap>(routes: T): Urls<T>;
 //#endregion
 //#region src/plugins/router/index.d.ts
 /**
  * Router plugin — typed, named route definitions with locale-aware URL generation
- * and matching. Author routes with {@link route} + {@link defineRoutes}. Depends
- * on site (base URL) and i18n (locales).
+ * and matching. Author routes with {@link route}, then register them the normal config
+ * way via `pluginConfigs.router.routes` (compiled at init). Depends on site (base URL)
+ * and i18n (locales).
  *
- * @example Define routes and choose a render mode
+ * @example Register routes via config, then start/build
  * ```ts
+ * import * as routes from "./routes";
  * const app = createApp({
- *   pluginConfigs: {
- *     router: {
- *       routes: defineRoutes({
- *         home: route("/"),
- *         article: route("/blog/{slug}/")
- *       }),
- *       mode: "hybrid" // "ssg" | "spa" | "hybrid" (default)
- *     }
- *   }
+ *   config: { mode: "hybrid" },               // render mode is GLOBAL config
+ *   pluginConfigs: { router: { routes } }     // declarative route map (a namespace works)
  * });
+ * await app.build.run();    // or: await app.start();  — routes compiled at init
  * ```
  */
 declare const routerPlugin: import("@moku-labs/core").PluginInstance<"router", RouterConfig, RouterState, RouterApi, {}> & {
   route: typeof route;
   defineRoutes: typeof defineRoutes;
+  createUrls: typeof createUrls;
 };
 //#endregion
 //#region src/plugins/head/primitives.d.ts
@@ -1495,6 +1610,8 @@ declare function feedLink(title: string, url: string, type?: string): HeadElemen
  * modified times, author, section, tags, plus a JSON-LD `Article` block and canonical.
  *
  * @param articleMeta - Article metadata (title, description, author, dates, tags, image…).
+ *   `image`, when present, is pushed to `og:image` verbatim and must therefore be
+ *   an absolute URL (this helper does not resolve relative paths against the site).
  * @param canonicalUrl - The article's canonical absolute URL.
  * @returns An ordered array of serializable head elements.
  * @example buildArticleHead({ title: "Hi", author: "A", published: "2026-01-01" }, "https://x/p")
@@ -1521,7 +1638,7 @@ declare function buildArticleHead(articleMeta: ArticleMeta, canonicalUrl: string
  * });
  * ```
  */
-declare const headPlugin: import("@moku-labs/core").PluginInstance<"head", Config, State, Api, {}> & {
+declare const headPlugin: import("@moku-labs/core").PluginInstance<"head", Config$1, State$1, Api$1, {}> & {
   meta: typeof meta;
   og: typeof og;
   twitter: typeof twitter;
@@ -1588,7 +1705,7 @@ declare const spaPlugin: import("@moku-labs/core").PluginInstance<"spa", SpaConf
     el: Element;
   };
 }> & Record<never, never>;
-declare namespace types_d_exports {
+declare namespace types_d_exports$1 {
   export { DataConfig, DataEntry, DataProvider, DataState, DataWriteSummary };
 }
 /**
@@ -1597,13 +1714,13 @@ declare namespace types_d_exports {
  * The `data` plugin is the **agnostic data provider** for the SSG→DATA→SPA pattern.
  * It owns ONE thing: the contract `page path → persisted JSON file`. It knows
  * NOTHING about what the data *is* — no domain types appear here. A route decides
- * its own data shape (`load`'s return) and its own validation (`route.parse`).
+ * its own data shape (`load`'s return).
  *
  *  - **Node (build):** `write(entries)` persists one JSON file per page, keyed by
  *    the page's URL via {@link DataProvider.fileFor}. `build` supplies the entries
  *    (it already expanded the routes), so there is no duplicate expansion here.
- *  - **Browser (runtime):** `at(path)` fetches + caches that file as `unknown`; the
- *    route's `parse` validates it into the route's data type before `render`.
+ *  - **Browser (runtime):** `at(path)` fetches + caches that file as `unknown`, which
+ *    the route uses directly as `ctx.data` in `render`.
  *
  * The Node-only file-writing code (`node:fs`) is isolated behind a lazy `import()`
  * inside `write()`, so composing `data` in a browser app keeps the bundle free of
@@ -1625,8 +1742,8 @@ type DataConfig = {
   outputDir: string;
   /**
    * READ side (browser): site-root-relative URL the client fetches the per-page
-   * JSON from. A different domain from {@link DataConfig.outputDir} (a filesystem
-   * path); keep consistent (`"/" + trim(outputDir) + "/"`). Default `"/_data/"`.
+   * JSON from. The URL-space mirror of {@link DataConfig.outputDir} (a filesystem
+   * path); keep them consistent (`"/" + trim(outputDir) + "/"`). Default `"/_data/"`.
    */
   baseUrl: string;
 };
@@ -1668,15 +1785,15 @@ interface DataState {
  * // Node build (build supplies the entries it already expanded):
  * await app.data.write([{ path: "/en/hello/", data: article }]);
  *
- * // Browser (inside spa nav): fetch the page's data, then route.parse validates it:
- * const raw = await app.data.at("/en/hello/"); // unknown | null
+ * // Browser (inside spa nav): fetch the page's data, used directly as ctx.data:
+ * const raw = await app.data.at("/en/hello/"); // unknown | null (null on failure)
  * ```
  */
 type DataProvider = {
   /**
    * READ (browser) — fetch (and cache) the persisted data for a page path from
-   * `config.baseUrl`. Returns the raw parsed JSON as `unknown` (the caller's
-   * `route.parse` validates it), or `null` if the fetch/parse fails.
+   * `config.baseUrl`. Returns the raw parsed JSON as `unknown`, used directly as
+   * the route's `ctx.data`; returns `null` if the fetch or JSON parse fails.
    *
    * @param path - The page URL path (e.g. `/en/hello/`).
    * @returns The page's raw data, or `null` on failure.
@@ -1722,18 +1839,316 @@ type DataProvider = {
  * @example
  * ```ts
  * // Node build: `build` calls app.data.write(...) during its pages phase when
- * // router.mode !== "ssg". Just compose the plugin:
+ * // router.mode() !== "ssg". Compose the plugin + set the global render mode:
+ * import * as routes from "./routes";
  * const app = createApp({
  *   plugins: [dataPlugin, contentPlugin, buildPlugin],
- *   pluginConfigs: { content: { contentDir: "./content" }, router: { routes, mode: "hybrid" } }
+ *   config: { mode: "hybrid" },
+ *   pluginConfigs: { content: { providers: [fileSystemContent({ contentDir: "./content" })] }, router: { routes } }
  * });
- * await app.start();
- * await app.build.run();   // writes HTML + per-page data sidecars
+ * await app.build.run();   // writes HTML + per-page data sidecars (routes compiled at init)
  *
  * // Browser app: compose `dataPlugin` too; spa fetches via app.data.at(path) on nav.
  * ```
  */
 declare const dataPlugin: import("@moku-labs/core").PluginInstance<"data", DataConfig, DataState, DataProvider, {}> & Record<never, never>;
+declare namespace types_d_exports {
+  export { Api, Article, ArticleCard, ComputedFields, Config, ContentApiContext, ContentEvents, ContentProvider, ContentProviderState, FileSystemContentOptions, Frontmatter, State };
+}
+/**
+ * YAML frontmatter parsed from each article file.
+ *
+ * @example
+ * ```ts
+ * { title: "Hello", date: "2026-01-15", description: "Intro", tags: [], language: "en" }
+ * ```
+ */
+type Frontmatter = {
+  /** Article title. Required. */title: string; /** ISO 8601 date string, e.g. "2026-01-15". Required. */
+  date: string; /** Short summary used in cards, feeds, and meta description. Required. */
+  description: string; /** Topic tags. Required (may be empty array). */
+  tags: string[]; /** Source language code of this file. Required. */
+  language: string; /** Draft flag. Excluded from output in production mode. Defaults to false. */
+  draft?: boolean; /** Author name. Falls back to the provider's defaultAuthor when omitted. */
+  author?: string;
+};
+/**
+ * Fields computed by the pipeline (not authored in frontmatter).
+ *
+ * @example
+ * ```ts
+ * { slug: "hello", readingTime: 1, contentId: "hello", status: "published", wordCount: 42 }
+ * ```
+ */
+type ComputedFields = {
+  /** Article directory name. */slug: string; /** Reading time in minutes (ceiling, minimum 1). */
+  readingTime: number; /** Stable content identifier (slug by default). */
+  contentId: string; /** Derived publication status. */
+  status: "published" | "draft"; /** Word count from the source body. */
+  wordCount: number;
+};
+/**
+ * A fully processed, render-ready article.
+ *
+ * @example
+ * ```ts
+ * { frontmatter, computed, html: "<p>…</p>", locale: "en", isFallback: false, url: "/en/hello/" }
+ * ```
+ */
+type Article = {
+  /** Parsed frontmatter. */frontmatter: Frontmatter; /** Pipeline-computed metadata. */
+  computed: ComputedFields; /** Sanitized rendered HTML body. */
+  html: string; /** Locale this Article instance represents (the requested locale, even on fallback). */
+  locale: string; /** True when the default-locale file was used because the requested locale was missing. */
+  isFallback: boolean; /** Canonical URL for this article in this locale. */
+  url: string;
+};
+/**
+ * Lightweight projection of Article for cards/lists.
+ *
+ * @example
+ * ```ts
+ * { contentId: "hello", status: "published", title: "Hello", date: "2026-01-15", description: "Intro", tags: [], readingTime: 1, url: "/en/hello/" }
+ * ```
+ */
+type ArticleCard = {
+  /** Stable content identifier. */contentId: string; /** Derived publication status. */
+  status: "published" | "draft"; /** Article title. */
+  title: string; /** ISO 8601 date string. */
+  date: string; /** Short summary. */
+  description: string; /** Topic tags. */
+  tags: string[]; /** Reading time in minutes. */
+  readingTime: number; /** Canonical URL for this article in this locale. */
+  url: string;
+};
+/**
+ * A pluggable content SOURCE. The shell calls these to read articles; whether content
+ * is read from the filesystem (Node) or some other source is chosen by which provider
+ * you compose — exactly like `env` providers (`dotenv`/`processEnv` vs `browserEnv`).
+ * The shell adds locale fallback, draft filtering, sorting, caching, and events on top.
+ *
+ * @example
+ * ```ts
+ * const provider = fileSystemContent({ contentDir: "./content" });
+ * ```
+ */
+interface ContentProvider {
+  /** Human-readable provider name, used in diagnostics. */
+  readonly name: string;
+  /** Source directory surfaced via `api.contentDir()` (filesystem providers; "" otherwise). */
+  readonly contentDir: string;
+  /**
+   * Discover the article slugs this provider can supply.
+   *
+   * @returns The provider's slug list.
+   */
+  slugs(): Promise<readonly string[]>;
+  /**
+   * Read + render ONE article for a file-locale; `null` if this provider has no such file.
+   *
+   * @param slug - Article directory name.
+   * @param fileLocale - Locale whose source file is read.
+   * @param outLocale - Locale the resulting Article represents (the requested locale).
+   * @param isFallback - Whether this resolution used the default-locale fallback.
+   * @returns The constructed Article, or `null` when absent.
+   */
+  readArticle(slug: string, fileLocale: string, outLocale: string, isFallback: boolean): Promise<Article | null>;
+  /**
+   * Render a standalone Markdown string to HTML through the provider's pipeline.
+   *
+   * @param markdown - Raw Markdown source.
+   * @returns The rendered HTML.
+   */
+  render(markdown: string): Promise<string>;
+  /**
+   * Optional dev hook: drop cached discovery so stale paths are re-read next time.
+   *
+   * @param paths - Stale file paths.
+   */
+  invalidate?(paths: readonly string[]): void;
+}
+/**
+ * Options for the node filesystem provider {@link ContentProvider} `fileSystemContent`.
+ * These are the markdown-pipeline + source concerns that used to live on the content
+ * plugin config; they now belong to the provider you compose.
+ *
+ * @example
+ * ```ts
+ * fileSystemContent({ contentDir: "./content", shikiTheme: "github-dark", defaultAuthor: "Ada" });
+ * ```
+ */
+type FileSystemContentOptions = {
+  /** Absolute or project-relative path to the content directory. */contentDir: string;
+  /**
+   * SECURITY GATE. When false (the default), rehype-sanitize runs as the final
+   * pipeline step. Set true ONLY for fully author-controlled Markdown.
+   */
+  trustedContent?: boolean; /** Additional remark plugins, concatenated AFTER framework defaults. Defaults to []. */
+  extraRemarkPlugins?: readonly Pluggable[]; /** Additional rehype plugins, concatenated after custom transforms, before Shiki + sanitize. Defaults to []. */
+  extraRehypePlugins?: readonly Pluggable[];
+  /**
+   * Shiki theme for syntax highlighting: a bundled theme NAME (default "github-dark")
+   * or a custom `ThemeRegistration` object. Passed straight through to `@shikijs/rehype`.
+   */
+  shikiTheme?: BundledTheme | ThemeRegistrationAny; /** Author applied to articles whose frontmatter omits author. Defaults to undefined. */
+  defaultAuthor?: string;
+};
+/**
+ * Internal mutable state of the filesystem provider: the lazy unified processor and
+ * the discovery caches. Owned by the provider closure, never by the plugin shell.
+ *
+ * @example
+ * ```ts
+ * { processor: null, slugs: null, dirtyPaths: new Set() }
+ * ```
+ */
+type ContentProviderState = {
+  /** Lazily-created unified processor singleton. null until first render()/readArticle(). */processor: Processor | null; /** Discovered, sorted slug list cached after first disk scan. null until first discovery. */
+  slugs: string[] | null; /** Paths marked stale by invalidate(); next discovery re-reads only these. Starts empty. */
+  dirtyPaths: Set<string>;
+};
+/**
+ * Configuration for the content plugin (shell).
+ *
+ * @example
+ * ```ts
+ * { providers: [fileSystemContent({ contentDir: "./content" })] }
+ * ```
+ */
+type Config = {
+  /**
+   * Ordered content sources. Compose at least one (e.g. `fileSystemContent(...)` on
+   * Node). The first provider that supplies an article for a slug+locale wins;
+   * `slugs()` are unioned. The plugin's own spec default is `[]` (a build must supply one).
+   */
+  providers: ContentProvider[];
+};
+/**
+ * Internal mutable state for the content plugin shell: the locale-keyed article cache.
+ *
+ * @example
+ * ```ts
+ * { articles: new Map() }
+ * ```
+ */
+type State = {
+  /** Article cache keyed locale -> (slug -> Article). Starts empty. */articles: Map<string, Map<string, Article>>;
+};
+/**
+ * Notification-only events emitted by the content plugin.
+ *
+ * @example
+ * ```ts
+ * emit("content:ready", { locales: ["en"], articleCount: 3 });
+ * ```
+ */
+type ContentEvents = {
+  /** All articles loaded across locales. */"content:ready": {
+    locales: readonly string[];
+    articleCount: number;
+  }; /** Article paths marked stale for dev rebuild. */
+  "content:invalidated": {
+    paths: readonly string[];
+  };
+};
+/**
+ * Kernel-free domain context handed to createContentApi by the wiring harness.
+ * Carries the shell state (article cache), global flag, emit, the i18n-derived
+ * locale helpers, and the resolved content {@link ContentProvider} — so api.ts stays
+ * free of createPlugin/ctx AND of any node/pipeline import.
+ *
+ * @example
+ * ```ts
+ * const apiContext: ContentApiContext = { state, global, emit, locales, defaultLocale, provider };
+ * ```
+ */
+type ContentApiContext = {
+  /** Mutable shell state (article cache). */state: State; /** Global framework configuration (deployment stage). */
+  global: {
+    stage: Stage;
+  }; /** Emit a registered content event. */
+  emit: <K extends keyof ContentEvents>(event: K, payload: ContentEvents[K]) => void; /** Active locale codes from i18n. */
+  locales: () => readonly string[]; /** Default locale code from i18n (fallback source). */
+  defaultLocale: () => string; /** The resolved content source (merged from `config.providers`). */
+  provider: ContentProvider;
+};
+/**
+ * Public API for the content plugin.
+ *
+ * @example
+ * ```ts
+ * const map = await app.content.loadAll();
+ * ```
+ */
+type Api = {
+  /**
+   * Load every article across every active locale, returning a locale-keyed
+   * map of date-descending Article arrays. Emits content:ready.
+   */
+  loadAll(): Promise<Map<string, Article[]>>;
+  /**
+   * Resolve and render a single article for one locale, with locale fallback.
+   *
+   * @param slug - Article directory name.
+   * @param locale - Requested locale code.
+   */
+  load(slug: string, locale: string): Promise<Article>;
+  /**
+   * Render a raw Markdown string to HTML through the full pipeline.
+   *
+   * @param md - Raw Markdown source.
+   */
+  renderMarkdown(md: string): Promise<string>;
+  /**
+   * Mark file paths stale for incremental dev rebuilds. Emits content:invalidated.
+   *
+   * @param paths - File paths to invalidate.
+   */
+  invalidate(paths: readonly string[]): void;
+  /**
+   * Project a full Article to a lightweight ArticleCard for list/grid rendering.
+   *
+   * @param article - The source article.
+   */
+  articleToCard(article: Article): ArticleCard;
+  /**
+   * The configured content source directory (e.g. `"./content"`), from the first
+   * provider. Lets the build copy each article's co-located assets
+   * (`<contentDir>/<slug>/images/`) into the output.
+   */
+  contentDir(): string;
+};
+//#endregion
+//#region src/plugins/content/index.d.ts
+/**
+ * Content plugin (shell) — provider-driven locale-keyed Article model. Orchestration
+ * (locale fallback, draft filtering, sort, caching, events) lives here; source I/O +
+ * the Markdown pipeline live in a {@link ContentProvider} you compose (like `env`
+ * providers). The shell imports zero node code, so `contentPlugin` is browser-safe.
+ * Depends on i18n; emits `content:ready` and `content:invalidated`.
+ *
+ * @example Compose the node filesystem provider with a content dir + Shiki theme
+ * ```ts
+ * import { contentPlugin, fileSystemContent } from "@moku-labs/web";
+ * const app = createApp({
+ *   plugins: [contentPlugin],
+ *   pluginConfigs: {
+ *     content: {
+ *       providers: [fileSystemContent({ contentDir: "./content", shikiTheme: "github-dark", defaultAuthor: "Ada" })]
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare const contentPlugin: import("@moku-labs/core").PluginInstance<"content", Config, State, Api, {
+  "content:ready": {
+    locales: readonly string[];
+    articleCount: number;
+  };
+  "content:invalidated": {
+    paths: readonly string[];
+  };
+}> & Record<never, never>;
 //#endregion
 //#region src/plugins/log/index.d.ts
 /**
@@ -1758,27 +2173,24 @@ declare const logPlugin: import("@moku-labs/core").CorePluginInstance<"log", Log
  *
  * @param options - Optional configuration:
  *  - `pluginConfigs` — per-plugin overrides, keyed by plugin name.
- *  - `config` — global framework config (e.g. `{ mode: "development" }`).
+ *  - `config` — global framework config (e.g. `{ mode: "spa" }`).
  *  - `plugins` — extra plugins (e.g. `dataPlugin` or your own) merged into the app and its type.
  *  - `onReady` / `onError` / `onStart` / `onStop` — lifecycle callbacks.
  * @returns The initialized app: `start()`, `stop()`, every plugin's API, and `log`.
  * @example
  * ```ts
  * // Client SPA — env works with no wiring (browserEnv is the default provider):
- * const app = createApp({
- *   plugins: [dataPlugin],
- *   pluginConfigs: {
- *     router: { mode: "spa", routes: defineRoutes({ home: route("/"), post: route("/blog/{slug}/") }) }
- *   }
- * });
- * await app.start();
+ * import * as routes from "./routes";
+ * const app = createApp({ config: { mode: "spa" }, pluginConfigs: { router: { routes } } });
+ * await app.start();             // routes compiled at init from config
  * app.env.get("PUBLIC_API_URL"); // resolved from import.meta.env
  * ```
  */
-declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs/core").AnyPluginInstance[] = readonly []>(options?: import("@moku-labs/core").CreateAppOptions<Config$4, Events, (import("@moku-labs/core").PluginInstance<"site", Config$3, Record<string, never>, Api$3, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"i18n", Config$2, Record<string, never>, Api$2, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"router", RouterConfig, RouterState, RouterApi, {}> & {
+declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs/core").AnyPluginInstance[] = readonly []>(options?: import("@moku-labs/core").CreateAppOptions<Config$5, Events, (import("@moku-labs/core").PluginInstance<"site", Config$4, Record<string, never>, Api$4, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"i18n", Config$3, Record<string, never>, Api$3, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"router", RouterConfig, RouterState, RouterApi, {}> & {
   route: typeof route;
   defineRoutes: typeof defineRoutes;
-}) | (import("@moku-labs/core").PluginInstance<"head", Config, State, Api, {}> & {
+  createUrls: typeof createUrls;
+}) | (import("@moku-labs/core").PluginInstance<"head", Config$1, State$1, Api$1, {}> & {
   meta: typeof meta;
   og: typeof og;
   twitter: typeof twitter;
@@ -1803,10 +2215,11 @@ declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs
     name: string;
     el: Element;
   };
-}> & Record<never, never>) | ExtraPlugins[number], [...ExtraPlugins], import("@moku-labs/core").CoreApisFromTuple<[import("@moku-labs/core").CorePluginInstance<"log", LogConfig, LogState, LogApi>, import("@moku-labs/core").CorePluginInstance<"env", EnvConfig, EnvState, EnvApi>]>> | undefined) => import("@moku-labs/core").App<Config$4, Events, (import("@moku-labs/core").PluginInstance<"site", Config$3, Record<string, never>, Api$3, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"i18n", Config$2, Record<string, never>, Api$2, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"router", RouterConfig, RouterState, RouterApi, {}> & {
+}> & Record<never, never>) | ExtraPlugins[number], [...ExtraPlugins], import("@moku-labs/core").CoreApisFromTuple<[import("@moku-labs/core").CorePluginInstance<"log", LogConfig, LogState, LogApi>, import("@moku-labs/core").CorePluginInstance<"env", EnvConfig, EnvState, EnvApi>]>> | undefined) => import("@moku-labs/core").App<Config$5, Events, (import("@moku-labs/core").PluginInstance<"site", Config$4, Record<string, never>, Api$4, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"i18n", Config$3, Record<string, never>, Api$3, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"router", RouterConfig, RouterState, RouterApi, {}> & {
   route: typeof route;
   defineRoutes: typeof defineRoutes;
-}) | (import("@moku-labs/core").PluginInstance<"head", Config, State, Api, {}> & {
+  createUrls: typeof createUrls;
+}) | (import("@moku-labs/core").PluginInstance<"head", Config$1, State$1, Api$1, {}> & {
   meta: typeof meta;
   og: typeof og;
   twitter: typeof twitter;
@@ -1847,6 +2260,6 @@ declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs
  * const app = createApp({ plugins: [analytics] });
  * ```
  */
-declare const createPlugin: import("@moku-labs/core").BoundCreatePluginFunction<Config$4, Events, import("@moku-labs/core").CoreApisFromTuple<[import("@moku-labs/core").CorePluginInstance<"log", LogConfig, LogState, LogApi>, import("@moku-labs/core").CorePluginInstance<"env", EnvConfig, EnvState, EnvApi>]>>;
+declare const createPlugin: import("@moku-labs/core").BoundCreatePluginFunction<Config$5, Events, import("@moku-labs/core").CoreApisFromTuple<[import("@moku-labs/core").CorePluginInstance<"log", LogConfig, LogState, LogApi>, import("@moku-labs/core").CorePluginInstance<"env", EnvConfig, EnvState, EnvApi>]>>;
 //#endregion
-export { types_d_exports as Data, types_d_exports$1 as Env, types_d_exports$2 as Head, types_d_exports$3 as Log, types_d_exports$4 as Router, types_d_exports$5 as Spa, browserEnv, buildArticleHead, canonical, createApp, createComponent, createPlugin, dataPlugin, defineRoutes, envPlugin, feedLink, headPlugin, hreflang, i18nPlugin, jsonLd, logPlugin, meta, og, route, routerPlugin, sitePlugin, spaPlugin, twitter };
+export { types_d_exports as Content, types_d_exports$1 as Data, types_d_exports$2 as Env, types_d_exports$3 as Head, types_d_exports$4 as Log, types_d_exports$5 as Router, types_d_exports$6 as Spa, browserEnv, buildArticleHead, canonical, contentPlugin, createApp, createComponent, createPlugin, createUrls, dataPlugin, defineRoutes, envPlugin, feedLink, headPlugin, hreflang, i18nPlugin, jsonLd, logPlugin, meta, og, route, routerPlugin, sitePlugin, spaPlugin, twitter };