gemi 0.52.0 → 0.54.0

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

@@ -1 +1 @@
-{"version":3,"file":"ViewRouteDispatcher.d.ts","sourceRoot":"","sources":["../../../services/router/ViewRouteDispatcher.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAIzC,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,UAAU,CAAC;AAUzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAyGxD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,YAAY,CAAC;AAE/C,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,EAAE,QAc9D;AAED,qBAAa,mBAAmB;IAC9B,MAAM,CAAC,KAAK,SAAiB;IAE7B,cAAc,EAAE,cAAc,CAAM;IACpC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAM;IAC7C,0FAA0F;IAC1F,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAM;IACnD,aAAa,EAAE,aAAa,CAAM;IAClC,iBAAiB,EAAE,MAAM,EAAE,CAAM;IACjC,IAAI,EAAE,GAAG,CAAQ;IACjB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa,CAAgC;IAErD;;;;;;;;;OASG;IACH,OAAO,CAAC,YAAY,CAGhB;IAEJ,OAAO,CAAC,QAAQ,CAAC,KAAK,CAKpB;IAEF,8CAA8C;IAC9C,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;gBAEvB,MAAM,EAAE,eAAe;IA2B7B,YAAY,CAAC,GAAG,EAAE,WAAW;IAanC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,cAAc;IAatB,0BAA0B;IAC1B,OAAO,CAAC,kBAAkB;YA0CZ,MAAM;IAqXd,iBAAiB,CAAC,GAAG,EAAE,OAAO,gCAlSZ;QACpB,SAAS,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QAC3C,aAAa,EAAE,GAAG,CAAC;QACnB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;QAC5B,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACtC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC3B;;;;WAIG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAClC;;;;;;;;;;;WAWG;QACH,WAAW,CAAC,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC;QACpD;;;WAGG;QACH,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;KAClD;CAwmBJ"}
+{"version":3,"file":"ViewRouteDispatcher.d.ts","sourceRoot":"","sources":["../../../services/router/ViewRouteDispatcher.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAIzC,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,UAAU,CAAC;AAUzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AA2GxD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,YAAY,CAAC;AAE/C,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,EAAE,QAc9D;AAED,qBAAa,mBAAmB;IAC9B,MAAM,CAAC,KAAK,SAAiB;IAE7B,cAAc,EAAE,cAAc,CAAM;IACpC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAM;IAC7C,0FAA0F;IAC1F,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAM;IACnD,aAAa,EAAE,aAAa,CAAM;IAClC,iBAAiB,EAAE,MAAM,EAAE,CAAM;IACjC,IAAI,EAAE,GAAG,CAAQ;IACjB;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa,CAAgC;IAErD;;;;;;;;;OASG;IACH,OAAO,CAAC,YAAY,CAGhB;IAEJ,OAAO,CAAC,QAAQ,CAAC,KAAK,CAKpB;IAEF,8CAA8C;IAC9C,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;gBAEvB,MAAM,EAAE,eAAe;IA2B7B,YAAY,CAAC,GAAG,EAAE,WAAW;IAanC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,cAAc;IAatB,0BAA0B;IAC1B,OAAO,CAAC,kBAAkB;YA0CZ,MAAM;IA6Xd,iBAAiB,CAAC,GAAG,EAAE,OAAO,gCA1SZ;QACpB,SAAS,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QAC3C,aAAa,EAAE,GAAG,CAAC;QACnB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;QAC5B,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACtC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC3B;;;;WAIG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAClC;;;;;;;;;;;WAWG;QACH,WAAW,CAAC,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC;QACpD;;;WAGG;QACH,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;KAClD;CAqoBJ"}

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

@@ -1,3 +1,4 @@
+import type { DictionarySink, DictionaryUse } from "../../i18n/dictionarySink";
 import type { ServerQueryEntry, ServerQueryStore } from "./ServerQueryStore";
 /**
  * `</script>`-safe (and `<!--`-safe) JSON for inlining into an HTML script
@@ -6,6 +7,13 @@ import type { ServerQueryEntry, ServerQueryStore } from "./ServerQueryStore";
  */
 export declare function htmlSafeJson(value: unknown): string;
 export declare function queryPayloadScript(entry: ServerQueryEntry): string;
+/**
+ * The same trick for a `defineDictionary` dictionary a segment just rendered
+ * with. It rides the same queue as query payloads, so it lands ahead of the
+ * reveal chunk for the segment that used it and hydration never re-fetches
+ * strings the document already carries.
+ */
+export declare function dictionaryPayloadScript(use: DictionaryUse): string;
 /**
  * The injector sits at the end of the response pipe, so it is the one place
  * that knows when the body's first byte goes out and when the body actually
@@ -52,6 +60,6 @@ export interface StreamLifecycleHooks {
  *    begins can't push a script in front of `<!doctype html>`. (Those are
  *    normally in the `__GEMI_DATA__` snapshot anyway and skipped here.)
  */
-export declare function injectQueryPayloads(source: ReadableStream<Uint8Array>, store: ServerQueryStore, hooks?: StreamLifecycleHooks): ReadableStream<Uint8Array>;
+export declare function injectQueryPayloads(source: ReadableStream<Uint8Array>, store: ServerQueryStore, hooks?: StreamLifecycleHooks, dictionaries?: DictionarySink): ReadableStream<Uint8Array>;
 export declare function isBotUserAgent(userAgent: string | null): boolean;
 //# sourceMappingURL=streamQueryInjection.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"streamQueryInjection.d.ts","sourceRoot":"","sources":["../../../services/router/streamQueryInjection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE7E;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAKnD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAKlE;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,EAClC,KAAK,EAAE,gBAAgB,EACvB,KAAK,GAAE,oBAAyB,GAC/B,cAAc,CAAC,UAAU,CAAC,CAoE5B;AAUD,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAGhE"}
+{"version":3,"file":"streamQueryInjection.d.ts","sourceRoot":"","sources":["../../../services/router/streamQueryInjection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE7E;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAKnD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAKlE;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAGlE;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACtC;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,EAClC,KAAK,EAAE,gBAAgB,EACvB,KAAK,GAAE,oBAAyB,EAChC,YAAY,CAAC,EAAE,cAAc,GAC5B,cAAc,CAAC,UAAU,CAAC,CA4E5B;AAUD,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAGhE"}

package/dist/support/index.js

@@ -1,4 +1,4 @@
 // @bun
-import{Bb as S,Cb as U,Db as V,Eb as W}from"../chunk-ha7n1c94.js";import{Fb as Y}from"../chunk-ttzkn1qd.js";import{Ce as R}from"../chunk-3y9nf09k.js";import{Ke as F,Me as q}from"../chunk-mt2755rs.js";import"../chunk-qyaqg07q.js";import"../chunk-0h3jr9d9.js";class v{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 q(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 H}from"fs/promises";import{join as J,parse as z}from"path";var L=[".ts",".tsx",".js",".mjs",".jsx"];function M(x={}){let f={};for(let[C,g]of Object.entries(x))f[C]=B(g);return new F(f)}async function Q(x,f=new F){let C=[];try{C=await H(x)}catch(D){return f}let g=C.filter((D)=>{let{ext:P,name:j}=z(D);return L.includes(P)&&!j.startsWith(".")}).sort();for(let D of g){let{name:P}=z(D),j=await import(J(x,D));f.set(P,B(j))}return f}function B(x){if(x&&typeof x==="object"&&"default"in x)return x.default;return x}export{R as withDefaults,S as sourceFiles,W as projectRoot,Q as loadConfigFrom,V as discoverClasses,M as createConfigRepository,Y as ServiceProvider,v as Service,F as Repository,U as DiscoveryError};
+import{Fb as S,Gb as U,Hb as V,Ib as W}from"../chunk-xxw0gz4q.js";import{Lb as Y}from"../chunk-n1tkn8gv.js";import{Se as R}from"../chunk-g5tj10p8.js";import{_e as F,af as q}from"../chunk-w6gb9gc5.js";import"../chunk-6j1z2cqt.js";import"../chunk-7f5ad759.js";class v{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 q(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 H}from"fs/promises";import{join as J,parse as z}from"path";var L=[".ts",".tsx",".js",".mjs",".jsx"];function M(x={}){let f={};for(let[C,g]of Object.entries(x))f[C]=B(g);return new F(f)}async function Q(x,f=new F){let C=[];try{C=await H(x)}catch(D){return f}let g=C.filter((D)=>{let{ext:P,name:j}=z(D);return L.includes(P)&&!j.startsWith(".")}).sort();for(let D of g){let{name:P}=z(D),j=await import(J(x,D));f.set(P,B(j))}return f}function B(x){if(x&&typeof x==="object"&&"default"in x)return x.default;return x}export{R as withDefaults,S as sourceFiles,W as projectRoot,Q as loadConfigFrom,V as discoverClasses,M as createConfigRepository,Y as ServiceProvider,v as Service,F as Repository,U as DiscoveryError};
 
-//# debugId=94EA4BF19A2C421664756E2164756E21
+//# debugId=EB864E0AAF5EC59B64756E2164756E21

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": "94EA4BF19A2C421664756E2164756E21",
+  "debugId": "EB864E0AAF5EC59B64756E2164756E21",
   "names": []
 }

package/dist/testing/Page.d.ts

@@ -0,0 +1,166 @@
+import { type ComponentType, type PropsWithChildren, type ReactNode } from "react";
+import { type FallbackProps } from "react-error-boundary";
+import type { User } from "../auth/types";
+import { type QueryConfig } from "../client/QueryManagerContext";
+import type { Breadcrumb } from "../client/useBreadcrumbs";
+/**
+ * A dictionary as `Dictionary.create` produces it: a name and a
+ * `{ key: { locale: string } }` map.
+ *
+ * Typed structurally rather than as `Dictionary<T>` for two reasons. It keeps
+ * `gemi/testing` from importing `gemi/i18n` — a server entry, which reaches the
+ * `Lang` facade and through it the container. And it means an object literal of
+ * the same shape is accepted, so a test never *has* to import the app's
+ * dictionaries at all.
+ *
+ * Only `name` and `dictionary` are read — both plain data. `Dictionary`'s
+ * server-only methods (`render`, `reference`, which throw once `window` is
+ * defined) are never called from here.
+ */
+export interface PageDictionary {
+    name: string;
+    dictionary: Record<string, Record<string, string>>;
+}
+export interface PageProps {
+    /**
+     * The URL the view is mounted at. A template (`/app/:orgId/chat`) is resolved
+     * against `params`, so the same string can be pasted from the router.
+     */
+    pathname?: string;
+    /** Route params, as the router would have parsed them out of `pathname`. */
+    params?: Record<string, string>;
+    /** `"?tab=recent"`, `"tab=recent"`, or `{ tab: "recent" }`. */
+    searchParams?: string | Record<string, string | number | boolean>;
+    hash?: string;
+    /** The locale `useTranslator` and `useLocale` report. */
+    locale?: string;
+    /**
+     * The app's default locale. Links and `useNavigate` omit the locale segment
+     * for it, so leaving this equal to `locale` (the default) keeps hrefs
+     * unprefixed — set it to seed a page being viewed in a non-default locale.
+     */
+    defaultLocale?: string;
+    supportedLocales?: string[];
+    /**
+     * Dictionaries the components under test translate against — the app's own,
+     * or literals of the same shape.
+     *
+     * Note what importing the app's costs: `app/i18n/index.ts` imports
+     * `gemi/i18n`, a server entry, so the test file pulls the container and
+     * `node:async_hooks` into its module graph. Nothing there runs (and nothing
+     * here calls it), so it is fine under any runner that has Node builtins —
+     * vitest, `bun test` — and not under one that renders in a real browser. Use
+     * `translations` there, which is the shape the client actually receives.
+     */
+    dictionaries?: PageDictionary[];
+    /**
+     * Translations for the current locale, already resolved: dictionary name →
+     * key → string. This is the shape the server serializes onto the page, so it
+     * is what the client reads at runtime — and it imports nothing.
+     *
+     * ```tsx
+     * <Page translations={{ Chat: { greeting: "Hello {{name}}" } }}>
+     * ```
+     *
+     * Merged over `dictionaries`, so the two compose: seed from the app's real
+     * dictionary and override the one key a test is about.
+     */
+    translations?: Record<string, Record<string, string>>;
+    /**
+     * Data `useQuery` finds already cached, keyed by API path — the path passed
+     * to `useQuery`, without the `/api` prefix the client adds when it fetches.
+     * A key may carry a query string (`"/lists?page=2"`) to seed one search
+     * variant.
+     *
+     * The cache is keyed by the *resolved* path, so a key's `:params` are
+     * resolved against the page's `params` — and a key naming one the page does
+     * not carry is an error, naming the key. That case is common enough to be
+     * worth the loud failure: a query often takes its params from the call site
+     * rather than the route (`useQuery("/orgs/:orgId/lists", { params: { orgId } })`
+     * with `orgId` in component state), and the right seed for it is the resolved
+     * path, `"/orgs/abc/lists"`.
+     *
+     * Seeded at mount only: a component that mutates or refetches its data owns
+     * the cache from then on.
+     */
+    queryData?: Record<string, unknown>;
+    /** App-wide `useQuery` defaults, as `createRoot` threads them. */
+    queryConfig?: QueryConfig;
+    /**
+     * What `useUser()` reports. Defaults to `null` — an anonymous visitor — and
+     * either way the hook resolves from here without issuing a request.
+     */
+    user?: Partial<User> | null;
+    /** What `useBreadcrumbs()` returns, in order. */
+    breadcrumbs?: Breadcrumb[];
+    /**
+     * The theme `useTheme()` starts on. The app reads a visitor's stored choice
+     * out of `localStorage`; a test has no session to have made one in, so this
+     * seeds it without writing to storage. `setTheme` works from either.
+     */
+    theme?: "light" | "dark" | "system";
+    /**
+     * Fallback for the `Suspense` boundary wrapped around the children — the
+     * stand-in for the view's own `Loading` export, which the real router
+     * supplies. Defaults to `null`.
+     */
+    fallback?: ReactNode;
+    /**
+     * Renders in place of the children when one throws, mirroring a view's
+     * `Error` export. Without it a thrown render (an errored suspense query,
+     * say) propagates out of `render()` and fails the test, which is usually
+     * what you want.
+     */
+    errorFallback?: ComponentType<FallbackProps>;
+    /**
+     * Called when something navigates — a `Link` click, `useNavigate().push`.
+     * The navigation is reported, not performed: `<Page>` renders one route and
+     * does not re-resolve the tree, so `useLocation()` keeps reporting the
+     * pathname it was given.
+     */
+    onNavigate?: (href: string, action: "push" | "replace") => void;
+}
+/**
+ * Mounts a component with the inputs a view normally arrives with — route
+ * params, the current locale and its dictionaries, prefetched query data, the
+ * signed-in user — so a unit test can assert what it renders rather than only
+ * its empty state.
+ *
+ * ```tsx
+ * import { render, screen } from "@testing-library/react";
+ * import { Page } from "gemi/testing";
+ *
+ * render(
+ *   <Page
+ *     pathname="/app/:orgId/chat"
+ *     params={{ orgId: "abc" }}
+ *     queryData={{ "/organizations/:orgId/messages": [{ id: 1, body: "hi" }] }}
+ *     dictionaries={[ChatDictionary]}
+ *   >
+ *     <OrgChat />
+ *   </Page>,
+ * );
+ *
+ * expect(screen.getByText("hi")).toBeDefined();
+ * ```
+ *
+ * It is a plain component, so it composes with any renderer — Testing
+ * Library's `render`, `react-test-renderer`, or `renderToString`.
+ *
+ * Two things it does not do.
+ *
+ * It does not route: there is no view tree and no route manifest behind it, so
+ * a navigation is reported through `onNavigate` rather than resolved. To
+ * assert the page *after* one, render a second `<Page>`.
+ *
+ * And under `renderToString` it renders the server's own no-data branch for an
+ * *unseeded* query rather than suspending — deliberately, because suspending
+ * there is the streaming server's job: `createRoot` threads the request's
+ * `ServerQueryStore` through `ServerQueryContext`, and that store is what runs
+ * the route handler. A harness has no request and no handler to run, so there
+ * is nothing to suspend on. Seeded queries render their data on the server
+ * exactly as they do in the browser; unseeded ones behave as a route with no
+ * `Query.prefetch` does, framework warning included.
+ */
+export declare const Page: (props: PropsWithChildren<PageProps>) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Page.d.ts.map

package/dist/testing/Page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Page.d.ts","sourceRoot":"","sources":["../../testing/Page.tsx"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAGzE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAI1C,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,+BAA+B,CAAC;AAYvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAM3D;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACpD;AAED,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,+DAA+D;IAC/D,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IAClE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B;;;;;;;;;;OAUG;IACH,YAAY,CAAC,EAAE,cAAc,EAAE,CAAC;IAChC;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,kEAAkE;IAClE,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC5B,iDAAiD;IACjD,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;IAC3B;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;IAC7C;;;;;OAKG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,KAAK,IAAI,CAAC;CACjE;AA6ID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,IAAI,GAAI,OAAO,iBAAiB,CAAC,SAAS,CAAC,4CA4PvD,CAAC"}

package/dist/testing/index.d.ts

@@ -0,0 +1,3 @@
+export { Page } from "./Page";
+export type { PageProps, PageDictionary } from "./Page";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC"}

package/dist/testing/index.js

@@ -0,0 +1,352 @@
+import { A as createMemoryHistory, F as applyParams, L as QueryManagerContext, N as RouteStateProvider, O as ProgressManager, P as toVariantKey, R as QueryManagerProvider, T as ServerDataContext, V as Subject, a as m, c as ClientRouterContext, k as Action, o as RouteTransitionProvider, r as WebSocketContext, t as ThemeProvider, w as I18nProvider } from "../chunks/ThemeProvider-Bk1eZymb.js";
+import { Suspense, useContext, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region testing/Page.tsx
+/** `"?a=b"` (or `""`) from any of the shapes `searchParams` accepts. */
+function toSearchString(search) {
+	if (!search) return "";
+	const query = typeof search === "string" ? search.replace(/^\?/, "") : new URLSearchParams(Object.entries(search).map(([key, value]) => [key, String(value)])).toString();
+	return query ? `?${query}` : "";
+}
+/**
+* The `:params` a seed key needs supplied. Wildcards (`:rest*`) are excluded —
+* `applyParams` drops those when missing, which is a resolution rather than a
+* failure.
+*
+* Optional params (`:id?`) cannot reach here at all: a key is split at its
+* first `?` to separate the search string, so `"/lists/:folderId?"` arrives as
+* the path `/lists/:folderId`. Seed the resolved path for those.
+*/
+function requiredParamsOf(path) {
+	return Array.from(path.matchAll(/:([^/]+)/g), ([, name]) => name).filter((name) => !name.endsWith("*"));
+}
+/**
+* Fails a `queryData` key whose `:params` the page does not carry, saying so
+* in terms of the key.
+*
+* Without this the two documented runners disagree, and neither is legible.
+* `applyParams` throws `Missing parameter: orgId` under `import.meta.env.DEV`
+* (vitest) — a router-utility stack trace out of `<Page>`'s render, before
+* anything mounts, naming nothing that appears in the test. Under `bun test`
+* that flag is falsy, so it logs and seeds the literal `/orgs/undefined/lists`
+* instead: the seed misses, the query goes to the network, and the assertion
+* runs against a loading state.
+*
+* The case is common because a query's params often come from the call site
+* rather than the route — `useQuery("/orgs/:orgId/lists", { params: { orgId } })`
+* with `orgId` in component state. The cache is keyed by the *resolved* path,
+* so the way out is to seed that path directly.
+*/
+function resolveSeedPath(key, rawPath, params) {
+	const missing = requiredParamsOf(rawPath).filter((name) => params[name] === void 0);
+	if (missing.length > 0) throw new Error(`[gemi] <Page> cannot resolve the queryData key "${key}": no value for ${missing.map((name) => `:${name}`).join(", ")}. The query cache is keyed by the resolved path, so either add ${missing.map((name) => `\`${name}\``).join(", ")} to the page's \`params\`, or seed the resolved path (e.g. "${applyParams(rawPath, Object.fromEntries(missing.map((name) => [name, "123"])))}") — which is what a query taking its params from component state reads under.`);
+	return applyParams(rawPath, params);
+}
+/**
+* `queryData` in the shape the query cache seeds from: `{ [path]: { [variant]:
+* data } }`, the same payload `Query.prefetch` puts on a server-rendered page.
+*/
+function toPrefetchedData(queryData, params, warned) {
+	const prefetchedData = {};
+	for (const [key, data] of Object.entries(queryData)) {
+		const [rawPath, rawSearch = ""] = key.split("?");
+		if (rawPath.startsWith("/api/") && !warned.has(key)) {
+			warned.add(key);
+			console.warn(`[gemi] queryData key "${key}" starts with /api. useQuery is keyed by the path you pass it — the /api prefix is added when it fetches — so this entry seeds a path no query reads.`);
+		}
+		const path = resolveSeedPath(key, rawPath, params);
+		prefetchedData[path] = {
+			...prefetchedData[path],
+			[toVariantKey(rawSearch)]: data
+		};
+	}
+	return prefetchedData;
+}
+/**
+* `{ [locale]: { [dictionary]: { [key]: string } } }` — the payload
+* `Translator` serializes onto the page, which is the only form the client
+* ever sees. `dictionaries` are transposed into it (they are keyed the other
+* way round, by key then locale); `translations` is already in it and lands
+* under `locale`, last, so it wins.
+*/
+function toClientDictionary(dictionaries, locales, locale, translations) {
+	const clientDictionary = {};
+	for (const supported of locales) clientDictionary[supported] ??= {};
+	for (const { name, dictionary } of dictionaries) for (const [key, byLocale] of Object.entries(dictionary ?? {})) for (const [dictLocale, translation] of Object.entries(byLocale ?? {})) {
+		clientDictionary[dictLocale] ??= {};
+		clientDictionary[dictLocale][name] ??= {};
+		clientDictionary[dictLocale][name][key] = translation;
+	}
+	for (const [name, keys] of Object.entries(translations)) {
+		clientDictionary[locale] ??= {};
+		clientDictionary[locale][name] = {
+			...clientDictionary[locale][name],
+			...keys
+		};
+	}
+	return clientDictionary;
+}
+/**
+* Mounts a component with the inputs a view normally arrives with — route
+* params, the current locale and its dictionaries, prefetched query data, the
+* signed-in user — so a unit test can assert what it renders rather than only
+* its empty state.
+*
+* ```tsx
+* import { render, screen } from "@testing-library/react";
+* import { Page } from "gemi/testing";
+*
+* render(
+*   <Page
+*     pathname="/app/:orgId/chat"
+*     params={{ orgId: "abc" }}
+*     queryData={{ "/organizations/:orgId/messages": [{ id: 1, body: "hi" }] }}
+*     dictionaries={[ChatDictionary]}
+*   >
+*     <OrgChat />
+*   </Page>,
+* );
+*
+* expect(screen.getByText("hi")).toBeDefined();
+* ```
+*
+* It is a plain component, so it composes with any renderer — Testing
+* Library's `render`, `react-test-renderer`, or `renderToString`.
+*
+* Two things it does not do.
+*
+* It does not route: there is no view tree and no route manifest behind it, so
+* a navigation is reported through `onNavigate` rather than resolved. To
+* assert the page *after* one, render a second `<Page>`.
+*
+* And under `renderToString` it renders the server's own no-data branch for an
+* *unseeded* query rather than suspending — deliberately, because suspending
+* there is the streaming server's job: `createRoot` threads the request's
+* `ServerQueryStore` through `ServerQueryContext`, and that store is what runs
+* the route handler. A harness has no request and no handler to run, so there
+* is nothing to suspend on. Seeded queries render their data on the server
+* exactly as they do in the browser; unseeded ones behave as a route with no
+* `Query.prefetch` does, framework warning included.
+*/
+var Page = (props) => {
+	const { children, pathname: routePath = "/", params = {}, searchParams, hash = "", locale = "en-US", defaultLocale = locale, dictionaries = [], translations = {}, queryData = {}, queryConfig, user = null, breadcrumbs = [], theme, fallback = null, errorFallback, onNavigate } = props;
+	const supportedLocales = useMemo(() => Array.from(/* @__PURE__ */ new Set([
+		...props.supportedLocales ?? [],
+		defaultLocale,
+		locale
+	])), [
+		props.supportedLocales,
+		defaultLocale,
+		locale
+	]);
+	const pathname = applyParams(routePath, params) || "/";
+	const search = toSearchString(searchParams);
+	const urlLocaleSegment = locale === defaultLocale ? null : locale;
+	const dictionary = useMemo(() => toClientDictionary(dictionaries, supportedLocales, locale, translations), [
+		dictionaries,
+		supportedLocales,
+		locale,
+		translations
+	]);
+	const warnedRef = useRef(/* @__PURE__ */ new Set());
+	const prefetchedData = useMemo(() => {
+		const seeded = toPrefetchedData(queryData, params, warnedRef.current);
+		seeded["/auth/me"] ??= { "": user ?? null };
+		return seeded;
+	}, [
+		queryData,
+		params,
+		user
+	]);
+	const { breadcrumbViews, breadcrumbsCache, breadcrumbsRecord } = useMemo(() => {
+		const views = breadcrumbs.map((_, index) => `breadcrumb-${index}`);
+		const cache = new Map(breadcrumbs.map((breadcrumb, index) => [`${views[index]}:${pathname}`, breadcrumb]));
+		return {
+			breadcrumbViews: views,
+			breadcrumbsCache: cache,
+			breadcrumbsRecord: Object.fromEntries(cache)
+		};
+	}, [breadcrumbs, pathname]);
+	const [isNavigatingSubject] = useState(() => new Subject(false));
+	const [progressManager] = useState(() => new ProgressManager(isNavigatingSubject));
+	const [history] = useState(() => createMemoryHistory({ initialEntries: [`${pathname}${search}${hash}`] }));
+	const routeState = useMemo(() => ({
+		views: [],
+		params,
+		search,
+		state: {},
+		pathname,
+		hash,
+		action: null,
+		routePath,
+		locale: urlLocaleSegment,
+		data: {},
+		i18n: {
+			currentLocale: locale,
+			dictionary,
+			supportedLocales
+		},
+		prefetchedData,
+		breadcrumbs: breadcrumbsRecord,
+		appId: "test"
+	}), [
+		params,
+		search,
+		pathname,
+		hash,
+		routePath,
+		urlLocaleSegment,
+		locale,
+		dictionary,
+		supportedLocales,
+		prefetchedData,
+		breadcrumbsRecord
+	]);
+	const [routerSubject] = useState(() => new Subject(routeState));
+	const onNavigateRef = useRef(onNavigate);
+	onNavigateRef.current = onNavigate;
+	const listeningRef = useRef(false);
+	if (!listeningRef.current) {
+		listeningRef.current = true;
+		history.listen(({ location, action }) => {
+			const href = `${location.pathname}${location.search}${location.hash}`;
+			onNavigateRef.current?.(href, action === Action.Replace ? "replace" : "push");
+		});
+	}
+	const serverData = useMemo(() => ({
+		routeManifest: {},
+		pageData: {},
+		breadcrumbs: breadcrumbsRecord,
+		prefetchedData,
+		router: {
+			pathname,
+			params,
+			currentPath: routePath,
+			is404: false,
+			searchParams: search,
+			urlLocaleSegment
+		},
+		i18n: {
+			dictionary,
+			currentLocale: locale,
+			supportedLocales,
+			defaultLocale
+		},
+		componentTree: [],
+		auth: { user },
+		__csrf: "test-csrf-token",
+		cssManifest: {},
+		modulePreloadManifest: {},
+		meta: {},
+		appId: "test"
+	}), [
+		breadcrumbsRecord,
+		prefetchedData,
+		pathname,
+		params,
+		routePath,
+		search,
+		urlLocaleSegment,
+		dictionary,
+		locale,
+		supportedLocales,
+		defaultLocale,
+		user
+	]);
+	const [viewEntriesSubject] = useState(() => new Subject([]));
+	const routerContext = useMemo(() => ({
+		viewEntriesSubject,
+		history,
+		updatePageData: () => {},
+		getPageData: () => ({}),
+		getScrollPosition: () => 0,
+		getViewPathsFromPathname: () => breadcrumbViews,
+		getRoutePathnameFromHref: (href) => href,
+		isNavigatingSubject,
+		setNavigationAbortController: () => {},
+		progressManager,
+		fetchRouteCSS: async () => {},
+		preloadRouteModules: () => {},
+		prefetchRoute: async () => {},
+		takePrefetched: () => null,
+		clearPrefetchCache: () => {},
+		breadcrumbsCache,
+		routerSubject,
+		urlLocaleSegment
+	}), [
+		viewEntriesSubject,
+		history,
+		breadcrumbViews,
+		isNavigatingSubject,
+		progressManager,
+		breadcrumbsCache,
+		routerSubject,
+		urlLocaleSegment
+	]);
+	const [websocket] = useState(() => ({
+		subscribe: async () => {},
+		unsubscribe: async () => {},
+		broadcast: () => {}
+	}));
+	return /* @__PURE__ */ jsx(ThemeProvider, {
+		theme,
+		children: /* @__PURE__ */ jsx(ServerDataContext.Provider, {
+			value: serverData,
+			children: /* @__PURE__ */ jsx(I18nProvider, { children: /* @__PURE__ */ jsx(WebSocketContext.Provider, {
+				value: websocket,
+				children: /* @__PURE__ */ jsx(QueryManagerProvider, {
+					queryConfig,
+					children: /* @__PURE__ */ jsx(ClientRouterContext.Provider, {
+						value: routerContext,
+						children: /* @__PURE__ */ jsx(RouteTransitionProvider, {
+							isPending: false,
+							isFetching: false,
+							transitionPath: ["", pathname],
+							children: /* @__PURE__ */ jsx(RouteStateProvider, {
+								state: routeState,
+								children: /* @__PURE__ */ jsx(Boundary, {
+									errorFallback,
+									fallback,
+									resetKey: pathname,
+									children
+								})
+							})
+						})
+					})
+				})
+			}) })
+		})
+	});
+};
+/**
+* The `Suspense` boundary every view renders inside, and — when the test
+* supplies a fallback for it — the error boundary too.
+*
+* `onReset={clearErrors}` is the part that has to be here rather than inline
+* above: it needs `QueryManagerContext`, and it is what makes a view's real
+* `Error` export testable. A fallback whose "Try again" calls
+* `resetErrorBoundary()` re-renders the child, and `useQuery` reads the
+* failure still stored on the `QueryResource` and throws it straight back —
+* so without this the fallback never goes away and the retry path that works
+* in the app cannot be exercised. `ClientRouter`'s own boundary wires exactly
+* this pair.
+*/
+var Boundary = (props) => {
+	const { errorFallback: ErrorFallback, fallback, resetKey, children } = props;
+	const { clearErrors } = useContext(QueryManagerContext);
+	const content = /* @__PURE__ */ jsx(Suspense, {
+		fallback,
+		children
+	});
+	if (!ErrorFallback) return content;
+	return /* @__PURE__ */ jsx(m, {
+		FallbackComponent: ErrorFallback,
+		resetKeys: [resetKey],
+		onReset: clearErrors,
+		children: content
+	});
+};
+//#endregion
+export { Page };
+
+//# sourceMappingURL=index.js.map