gemi 0.109.0 → 0.111.0

package/dist/services/router/ViewRouteDispatcher.d.ts

@@ -70,7 +70,9 @@ export declare class ViewRouteDispatcher {
      * a route inside a gated section cannot be more reachable than the section.
      */
     private passesFeatureGates;
-    onRequestEnd(req: HttpRequest): Promise<void>;
+    onRequestEnd(req: HttpRequest, options?: {
+        mintSession?: boolean;
+    }): Promise<void>;
     /**
      * Fires the provider's `onStreamComplete` from a stream callback — an
      * observability hook must never break the response body it observes, so

package/dist/services/router/ViewRouteDispatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewRouteDispatcher.d.ts","sourceRoot":"","sources":["../../../services/router/ViewRouteDispatcher.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ViewRouteDispatcher.d.ts","sourceRoot":"","sources":["../../../services/router/ViewRouteDispatcher.ts"],"names":[],"mappings":"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"}

package/dist/services/router/staticCache.d.ts

@@ -0,0 +1,23 @@
+import type { StaticViewOptions } from "../../http/ViewRouter";
+/**
+ * Which of the cookies gemi sets on its own a view request gets.
+ *
+ * A hydrated view gets all three. A static view (`.static()`) gets none unless
+ * it asked: it is one body for every visitor, and a per-visitor `Set-Cookie`
+ * is what keeps a CDN from caching it. `i18n-locale` has no opt-in — the url
+ * carries a static page's locale.
+ */
+export declare function staticCookiePolicy(staticView: StaticViewOptions | undefined): {
+    locale: boolean;
+    session: boolean;
+    csrf: boolean;
+};
+/**
+ * Sets a static page's `Cache-Control` from `.static({ cacheControl })`.
+ *
+ * The handler's own header wins. A response that sets a cookie is never handed
+ * to a shared cache, whatever the option says: one visitor's cookie stored with
+ * the page would be replayed to everyone who gets that copy.
+ */
+export declare function applyStaticCacheControl(headers: Headers, staticView: StaticViewOptions): void;
+//# sourceMappingURL=staticCache.d.ts.map

package/dist/services/router/staticCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticCache.d.ts","sourceRoot":"","sources":["../../../services/router/staticCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,iBAAiB,GAAG,SAAS;;;;EAS3E;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,iBAAiB,QAatF"}

package/dist/services/router/staticDocument.d.ts

@@ -1,44 +1,66 @@
-import type { StaticRenderCollector } from "../../client/islands";
+import { type StaticRenderCollector } from "../../client/islands";
 /**
- * Where an island's client module is served from: `src` is imported by the
- * loader, `preload` is every chunk that import pulls in (itself first).
+ * Where an island's entry is served from: `src` is imported by the loader,
+ * `preload` is every chunk that import pulls in (itself first), React
+ * included.
  */
 export type IslandAsset = {
     src: string;
     preload: string[];
 };
-/** Maps an island module's build key (`app/views/site/menu.island.ts`) to its asset. */
+/** Maps an island module's build key (`app/views/site/Counter.tsx`) to its entry. */
 export type IslandResolver = (moduleKey: string) => IslandAsset | undefined;
 /** The id of the JSON block the loader reads its island table from. */
 export declare const ISLAND_DATA_ID = "gemi-islands";
 /**
  * The island loader, inlined into a static document that uses islands.
  *
- * Kept byte-for-byte constant — the per-page island table travels in a
+ * Kept byte-for-byte constant (the per-page island table travels in a
  * separate `<script type="application/json">`, which a Content Security Policy
- * does not treat as script — so a strict policy can allow it by hash:
- * `script-src 'sha256-…'` with `ISLAND_LOADER_CSP_HASH`. Island modules are
- * then plain `import()`s of same-origin (or asset-base) files.
+ * does not treat as script), so a strict policy can allow it by hash:
+ * `script-src 'sha256-…'` with `ISLAND_LOADER_CSP_HASH`. Everything it loads
+ * is a plain `import()` of a same-origin (or asset-base) file.
  *
- * Per marker: parse `data-props`, import the module on the island's schedule,
- * call its default export once. A failure is logged and leaves the
- * server-rendered markup in place.
+ * The table is `{ i: [{ s: entry URL, e: export, l: load }] }` and each
+ * marker's `data-island` indexes `i`. Per marker, on its schedule: import the
+ * island's entry (the module as `m`, the runtime's `h`), then
+ * `h(marker, m[export])`, which calls `hydrateRoot`. A failure is logged and
+ * leaves the server-rendered markup in place.
  */
 export declare const ISLAND_LOADER_SOURCE: string;
 /**
  * `'sha256-…'` for the production island loader, ready to put in a
  * `script-src` directive. The dev loader also installs the React Refresh
- * preamble first, so it does not match; a dev policy needs `'unsafe-inline'`
- * as Vite itself does.
+ * preamble and Vite's HMR client first, so it does not match; a dev policy
+ * needs `'unsafe-inline'` as Vite itself does.
  */
 export declare const ISLAND_LOADER_CSP_HASH: string;
 /**
- * Adds the island loader to a settled static document — only when the render
+ * Adds the island loader to a settled static document, only when the render
  * recorded an island, so a page without one keeps no script at all.
  *
- * Eager islands get `modulepreload`s in the head for their whole static import
- * closure; lazy ones are fetched when their schedule fires, so nothing about
- * them is announced up front.
+ * Eager islands get `modulepreload`s in the head for their entry's whole
+ * static import closure (React included); lazy ones are fetched when their
+ * schedule fires, so nothing about them is announced up front.
+ *
+ * Without a resolver (a test rendering through `app.fetch`), the markup is
+ * the whole result: nothing is injected and nothing is logged.
  */
 export declare function injectIslands(html: string, collector: StaticRenderCollector, resolveIsland: IslandResolver | undefined, dev: boolean): string;
+/**
+ * Moves each island's children into its slot.
+ *
+ * An island's own render (a root of its own) leaves an empty
+ * `<gemi-slot data-slot="i0-">`; the page tree renders the children, with the
+ * page's context, right after the marker in `<template data-gemi-slot="i0-">`.
+ * Here the template's content replaces the placeholder (as
+ * `<gemi-slot style="display:contents">…</gemi-slot>`, what the browser
+ * hydrates against) and the template goes away.
+ *
+ * The last template is spliced first: nothing after it can be inside it, so it
+ * holds no other island's children, and an island's children that contain
+ * islands are spliced after theirs are. Children the island didn't render are
+ * dropped, as a component that ignores `children` drops them anywhere.
+ */
+export declare function spliceIslandSlots(html: string): string;
 //# sourceMappingURL=staticDocument.d.ts.map

package/dist/services/router/staticDocument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staticDocument.d.ts","sourceRoot":"","sources":["../../../services/router/staticDocument.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGlE;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAE7D,wFAAwF;AACxF,MAAM,MAAM,cAAc,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,CAAC;AAE5E,uEAAuE;AACvE,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,QAMkH,CAAC;AAEpJ;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,QAEb,CAAC;AAwBvB;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,qBAAqB,EAChC,aAAa,EAAE,cAAc,GAAG,SAAS,EACzC,GAAG,EAAE,OAAO,GACX,MAAM,CAiCR"}
+{"version":3,"file":"staticDocument.d.ts","sourceRoot":"","sources":["../../../services/router/staticDocument.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAC;AAG9B;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAE7D,qFAAqF;AACrF,MAAM,MAAM,cAAc,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,CAAC;AAE5E,uEAAuE;AACvE,eAAO,MAAM,cAAc,iBAAiB,CAAC;AAE7C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,QAM8G,CAAC;AAEhJ;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,QAEb,CAAC;AA0BvB;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,qBAAqB,EAChC,aAAa,EAAE,cAAc,GAAG,SAAS,EACzC,GAAG,EAAE,OAAO,GACX,MAAM,CAiCR;AAcD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgBtD"}

package/dist/stats/bundleStats.d.ts

@@ -0,0 +1,104 @@
+import { type ViteManifest } from "../server/modulePreloads";
+import type { RouteTableEntry } from "./routeTable";
+/**
+ * `gemi stats`: the JavaScript each route loads before it can run, from the
+ * client build's manifest.
+ *
+ * A **hydrated** route loads the client entry and every view in its chain
+ * (layouts and page), each with its static imports followed transitively: the
+ * same walk the server does for the route's `modulepreload` links. Lazy chunks
+ * (`import()`) aren't initial and don't count.
+ *
+ * A **static** route (`.static()`) loads no client entry and no view code, only
+ * the islands its views can render. Each island has a client entry of its own,
+ * keyed `<module>?gemi-island` in the manifest, that imports the chunk holding
+ * the island's module and the island runtime (React, `react-dom/client`). A
+ * route can render an island when the chunk holding its module is reachable
+ * from the route's views (and the document layout) through static or lazy
+ * imports; the route then counts that island entry with its static imports. A
+ * page loads only the islands it shows, so this is its most. Chunks the islands
+ * share (the runtime, React) count once per route. The island loader is inline
+ * in the HTML and not counted.
+ *
+ * Sizes are raw, gzip -9 and brotli q11, the encodings `gemi build` writes
+ * next to each asset; those files are read when present.
+ */
+export type Size = {
+    raw: number;
+    gzip: number;
+    brotli: number;
+};
+export type SizeUnit = keyof Size;
+export interface RouteStats extends Size {
+    /** View paths that render the route, outermost layout first. */
+    views: string[];
+    /** Set for a `.static()` route. */
+    static?: true;
+    /** A static route's island entries (manifest keys, `<module>?gemi-island`). */
+    islands?: string[];
+    /** The JS chunks counted, by name without the content hash. */
+    chunks: string[];
+}
+export interface BuildStats {
+    /** The JSON shape, bumped when it changes incompatibly. */
+    version: 1;
+    /**
+     * `routes`: keyed by route path (`/p/:slug`; `<group>:/path` for a host group
+     * other than the root). `views`: the route table could not be read, so each
+     * view is reported as a hydrated page, keyed by view path.
+     */
+    by: "routes" | "views";
+    routes: Record<string, RouteStats>;
+    /** Each island entry (`<module>?gemi-island`) with its static imports. */
+    islands: Record<string, Size & {
+        chunks: string[];
+    }>;
+    /** Every JS chunk in the build, by name without the content hash. */
+    chunks: Record<string, Size>;
+    /** All CSS in the build. */
+    css: Size;
+}
+/** `stats` in `gemi.config.ts`. */
+export interface StatsConfig {
+    budgets?: StatsBudgets;
+}
+/** Initial-JS budgets in KB (1024 bytes). `gemi stats` fails when a route is over its. */
+export interface StatsBudgets {
+    /** Which size the budgets are in. Default `gzip`. */
+    unit?: SizeUnit;
+    /** Applies to every route without its own budget. Unset: only listed routes are checked. */
+    default?: number;
+    /** By route path (`/p/:slug`) or by view path (`site/Page`, the route's page view). */
+    routes?: Record<string, number>;
+}
+/**
+ * A chunk by its name without the content hash, so the same chunk compares
+ * across builds: `assets/PageBuilder-C4f9a1Xz.js` is `PageBuilder.js`.
+ */
+export declare function chunkName(file: string): string;
+/** The route key in `BuildStats.routes`: the path, prefixed by a non-root host group. */
+export declare function routeKey(entry: Pick<RouteTableEntry, "group" | "path">): string;
+export interface BundleStatsOptions {
+    /** The client build, `dist/client`. */
+    clientDir: string;
+    /** The route table; without it every view is reported as a hydrated page. */
+    routes?: RouteTableEntry[] | null;
+    /** The manifest, if already read; otherwise `<clientDir>/.vite/manifest.json`. */
+    manifest?: ViteManifest;
+}
+export declare function bundleStats(options: BundleStatsOptions): BuildStats;
+/** The budget that applies to a route: its own, its page view's, or the default. */
+export declare function budgetFor(key: string, route: Pick<RouteStats, "views">, budgets: StatsBudgets | undefined): number | undefined;
+/** The routes over their budget, as messages. */
+export declare function overBudget(stats: BuildStats, budgets: StatsBudgets | undefined): string[];
+/** Budget keys that match no route and no route's page view: probably a typo or a removed view. */
+export declare function unusedBudgets(stats: BuildStats, budgets: StatsBudgets | undefined): string[];
+/**
+ * The stats as a Markdown table, compared with `base` (another build's JSON,
+ * e.g. `main`'s) when given: per-route deltas, then the chunks that came, went
+ * or changed. Meant for a PR comment.
+ */
+export declare function markdownReport(stats: BuildStats, base: BuildStats | null, budgets: StatsBudgets | undefined): string;
+/** The stats as a plain-text table for the terminal, largest route first. */
+export declare function textReport(stats: BuildStats, budgets: StatsBudgets | undefined): string;
+//# sourceMappingURL=bundleStats.d.ts.map

package/dist/stats/bundleStats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleStats.d.ts","sourceRoot":"","sources":["../../stats/bundleStats.ts"],"names":[],"mappings":"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"}

package/dist/stats/route-table.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=route-table.d.ts.map

package/dist/stats/route-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-table.d.ts","sourceRoot":"","sources":["../../stats/route-table.ts"],"names":[],"mappings":""}

package/dist/stats/route-table.js

@@ -0,0 +1,4 @@
+// @bun
+import"../chunk-1yx2e0bh.js";import M from"path";import{writeFileSync as Q}from"fs";var L=new Set(["FILE","REDIRECT"]);function H(j){return j.run(()=>{let x=[];for(let{group:z,view:D}of j.domains().viewGroups())for(let[G,B]of Object.entries(D.flatViewRoutes)){let C=D.routeManifest[G]??B.segments.map((K)=>K.viewPath);if(C.length===0||L.has(C.at(-1)))continue;x.push({path:G,group:z,views:C,...B.static?{static:B.static.layout?{layout:B.static.layout}:{}}:{}})}return x})}var J=process.argv[2];async function U(){if(!J)throw Error("usage: route-table <out.json>");let j=M.resolve(process.cwd(),"app/kernel/Kernel.ts"),x=await import(j);if(typeof x.default!=="function")throw Error(`${j} has no default export (the Kernel subclass).`);let z=new x.default;z.boot();try{Q(J,JSON.stringify(H(z)))}finally{z.destroy()}}U().then(()=>process.exit(0),(j)=>{console.error(j?.stack??String(j)),process.exit(1)});
+
+//# debugId=2C354352EBF6475164756E2164756E21

package/dist/stats/route-table.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../stats/route-table.ts", "../stats/routeTable.ts"],
+  "sourcesContent": [
+    "/**\n * The entry `gemi stats` (and `gemi build --stats`) spawns to read the app's\n * route table: `bun --preload gemi/bun/preload stats/route-table.ts <out>`.\n *\n * `gemi build` deliberately never boots the app (see `bin/createRollupInput`).\n * This doesn't either, in the sense that matters: it imports the Kernel and\n * runs only its synchronous `boot()`, which registers providers and constructs\n * nothing that does I/O. No provider `boot()`, no service, no database, no\n * queue claiming and no scheduler. Importing the app's route files is the one\n * side effect, the same one `gemi app:route-manifest` has.\n *\n * Exposed as `gemi/stats/route-table` and resolved from the application's\n * `node_modules`, like `gemi/console/run`: the routers the app's files extend\n * are the app's copy of gemi, so the code reading them has to be as well.\n *\n * The table is written to the file named by the first argument rather than to\n * stdout, which app code is free to log to while it is imported.\n */\nimport path from \"node:path\";\nimport { writeFileSync } from \"node:fs\";\nimport type { Kernel } from \"../kernel/Kernel\";\nimport { collectRouteTable } from \"./routeTable\";\n\nconst out = process.argv[2];\n\nasync function main() {\n  if (!out) throw new Error(\"usage: route-table <out.json>\");\n  const kernelPath = path.resolve(process.cwd(), \"app/kernel/Kernel.ts\");\n  const module: { default?: new () => Kernel } = await import(kernelPath);\n  if (typeof module.default !== \"function\") {\n    throw new Error(`${kernelPath} has no default export (the Kernel subclass).`);\n  }\n  const kernel = new module.default();\n  kernel.boot();\n  try {\n    writeFileSync(out, JSON.stringify(collectRouteTable(kernel)));\n  } finally {\n    kernel.destroy();\n  }\n}\n\n// `.then` rather than a top-level `await`; see `console/run.ts`.\nmain().then(\n  () => process.exit(0),\n  (error) => {\n    console.error((error as Error)?.stack ?? String(error));\n    process.exit(1);\n  },\n);\n",
+    "import type { Kernel } from \"../kernel/Kernel\";\n\n/**\n * One document route, as `gemi stats` needs it: which views render it (layouts\n * first, the page last) and whether it is a `.static()` view.\n */\nexport interface RouteTableEntry {\n  /** The route pattern, e.g. `/p/:slug`. */\n  path: string;\n  /** The host group: `\"\"` for the root, a subdomain, `\"*\"` for the custom fallback. */\n  group: string;\n  /** View paths (`app/views/<path>.tsx`), outermost layout first. */\n  views: string[];\n  /** Set for a `.static()` route; `layout` is its document layout, if any. */\n  static?: { layout?: string };\n}\n\n/** View paths that name no component: file and redirect routes. */\nconst NOT_A_VIEW = new Set([\"FILE\", \"REDIRECT\"]);\n\n/**\n * Every document route the app declares, from a kernel that has only run its\n * synchronous `boot()`: providers have registered, nothing has booted, so no\n * database, queue, scheduler or listener is touched. Reading the routers only\n * constructs them, which is what `app:route-manifest` has always done.\n */\nexport function collectRouteTable(kernel: Kernel): RouteTableEntry[] {\n  return kernel.run(() => {\n    const entries: RouteTableEntry[] = [];\n    for (const { group, view } of kernel.domains().viewGroups()) {\n      for (const [path, route] of Object.entries(view.flatViewRoutes)) {\n        const views = view.routeManifest[path] ?? route.segments.map((s) => s.viewPath);\n        if (views.length === 0 || NOT_A_VIEW.has(views.at(-1)!)) continue;\n        entries.push({\n          path,\n          group,\n          views,\n          ...(route.static\n            ? { static: route.static.layout ? { layout: route.static.layout } : {} }\n            : {}),\n        });\n      }\n    }\n    return entries;\n  });\n}\n"
+  ],
+  "mappings": ";6BAkBA,oBACA,wBAAS,WCDT,IAAM,EAAa,IAAI,IAAI,CAAC,OAAQ,UAAU,CAAC,EAQxC,SAAS,CAAiB,CAAC,EAAmC,CACnE,OAAO,EAAO,IAAI,IAAM,CACtB,IAAM,EAA6B,CAAC,EACpC,QAAa,QAAO,UAAU,EAAO,QAAQ,EAAE,WAAW,EACxD,QAAY,EAAM,KAAU,OAAO,QAAQ,EAAK,cAAc,EAAG,CAC/D,IAAM,EAAQ,EAAK,cAAc,IAAS,EAAM,SAAS,IAAI,CAAC,IAAM,EAAE,QAAQ,EAC9E,GAAI,EAAM,SAAW,GAAK,EAAW,IAAI,EAAM,GAAG,EAAE,CAAE,EAAG,SACzD,EAAQ,KAAK,CACX,OACA,QACA,WACI,EAAM,OACN,CAAE,OAAQ,EAAM,OAAO,OAAS,CAAE,OAAQ,EAAM,OAAO,MAAO,EAAI,CAAC,CAAE,EACrE,CAAC,CACP,CAAC,EAGL,OAAO,EACR,EDrBH,IAAM,EAAM,QAAQ,KAAK,GAEzB,eAAe,CAAI,EAAG,CACpB,GAAI,CAAC,EAAK,MAAU,MAAM,+BAA+B,EACzD,IAAM,EAAa,EAAK,QAAQ,QAAQ,IAAI,EAAG,sBAAsB,EAC/D,EAAyC,MAAa,UAC5D,GAAI,OAAO,EAAO,UAAY,WAC5B,MAAU,MAAM,GAAG,gDAAyD,EAE9E,IAAM,EAAS,IAAI,EAAO,QAC1B,EAAO,KAAK,EACZ,GAAI,CACF,EAAc,EAAK,KAAK,UAAU,EAAkB,CAAM,CAAC,CAAC,SAC5D,CACA,EAAO,QAAQ,GAKnB,EAAK,EAAE,KACL,IAAM,QAAQ,KAAK,CAAC,EACpB,CAAC,IAAU,CACT,QAAQ,MAAO,GAAiB,OAAS,OAAO,CAAK,CAAC,EACtD,QAAQ,KAAK,CAAC,EAElB",
+  "debugId": "2C354352EBF6475164756E2164756E21",
+  "names": []
+}

package/dist/stats/routeTable.d.ts

@@ -0,0 +1,25 @@
+import type { Kernel } from "../kernel/Kernel";
+/**
+ * One document route, as `gemi stats` needs it: which views render it (layouts
+ * first, the page last) and whether it is a `.static()` view.
+ */
+export interface RouteTableEntry {
+    /** The route pattern, e.g. `/p/:slug`. */
+    path: string;
+    /** The host group: `""` for the root, a subdomain, `"*"` for the custom fallback. */
+    group: string;
+    /** View paths (`app/views/<path>.tsx`), outermost layout first. */
+    views: string[];
+    /** Set for a `.static()` route; `layout` is its document layout, if any. */
+    static?: {
+        layout?: string;
+    };
+}
+/**
+ * Every document route the app declares, from a kernel that has only run its
+ * synchronous `boot()`: providers have registered, nothing has booted, so no
+ * database, queue, scheduler or listener is touched. Reading the routers only
+ * constructs them, which is what `app:route-manifest` has always done.
+ */
+export declare function collectRouteTable(kernel: Kernel): RouteTableEntry[];
+//# sourceMappingURL=routeTable.d.ts.map

package/dist/stats/routeTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routeTable.d.ts","sourceRoot":"","sources":["../../stats/routeTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,4EAA4E;IAC5E,MAAM,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9B;AAKD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,EAAE,CAmBnE"}

package/dist/stats/run.d.ts

@@ -0,0 +1,43 @@
+import { type StatsConfig } from "./bundleStats";
+import type { RouteTableEntry } from "./routeTable";
+export interface RunStatsOptions {
+    rootDir: string;
+    /** `stats` from `gemi.config.ts`. */
+    config?: StatsConfig;
+    /** Write the stats as JSON here. */
+    json?: string;
+    /** Another build's JSON to compare with; a missing file is no comparison. */
+    base?: string;
+    /** Write the Markdown table here. */
+    markdown?: string;
+    /** `false` skips the route table and reports per view. */
+    routes?: boolean;
+    /** `bun --preload` args for the app's own preload (see `bin/gemi.ts`). */
+    preloadArgs?: string[];
+    log?: (line: string) => void;
+    error?: (line: string) => void;
+}
+/**
+ * Reads the client build in `<rootDir>/dist/client`, prints the initial JS per
+ * route, writes the requested files and checks the budgets. Returns the exit
+ * code: 1 when a route is over its budget or there is no build to read.
+ */
+export declare function runStats(options: RunStatsOptions): Promise<number>;
+export type RouteTableResult = {
+    ok: true;
+    routes: RouteTableEntry[];
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * The app's route table, read in a child process (`gemi/stats/route-table`)
+ * that imports the Kernel and runs only its synchronous `boot()`, with the same
+ * preloads as `gemi start`. A child, because the app's code has to load under
+ * the app's own gemi with the request transform registered, and because it
+ * must not leave anything running in the build process.
+ */
+export declare function loadRouteTable(rootDir: string, preloadArgs: string[], options?: {
+    timeoutMs?: number;
+}): Promise<RouteTableResult>;
+//# sourceMappingURL=run.d.ts.map

package/dist/stats/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../stats/run.ts"],"names":[],"mappings":"AAGA,OAAO,EAOL,KAAK,WAAW,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,qCAAqC;IACrC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,oCAAoC;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CA6CxE;AAED,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CAAE,GACvC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnC;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACnC,OAAO,CAAC,gBAAgB,CAAC,CAuC3B"}

package/dist/support/index.js

@@ -1,4 +1,4 @@
 // @bun
-import{hc as Y}from"../chunk-9hbwvcxn.js";import{ag as M}from"../chunk-9m18pknp.js";import{ah as P,ch as R}from"../chunk-h6g9g8qc.js";import"../chunk-367kyrdx.js";import{lh as Q,mh as U,nh as V,oh as W}from"../chunk-vna85rdq.js";import"../chunk-wvwee7dn.js";class S{static token;async boot(){}static inject(){if(!this.token)throw Error(`Service [${this.name}] does not declare a \`static token\`, so the container has no key to resolve it by.`);try{return R(this)}catch(x){throw Error(`Could not inject [${this.name}]. Services are constructed when the kernel boots, so `+"inject() only works from code that runs after that \u2014 a constructor default or a method "+`body, never module top level. Check that [${this.name}] is listed in \`services\` on your Kernel.`,{cause:x})}}static with(x){let f=new this;for(let[C,g]of Object.entries(x))if(g!==void 0)f[C]=g;return f}}import{readdir as z}from"fs/promises";import{join as B,parse as j}from"path";var H=[".ts",".tsx",".js",".mjs",".jsx"];function J(x={}){let f={};for(let[C,g]of Object.entries(x))f[C]=q(g);return new P(f)}async function L(x,f=new P){let C=[];try{C=await z(x)}catch(D){return f}let g=C.filter((D)=>{let{ext:v,name:F}=j(D);return H.includes(v)&&!F.startsWith(".")}).sort();for(let D of g){let{name:v}=j(D),F=await import(B(x,D));f.set(v,q(F))}return f}function q(x){if(x&&typeof x==="object"&&"default"in x)return x.default;return x}export{M as withDefaults,Q as sourceFiles,W as projectRoot,L as loadConfigFrom,V as discoverClasses,J as createConfigRepository,Y as ServiceProvider,S as Service,P as Repository,U as DiscoveryError};
+import{pc as Y}from"../chunk-qd2v93y4.js";import{ig as M}from"../chunk-bn5yn731.js";import{jh as P,lh as R}from"../chunk-q9s7kwgt.js";import"../chunk-3cg7y62b.js";import{uh as Q,vh as U,wh as V,xh as W}from"../chunk-m6ystvtk.js";import"../chunk-1yx2e0bh.js";class S{static token;async boot(){}static inject(){if(!this.token)throw Error(`Service [${this.name}] does not declare a \`static token\`, so the container has no key to resolve it by.`);try{return R(this)}catch(x){throw Error(`Could not inject [${this.name}]. Services are constructed when the kernel boots, so `+"inject() only works from code that runs after that \u2014 a constructor default or a method "+`body, never module top level. Check that [${this.name}] is listed in \`services\` on your Kernel.`,{cause:x})}}static with(x){let f=new this;for(let[C,g]of Object.entries(x))if(g!==void 0)f[C]=g;return f}}import{readdir as z}from"fs/promises";import{join as B,parse as j}from"path";var H=[".ts",".tsx",".js",".mjs",".jsx"];function J(x={}){let f={};for(let[C,g]of Object.entries(x))f[C]=q(g);return new P(f)}async function L(x,f=new P){let C=[];try{C=await z(x)}catch(D){return f}let g=C.filter((D)=>{let{ext:v,name:F}=j(D);return H.includes(v)&&!F.startsWith(".")}).sort();for(let D of g){let{name:v}=j(D),F=await import(B(x,D));f.set(v,q(F))}return f}function q(x){if(x&&typeof x==="object"&&"default"in x)return x.default;return x}export{M as withDefaults,Q as sourceFiles,W as projectRoot,L as loadConfigFrom,V as discoverClasses,J as createConfigRepository,Y as ServiceProvider,S as Service,P as Repository,U as DiscoveryError};
 
-//# debugId=654759EB0C4D295264756E2164756E21
+//# debugId=447CF5C12AD6A7A564756E2164756E21

package/dist/support/index.js.map

@@ -6,6 +6,6 @@
     "import { readdir } from \"node:fs/promises\";\nimport { join, parse } from \"node:path\";\n\nimport { Repository } from \"./Repository\";\n\nconst CONFIG_EXTENSIONS = [\".ts\", \".tsx\", \".js\", \".mjs\", \".jsx\"];\n\n// Builds a Repository from an already-imported map of config modules. The map\n// key becomes the top-level config key, so `{ mail: mailModule }` is readable\n// as `config.get(\"mail.driver\")`. Each entry may be either the module namespace\n// (its `default` export is unwrapped) or the config object itself.\nexport function createConfigRepository(\n  modules: Record<string, any> = {},\n): Repository {\n  const items: Record<string, any> = {};\n\n  for (const [key, mod] of Object.entries(modules)) {\n    items[key] = unwrap(mod);\n  }\n\n  return new Repository(items);\n}\n\n// Reads every config module in an app's `app/config` directory into a\n// Repository. The file's basename is the top-level key: `app/config/mail.ts`\n// populates `mail.*`. A missing directory yields an empty Repository so apps\n// that declare no config still boot.\nexport async function loadConfigFrom(\n  directory: string,\n  repository = new Repository(),\n): Promise<Repository> {\n  let entries: string[] = [];\n\n  try {\n    entries = await readdir(directory);\n  } catch (err) {\n    return repository;\n  }\n\n  const files = entries\n    .filter((entry) => {\n      const { ext, name } = parse(entry);\n      return CONFIG_EXTENSIONS.includes(ext) && !name.startsWith(\".\");\n    })\n    .sort();\n\n  for (const file of files) {\n    const { name } = parse(file);\n    const mod = await import(join(directory, file));\n    repository.set(name, unwrap(mod));\n  }\n\n  return repository;\n}\n\nfunction unwrap(mod: any) {\n  if (mod && typeof mod === \"object\" && \"default\" in mod) {\n    return mod.default;\n  }\n  return mod;\n}\n"
   ],
   "mappings": ";2RAgCO,CAAe,JAAQ,EAOrB,OAMD,AAAI,EAAkB,QAmBrB,OAAS,EAKX,CACH,GAAI,CAAC,KAAK,MACR,MAAU,MACR,YAAY,KAAK,0FACnB,EAGF,GAAI,CACF,OAAO,EAAI,IAAuB,EAClC,MAAO,EAAO,CACd,MAAU,MACR,qBAAqB,KAAK,6DACxB,+FACA,6CAA6C,KAAK,kDAEpD,CAAE,OAAM,CACV,SAoBG,KAAuB,CAAoB,EAA0B,CAC1E,IAAM,EAAW,IAAI,KACrB,QAAY,EAAK,KAAU,OAAO,QAAQ,CAAS,EACjD,GAAI,IAAU,OAAW,EAAS,GAAO,EAE3C,OAAO,EAEX,CChHA,kBAAS,oBACT,eAAS,WAAM,aAIf,IAAM,EAAoB,CAAC,MAAO,OAAQ,MAAO,OAAQ,MAAM,EAMxD,SAAS,CAAsB,CACpC,EAA+B,CAAC,EACpB,CACZ,IAAM,EAA6B,CAAC,EAEpC,QAAY,EAAK,KAAQ,OAAO,QAAQ,CAAO,EAC7C,EAAM,GAAO,EAAO,CAAG,EAGzB,OAAO,IAAI,EAAW,CAAK,EAO7B,eAAsB,CAAc,CAClC,EACA,EAAa,IAAI,EACI,CACrB,IAAI,EAAoB,CAAC,EAEzB,GAAI,CACF,EAAU,MAAM,EAAQ,CAAS,EACjC,MAAO,EAAK,CACZ,OAAO,EAGT,IAAM,EAAQ,EACX,OAAO,CAAC,IAAU,CACjB,IAAQ,MAAK,QAAS,EAAM,CAAK,EACjC,OAAO,EAAkB,SAAS,CAAG,GAAK,CAAC,EAAK,WAAW,GAAG,EAC/D,EACA,KAAK,EAER,QAAW,KAAQ,EAAO,CACxB,IAAQ,QAAS,EAAM,CAAI,EACrB,EAAM,MAAa,SAAK,EAAW,CAAI,GAC7C,EAAW,IAAI,EAAM,EAAO,CAAG,CAAC,EAGlC,OAAO,EAGT,SAAS,CAAM,CAAC,EAAU,CACxB,GAAI,GAAO,OAAO,IAAQ,UAAY,YAAa,EACjD,OAAO,EAAI,QAEb,OAAO",
-  "debugId": "654759EB0C4D295264756E2164756E21",
+  "debugId": "447CF5C12AD6A7A564756E2164756E21",
   "names": []
 }

package/dist/vite/index.mjs

@@ -1448,12 +1448,74 @@ function documentBase(base) {
 	return base.startsWith("/") || /^[a-z][a-z\d+.-]*:\/\//i.test(base) ? normalizeAssetBase(base) : "/";
 }
 //#endregion
+//#region internal/islandRuntime.ts
+/**
+* The browser side of islands, shared by the Vite plugin (which builds it), the
+* servers (which point the loader at it) and the tests.
+*
+* No imports: the Vite plugin is built on its own and the servers load it at
+* boot, so this file stays plain strings.
+*/
+/**
+* The module that hydrates islands: React, `react-dom/client` and the small
+* `h(marker, Component)` below. A virtual module of gemi's Vite plugin that
+* every island entry imports, so the islands on a page share one copy of
+* React, in one chunk.
+*/
+var ISLAND_RUNTIME_ID = "virtual:gemi-island-runtime";
+/** What `resolveId` turns `ISLAND_RUNTIME_ID` into (Vite's virtual-module convention). */
+var RESOLVED_ISLAND_RUNTIME_ID = `\0${ISLAND_RUNTIME_ID}`;
+/**
+* The query that turns a module into its island entry: `Counter.tsx?gemi-island`
+* is a module of the plugin's that re-exports `Counter.tsx` as `m` next to the
+* runtime's `h`. It is what a static page imports for an island, and so it
+* is what the client manifest lists, keyed `app/…/Counter.tsx?gemi-island`,
+* with React and `react-dom/client` among its imports.
+*/
+var ISLAND_ENTRY_QUERY = "?gemi-island";
+/** The island entry module for `file` (an absolute path or a root-relative URL). */
+function islandEntrySource(file) {
+	return `import * as m from ${JSON.stringify(file)};
+export { m };
+export { h } from ${JSON.stringify(ISLAND_RUNTIME_ID)};
+`;
+}
+/** The runtime module's source, as the plugin serves and builds it. */
+var ISLAND_RUNTIME_SOURCE = `import { createElement } from "react";
+import { hydrateRoot } from "react-dom/client";
+export function h(marker, Component) {
+  if (typeof Component !== "function" && (typeof Component !== "object" || Component === null)) {
+    throw new Error("gemi: island module has no component export for " + marker.outerHTML.slice(0, 80));
+  }
+  const json = marker.getAttribute("data-props");
+  const props = json ? JSON.parse(json) : {};
+  let slot = null;
+  for (const candidate of marker.querySelectorAll("gemi-slot")) {
+    if (candidate.closest("gemi-island") === marker) {
+      slot = candidate;
+      break;
+    }
+  }
+  const children = slot
+    ? [createElement("gemi-slot", {
+        style: { display: "contents" },
+        suppressHydrationWarning: true,
+        dangerouslySetInnerHTML: { __html: slot.innerHTML },
+      })]
+    : [];
+  return hydrateRoot(marker, createElement(Component, props, ...children), {
+    identifierPrefix: marker.getAttribute("data-uid") || undefined,
+  });
+}
+`;
+//#endregion
 //#region vite/islandPlugin.ts
 /**
-* `() => import("./x.island")` — the loader `island()` takes. The specifier
-* must name a `*.island` module; the extension is optional, as in any import.
+* `island(() => import("./Counter")`: the call `island()` is declared with.
+* The loader must be the first argument, written as an arrow with no
+* parameters returning one `import()` of a string literal.
 */
-var ISLAND_LOADER = /\(\s*\)\s*=>\s*import\(\s*(["'])([^"'\n]+?\.island(?:\.[cm]?[jt]sx?)?)\1\s*\)/g;
+var ISLAND_CALL = /\bisland\s*\(\s*(\(\s*\)\s*=>\s*import\(\s*(["'])([^"'\n]+)\2\s*\))/g;
 /**
 * Symlinks resolved, so the key is the same path the manifest is keyed on
 * however the project directory was reached (`/var` vs `/private/var` on
@@ -1467,47 +1529,87 @@ function realPath(path) {
 	}
 }
 /**
-* Tells the server which built file an island's loader imports.
+* Islands: `island(() => import("./Counter"))` in `gemi/client`.
 *
-* `island("nav-menu", NavMenuView, () => import("./navMenu.island"))` is
-* rewritten so the loader carries the module's build key — its path from the
-* project root, the key the client manifest uses:
+* Every such call is rewritten, in the client and the server graph alike, so
+* the loader carries the module's build key (its path from the project root,
+* the key the client manifest uses) and the module itself, imported
+* statically:
 *
 * ```js
-* Object.assign(() => import("./navMenu.island"), { gemiIsland: "app/views/site/navMenu.island.ts" })
+* import * as __gemi_island_0 from "./Counter";
+* island(Object.assign(() => Promise.resolve(__gemi_island_0),
+*   { gemiIsland: "app/views/site/Counter.tsx", gemiModule: __gemi_island_0 }))
 * ```
 *
-* The server renders, never calls the loader, and maps the key to a URL. In
-* the SSR graph the import itself is replaced too, so an island's browser code
-* is not bundled into the server build.
+* The static import is what lets a hydrated view render the component in
+* place, and a static view render it on the server without waiting on a
+* dynamic import. The key is what a static page's loader is pointed at.
+*
+* In the client build, each island module also gets an entry of its own,
+* `Counter.tsx?gemi-island`: the module (as `m`) and the island runtime's
+* hydrate function `h` (from `virtual:gemi-island-runtime`, which imports
+* React and `react-dom/client`). That entry's import closure, React included,
+* is exactly what a static page loads for the island, and the manifest shows
+* it under the entry's key. The runtime is one chunk the islands share. In
+* dev, Vite serves the same modules from source.
+*
+* Also usable on its own, e.g. from `gemi/vitest` in an app's
+* `vitest.config.ts`, so tests render islands with the same keys as the build.
 */
 function gemiIslandPlugin() {
 	let root = process.cwd();
+	let clientBuild = false;
+	const emitted = /* @__PURE__ */ new Set();
 	return {
 		name: "gemi-plugin-islands",
 		enforce: "pre",
 		configResolved(config) {
 			root = realPath(config.root);
+			clientBuild = config.command === "build" && !config.build.ssr;
+		},
+		buildStart() {
+			emitted.clear();
+		},
+		resolveId(id) {
+			return id === "virtual:gemi-island-runtime" ? RESOLVED_ISLAND_RUNTIME_ID : null;
 		},
-		async transform(code, id, options) {
-			if (id.includes("/node_modules/") || id.startsWith("\0")) return null;
+		load(id) {
+			if (id === RESOLVED_ISLAND_RUNTIME_ID) return ISLAND_RUNTIME_SOURCE;
+			if (id.endsWith("?gemi-island")) return islandEntrySource(id.slice(0, -ISLAND_ENTRY_QUERY.length));
+			return null;
+		},
+		async transform(code, id) {
+			if (id.includes("/node_modules/") || id.startsWith("\0") || id.endsWith("?gemi-island")) return null;
 			if (!/\.[cm]?[jt]sx?$/.test(id.split("?")[0])) return null;
-			if (!code.includes(".island")) return null;
-			const ssr = Boolean(options?.ssr) || this.environment?.config?.consumer === "server";
+			if (!code.includes("island")) return null;
+			const environmentConsumer = this.environment?.config?.consumer;
+			const emitEntries = clientBuild && (environmentConsumer === void 0 || environmentConsumer === "client");
 			const s = new MagicString(code);
-			let changed = false;
-			for (const match of code.matchAll(ISLAND_LOADER)) {
-				const [whole, quote, specifier] = match;
+			const imports = [];
+			for (const match of code.matchAll(ISLAND_CALL)) {
+				const [, loader, quote, specifier] = match;
 				const resolved = await this.resolve(specifier, id);
 				if (!resolved || resolved.external) continue;
 				const file = realPath(resolved.id.split("?")[0]);
 				const key = relative(root, file).split(sep).join("/");
 				if (key.startsWith("..")) continue;
-				const loader = ssr ? `() => Promise.reject(new Error("Island modules load in the browser."))` : `() => import(${quote}${specifier}${quote})`;
-				s.overwrite(match.index, match.index + whole.length, `Object.assign(${loader}, { gemiIsland: ${JSON.stringify(key)} })`);
-				changed = true;
+				const name = `__gemi_island_${imports.length}`;
+				imports.push(`import * as ${name} from ${quote}${specifier}${quote};`);
+				const start = match.index + match[0].length - loader.length;
+				s.overwrite(start, start + loader.length, `Object.assign(() => Promise.resolve(${name}), { gemiIsland: ${JSON.stringify(key)}, gemiModule: ${name} })`);
+				const moduleId = resolved.id.split("?")[0];
+				if (emitEntries && !emitted.has(moduleId)) {
+					emitted.add(moduleId);
+					this.emitFile({
+						type: "chunk",
+						id: `${moduleId}${ISLAND_ENTRY_QUERY}`,
+						preserveSignature: "strict"
+					});
+				}
 			}
-			if (!changed) return null;
+			if (imports.length === 0) return null;
+			s.prepend(`${imports.join("\n")}\n`);
 			return {
 				code: s.toString(),
 				map: s.generateMap({ hires: true })
@@ -1533,7 +1635,7 @@ var gemi = async () => {
 						ssrEmitAssets: true,
 						sourcemap: true,
 						rollupOptions: {
-							input: Array.from(JSON.parse(process.env.GEMI_INPUT ?? "[]")).filter((entry) => !(env.isSsrBuild && /\.island\.[cm]?[jt]sx?$/.test(entry))),
+							input: Array.from(JSON.parse(process.env.GEMI_INPUT ?? "[]")),
 							preserveEntrySignatures: "strict",
 							...env.isSsrBuild ? { external: isGemiExternal } : {}
 						}

package/dist/vitest/index.d.ts

@@ -24,4 +24,22 @@ import type { Plugin } from "vite";
  * ```
  */
 export declare function gemiRequestPlugin(): Plugin;
+/**
+ * gemi's island transform, for an app's `vitest.config.ts`: with it, a test
+ * that renders a static view through `App.fetch` sees each
+ * `island(() => import("./Counter"))` with the same module key as the build,
+ * and a hydrated view renders the component in place instead of lazily.
+ *
+ * Without it islands still render (the component is loaded with the
+ * `import()`), but their keys are unknown.
+ *
+ * ```ts
+ * // vitest.config.ts
+ * import { defineConfig } from "vitest/config";
+ * import { gemiIslandPlugin, gemiRequestPlugin } from "gemi/vitest";
+ *
+ * export default defineConfig({ plugins: [gemiRequestPlugin(), gemiIslandPlugin()] });
+ * ```
+ */
+export { gemiIslandPlugin } from "../vite/islandPlugin";
 //# sourceMappingURL=index.d.ts.map

package/dist/vitest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../vitest/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAMnC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAY1C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../vitest/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAMnC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAY1C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC"}