prosebook 0.3.0 → 0.5.0

package/README.md

@@ -1,6 +1,6 @@
 # prosebook
 
-Every string your app shows, in one typed catalog. For React and any JavaScript.
+Every string your app shows, in one typed catalog. For React, Preact, Vue, Svelte, Solid and any JavaScript.
 
 [Homepage](https://gkurt.com/prosebook/) · [Try it on the page](https://gkurt.com/prosebook/#in-context)
 
@@ -38,7 +38,7 @@ const { t } = useCopy();
   string, periods, sentence case, banned filler, and `{count} files` outside a plural. Plugins add your
   own rules, scoped by kind, surface and locale, and translations are held to their source.
 - **Native too.** The same catalog generates Rust, Swift and Kotlin for a tray, a menu bar or a CLI,
-  with plurals and number formats that say what the browser says.
+  with plurals, numbers and dates that say what the browser says, and the string resources Android and Apple read.
 
 ## Quick start
 
@@ -155,6 +155,121 @@ function Cart({ count }: { count: number }) {
 }
 ```
 
+### In Preact
+
+`prosebook/preact` is the React binding for Preact, written on `preact/hooks`, so it needs no
+`preact/compat`: `CopyProvider`, `useCopy`, `useLocale` and `Text`, used as above.
+
+```tsx
+import { CopyProvider, Text, useCopy } from 'prosebook/preact';
+```
+
+### In Vue
+
+Install the copy as a plugin, or give a subtree its own with `provideCopy(copy)` in `setup`. What
+`useCopy()` returns reads through a ref, so a template or `computed` that reads a message runs again
+when the locale changes. `rich` returns a `VNode`; in a template, `<Text>` renders a message and takes
+each tag as a slot of the same name, which gets what the tag wraps as `chunks`:
+
+```ts
+// main.ts
+import { copyPlugin } from 'prosebook/vue';
+
+createApp(App)
+  .use(copyPlugin(copy, { tags: { link: (chunks) => h('a', { href: '/terms' }, chunks) } }))
+  .mount('#app');
+```
+
+```vue
+<script setup lang="ts">
+import { Text, useCopy } from 'prosebook/vue';
+import { ref } from 'vue';
+
+const copy = useCopy();
+const count = ref(2);
+</script>
+
+<template>
+  <h2>{{ copy.t('cart.title') }}</h2>
+  <Text id="cart.items" :values="{ count }" />
+  <Text id="cart.terms">
+    <template #link="{ chunks }"
+      ><RouterLink to="/terms"><component :is="chunks" /></RouterLink
+    ></template>
+  </Text>
+  <button @click="copy.setLocale('de')">Deutsch</button>
+</template>
+```
+
+Templates are typed with `vue-tsc`, which runs on TypeScript 6 until TypeScript 7 ships its API.
+
+### In Svelte
+
+`setCopy(copy)` in a component gives it and everything below it the copy; `getCopy()` reads it. Its
+reads are reactive, so markup, `$derived` and effects that read a message run again when the locale
+changes. Tags render through snippets: give `<Text>` one of the same name, or `setCopy` one for every
+message. A snippet gets what its tag wraps as `chunks`, which `<Text {chunks} />` renders:
+
+```svelte
+<!-- App.svelte -->
+<script lang="ts">
+  import { setCopy, Text, type RichPart } from 'prosebook/svelte';
+
+  let { copy } = $props();
+  setCopy(copy, { tags: { link } });
+</script>
+
+{#snippet link(chunks: RichPart[])}<a href="/terms"><Text {chunks} /></a>{/snippet}
+```
+
+```svelte
+<!-- Cart.svelte -->
+<script lang="ts">
+  import { getCopy, Text } from 'prosebook/svelte';
+
+  const copy = getCopy();
+  let count = $state(2);
+</script>
+
+<h2>{copy.t('cart.title')}</h2>
+<Text id="cart.items" values={{ count }} />
+<Text id="cart.terms" />
+<button onclick={() => copy.setLocale('de')}>Deutsch</button>
+```
+
+`Text` ships as a `.svelte` file for your Svelte compiler to build, so it needs Svelte 5 and its Vite
+plugin (or SvelteKit). `svelte-check` types it, and runs on TypeScript 6 for now.
+
+### In Solid
+
+Each read tracks a signal the copy sets, so what reads a message updates in place when the locale
+changes, and components never run again. `rich` returns your tag renderers' elements beside the text.
+
+```tsx
+import { CopyProvider, Text, useCopy } from 'prosebook/solid';
+
+render(
+  () => (
+    <CopyProvider copy={copy} tags={{ link: (chunks) => <a href="/terms">{chunks}</a> }}>
+      <Cart />
+    </CopyProvider>
+  ),
+  root,
+);
+
+function Cart() {
+  const copy = useCopy();
+  const [count, setCount] = createSignal(2);
+  return (
+    <>
+      <h2>{copy.t('cart.title')}</h2>
+      <Text id="cart.items" values={{ count: count() }} />
+      <p>{copy.rich('cart.terms')}</p>
+    </>
+  );
+}
+```
+
 ### In plain JavaScript
 
 ```js
@@ -238,7 +353,7 @@ function Ready({ copy, children }: { copy: Copy; children: ReactNode }) {
 }
 ```
 
-### Outside the browser: Rust, Swift and Kotlin
+### Outside the browser: Rust, Swift, Kotlin, Android and Apple
 
 The parts of an app the browser doesn't draw, a tray, a menu bar, a CLI, an Android shell, can read
 the same catalog. `generate` writes one file per target in `native`, holding every locale:
@@ -283,17 +398,126 @@ A message with no placeholders is a `&'static str` in Rust and a property in Swi
 with placeholders is a function taking them in order, a string or a number of any integer or float type. Each member's doc comment
 is the source text, its context and what each argument holds.
 
+A date is a `Date` in Swift and a `java.time.Instant` in Kotlin, shown in the device's time zone. Rust's
+standard library has no time zones, so its file brings a `DateTime` holding the clock's fields, made
+from a moment and the offset it is shown at:
+
+```rust
+let printed = copy::DateTime::from_unix(seconds, offset); // offset in seconds east of UTC
+copy.printed(printed); // "Printed Jan 5, 2026 at 2:05 PM."
+```
+
 The files need nothing beside them: each brings the plural rules of its locales, compiled from CLDR's
-(the data `Intl.PluralRules` is built on), and its number formats, taken apart from `Intl` when it is
-generated: the digits, the separators, how integers group, the text around a currency or a percent.
-Each format is checked against `Intl` before any code is written, so native code writes what the
-browser does, Arabic digits and Indian grouping included. A key with no translation falls back
-through its parents to the source as the runtime's do, resolved when the file is written.
+(the data `Intl.PluralRules` is built on), and its number and date formats, taken apart from `Intl`
+when it is generated: the digits, the separators, how integers group, the text around a currency or a
+percent; the order of a date's fields, the month and weekday names, AM and PM or the locale's periods
+of the day, and its clock. Each format is checked against `Intl` before any code is written, so native
+code writes what the browser does, Arabic digits and Indian grouping included. A key with no
+translation falls back through its parents to the source as the runtime's do, resolved when the file
+is written.
+
+What can't be written that way fails `generate`, with the fix: a tag, compact notation, significant
+digits, a unit or currency name that changes with the count (`unitDisplay: 'long'`), a date with its
+time zone's name (`{when, time, full}`) or a time zone of its own, a locale that counts in another
+calendar than the Gregorian (Thai's Buddhist, Persian), and an MF2 option read from an argument. Leave
+such keys out of the target's `keys`.
+
+#### Android resources
+
+An Android app needs string resources even with the Kotlin target: its manifest, launcher shortcuts,
+an accessibility service's description and every other XML resource name strings as `@string/…`, and
+only a resource answers that. The `android` target writes them, with `out` naming the `res` folder:
 
-What can't be written that way fails `generate`, with the fix: a date (pass it formatted, as a plain
-`{when}`), a tag, compact notation, significant digits, a unit or currency name that changes with the
-count (`unitDisplay: 'long'`), and an MF2 option read from an argument. Leave such keys out of the
-target's `keys`.
+```ts
+native: [{ language: 'android', out: 'android/app/src/main/res', keys: ['android'] }],
+```
+
+`values/strings.xml` holds the source locale, and each other locale gets a folder named as Android
+names it (`values-de`, `values-pt-rBR`, `values-b+sr+Latn` for a script), holding what that locale
+shows, every fallback resolved. `name` renames the file, `strings` by default, so it can sit beside
+strings you write yourself. A resource is named for its key, less the prefix, with `.` and `-` as
+`_`: `android.sign-in.denied` is `R.string.sign_in_denied`. Above each is a comment with its context
+and what each argument holds.
+
+```xml
+<!-- Counts the cart. count: how many items the cart holds. -->
+<plurals name="cart_items">
+    <item quantity="one">%1$d item in the cart.</item>
+    <item quantity="other">%1$d items in the cart.</item>
+</plurals>
+<!-- Greets the person signed in. firstName: the person's first name. -->
+<string name="hello">Hello, %1$s!</string>
+```
+
+Android fills placeholders in with `String.format` and picks a plural's arm itself, so a resource
+holds less than the other targets: text, plain `{name}` placeholders, written `%1$s` by their place in
+the source so a translation can reorder them, and one plural, which becomes `<plurals>` with its count
+as `%1$d` (the text around it goes into each arm). Call it as Android does,
+`resources.getQuantityString(R.plurals.cart_items, count, count)`. `String.format` isn't `Intl`, so
+nothing here is checked against it: `%d` writes 1234 without grouping. Android picks the arm by the
+device's language, so a plural a locale doesn't translate picks among the source's arms by that
+language's rules. Escaping is done for you: quotes, apostrophes, `\`, `&`, `<`, a newline, a leading
+`@` or `?`, `%` where the string is formatted, and spaces Android would collapse or trim.
+
+What a resource can't hold fails `generate`, with the fix: a select, a date, a formatted number, a
+second plural, an ordinal, an offset, an exact arm such as `=0` (Android's `zero` is a category, which
+English never picks), a selector other than a bare `:number` or `:integer`, and a tag.
+
+#### Apple string tables
+
+An Apple app has the same gap: macOS and iOS read the permission prompts, the app's name and other
+Info.plist strings from the bundle, never from Swift. The `apple` target writes `.strings` tables, a
+`<locale>.lproj/<name>.strings` per locale under `out`, each holding what that locale shows. They are
+plain `.strings` files, not a String Catalog, which only Xcode compiles: an app bundled by Tauri or a
+script copies the `.lproj` folders into `Contents/Resources` as they are.
+
+With `plist`, the table is `InfoPlist` and translates that Info.plist. A catalog key can't be written
+`NSCameraUsageDescription`, so its words spell the plist key: `macos.ns-camera-usage-description` is
+`NSCameraUsageDescription`. The key must be in the plist, since the system reads only the keys there,
+and the plist's own text must be the source's, since it shows where no `.lproj` matches. Either way
+round, `generate` fails with the fix:
+
+```ts
+native: [{ language: 'apple', out: 'src-tauri/Resources', keys: ['macos'], plist: 'src-tauri/Info.plist' }],
+```
+
+```c
+/* Asks for the camera. */
+"NSCameraUsageDescription" = "Corner Shop scans a product's barcode with the camera.";
+```
+
+Without `plist`, the table is `Localizable`, for what the system looks up by key, such as a push
+notification's `loc-key`. An entry is named for its key less the prefix, as written (`tray.quit` is
+`"quit"` under `['tray']`), and placeholders are written `%1$@` by their place in the source, filled
+in by `String(format:)`, not `Intl`. A table holds text and plain `{name}` placeholders.
+
+A message with a plural goes into a `.stringsdict` of the same name beside the table, where the
+system looks first. Each plural is a variable in its format, so the text around it stays where it is
+and a message can hold two; its count is `%N$lld`, for an `Int`, and the system picks the arm by its
+own CLDR rules:
+
+```xml
+<key>items</key>
+<dict>
+    <key>NSStringLocalizedFormatKey</key>
+    <string>%1$@ has %2$#@count@ in the cart.</string>
+    <key>count</key>
+    <dict>
+        <key>NSStringFormatSpecTypeKey</key>
+        <string>NSStringPluralRuleType</string>
+        <key>NSStringFormatValueTypeKey</key>
+        <string>lld</string>
+        <key>one</key>
+        <string>%2$lld item</string>
+        <key>other</key>
+        <string>%2$lld items</string>
+    </dict>
+</dict>
+```
+
+A plural there is cardinal, on a bare count, with no offset and no exact arm such as `=0`, as on
+Android; a select, a date, a formatted number, a tag and a plural inside another fail `generate`, and
+an Info.plist string takes no placeholders at all. Show those from the Swift target.
 
 ## The catalog
 
@@ -321,6 +545,10 @@ catalog, so an editor with the YAML language server completes and explains every
 # yaml-language-server: $schema=./catalog.schema.json
 ```
 
+That line is how the editor finds the schema, so `generate` starts each catalog file with it, and
+`generate --check` (and `check`) fails on a file without it. A file that names a schema of its own on
+its first line keeps it.
+
 ### Messages
 
 ICU MessageFormat, checked at build time:
@@ -487,6 +715,26 @@ translations are then linted, as a person's would be. An agent working in the re
 of this: it can read `prosebook todo de`, write the translation files itself, and run
 `prosebook check`.
 
+**Translation tools.** `prosebook export` writes the same entries for a translation tool, as XLIFF
+2.0 or JSON by the file's extension (`--format xliff|json` on stdout), and `import` takes the tool's
+file back as it takes a reply:
+
+```bash
+prosebook export de de.xlf        # what todo lists; --all for every entry
+prosebook export en en.json       # the source, every entry, for a tool that translates JSON
+prosebook import de de.xlf        # or de.json, flat or nested by key
+```
+
+In XLIFF, each entry is a unit named for its key, in a file per area, with its context, kind, surface,
+what each placeholder holds and, for a stale one, the word diff as notes. A message travels as its
+ICU or MF2 text, which tools that take these formats read, not as XLIFF's inline codes: a target that
+comes back with a `<ph>` is left out with the fix. A missing translation goes out `initial`, a stale
+one `initial` with its translation, and a current one `translated`. A stale translation given back
+unchanged is accepted only once the tool has moved it on from `initial`, since only then has someone
+looked at it. Each unit carries its source as exported, so a translation of a source that has changed
+since is left out until it is exported again. JSON is `key: text` in the locale, empty where it has
+none, and carries no context: give the tool the XLIFF where it reads both.
+
 **Pseudo-locale.** `pseudo: 'en-XA'` generates `⟦Ýóóúúŕ çááŕţ⟧` from the source. Switch to it and
 any plain text on screen is hardcoded, a missing bracket is clipped text, and brackets inside
 brackets are a sentence spliced from fragments.
@@ -734,10 +982,92 @@ A message the build leaves out shows as its key, so by default a build fails on
 it can't see: `t(item.key)`, ``rich(`${area}.title`)``, `<Text id={id} />`. Write the key at the read,
 or, where every key it reads is written elsewhere (in an array, say) or listed in `keep`, mark the
 line with `prosebook-ignore`. Reads are known by name: `t` and `rich` alone or as methods, the names
-they're destructured to (`const { rich: tRich } = copy`) in any module, and `<Text>` from
-`prosebook/react`. `prune: 'loose'` prunes without the check, and `prune: false` ships everything.
+they're destructured to (`const { rich: tRich } = copy`) in any module, and `<Text>` from any of the
+bindings. In `.vue` and `.svelte` files the scripts and the expressions in the markup are read alike
+(`{{ t(key) }}`, `:id="key"`, `{copy.t(key)}`, `<Text {id} />`), and `<!-- prosebook-ignore -->` marks
+a line there. `prune: 'loose'` prunes without the check, and `prune: false` ships everything.
 `prune` and `keep` are options of each integration.
 
+## Splitting
+
+Pruning drops what no code reads; splitting ships the rest with the code that reads it. With
+`prosebook({ split: true })`, the Vite plugin splits each locale by area, the file a key's first
+segment names, so a route loaded with `lazy(() => import('./Cart.tsx'))` brings the `cart` messages
+with it and the main bundle holds none of them:
+
+```ts
+// vite.config.ts
+export default defineConfig({
+  plugins: [react(), prosebook({ split: true })],
+});
+```
+
+A module that names an area's keys imports that area, and the bundler puts it beside that module:
+in the main chunk when the shell reads it, in a route's chunk when only the route does, in a shared
+chunk when two routes do. An area holds the source's messages and the `bundled` locales'; every
+other locale loads area by area, as it is needed: switching language fetches only the areas
+already on the page. The area's module waits for that load (a top-level `await`), so a lazy route
+renders in the reader's language from its first frame, in every binding, with no change to the code
+reading it.
+
+Areas the bundler puts in one chunk share a file in each such locale, so a route reading three areas
+across its modules loads German in one request, not three. Which areas share a chunk is read from
+the imports under `scan.dirs` as the build starts, as the bundler will chunk them. An import that
+can't be followed, such as one through an alias, can leave two areas of a chunk a file each: one
+more request, never a missing message.
+
+The Bun plugin takes `split` too. `Bun.build` needs `splitting: true` for its lazy chunks, and in a
+full-stack build, one `Bun.build` of a server and the pages it imports, only the pages are split.
+bunfig.toml names a module whose default export is the plugin, so the dev server's comes from a
+file of the app's own. Under Bun, the files read for areas are those under `scan.dirs`, as for
+pruning:
+
+```ts
+// prosebook.plugin.ts, which bunfig.toml names: plugins = ["./prosebook.plugin.ts"]
+import { prosebook } from 'prosebook/bun';
+
+export default prosebook({ split: true });
+```
+
+```ts
+// build.ts
+await Bun.build({
+  entrypoints: ['./src/server.ts'],
+  target: 'bun',
+  outdir: './dist',
+  splitting: true,
+  plugins: [prosebook({ split: true })],
+});
+```
+
+Under Next, `withProsebook(config, { split: true })` splits what client components read. Next
+already splits client code by route, so each route's brings only its areas, and a server component
+reads whole locales, as the server render does. Turbopack has no virtual modules, so the areas are
+files `next dev` and `next build` write under `node_modules/.prosebook`, and a loader over the app's
+source under `scan.dirs` adds their imports in the browser.
+
+A read the build can't see, marked `prosebook-ignore`, finds its area only if some module loaded
+before it names one of the area's keys; one read before then shows its key and is reported through
+`onError`, with the fix. Areas `keep` names load with the catalog. Splitting runs in the browser
+only: a server render, and an app without a plugin, load whole locales. It needs a build target
+with top-level `await`, which Vite's, Bun's and Next's defaults have.
+
+A page rendered on a server in a lazy locale hydrates once its areas' files have loaded, and the
+browser asks for them only after the code reading them has. Under Vite, the server can link them
+first. A split client build writes down each area's file per lazy locale, the server build after
+it lists them in its catalog, and a copy hands each file it reads from to `preload`, once:
+
+```tsx
+import { preloadModule } from 'react-dom';
+
+const copy = createCopy(catalog, { locale, preload: (href) => preloadModule(href, { as: 'script' }) });
+```
+
+React puts a `<link rel="modulepreload">` in the page for each, so the browser fetches German
+beside the route's code. Without React, collect them and write the links yourself. Build the client
+before the server, as TanStack Start and other frameworks on Vite do; `vite build` warns where it
+built the server with no client to take the files from.
+
 ## Finding a string's entry
 
 In dev, hold Alt (Option on a Mac) and point at text on the page: the inspector outlines the
@@ -815,7 +1145,7 @@ export default defineConfig({
     properNouns: [],
     pathSeparator: '›',
   },
-  native: [], // Rust, Swift or Kotlin files: { language: 'rust', out: 'src/copy.rs', keys: ['tray'] }
+  native: [], // Rust, Swift or Kotlin files, Android's res or Apple's .lproj: { language: 'rust', out: 'src/copy.rs', keys: ['tray'] }
   scan: { dirs: ['src'] },
 });
 ```
@@ -826,13 +1156,17 @@ Each is a small shop in English, German and the pseudo-locale, and uses proseboo
 from the package. CI generates, lints, typechecks and builds each one, then checks what its build
 serves.
 
-| Example                                              |                                                                                             |
-| ---------------------------------------------------- | ------------------------------------------------------------------------------------------- |
-| [`examples/vite`](examples/vite)                     | React with Vite, and a part-translated Turkish. The inspector is on.                        |
-| [`examples/next`](examples/next)                     | Next.js: server components read a copy per request, client components the provider's.       |
-| [`examples/tanstack-start`](examples/tanstack-start) | TanStack Start, rendered on the server in the request's locale with the Vite plugin.        |
-| [`examples/bun`](examples/bun)                       | `Bun.serve` with a React page, a route that answers in the request's locale, the inspector. |
-| [`examples/node`](examples/node)                     | No framework and no bundler: a Node script prints a receipt from the generated TypeScript.  |
+| Example                                              |                                                                                                                                      |
+| ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
+| [`examples/vite`](examples/vite)                     | React with Vite, a part-translated Turkish and the inspector. The cart is a lazy route, split by area.                               |
+| [`examples/preact`](examples/preact)                 | Preact with Vite's own JSX transform, the same app as the React one.                                                                 |
+| [`examples/vue`](examples/vue)                       | Vue single-file components: `<Text>` in templates, typed by `vue-tsc`.                                                               |
+| [`examples/svelte`](examples/svelte)                 | Svelte 5 with runes: the copy set in the root, the link a snippet, typed by `svelte-check`.                                          |
+| [`examples/solid`](examples/solid)                   | Solid: reads update in place on a locale switch, and the components run once.                                                        |
+| [`examples/next`](examples/next)                     | Next.js: server components read a copy per request, client components the provider's. The cart is a route of its own, split by area. |
+| [`examples/tanstack-start`](examples/tanstack-start) | TanStack Start, rendered on the server in the request's locale, split, with the page's German files linked ahead.                    |
+| [`examples/bun`](examples/bun)                       | `Bun.serve` with a React page, a route that answers in the request's locale, the inspector. The cart is a lazy route, split by area. |
+| [`examples/node`](examples/node)                     | No framework and no bundler: a Node script prints a receipt from the generated TypeScript.                                           |
 
 ```bash
 bun run build                      # the examples import prosebook from dist
@@ -843,7 +1177,4 @@ bun run --cwd examples/next dev
 
 Ideas not built yet, roughly in order of value:
 
-1. **Exchange formats**: XLIFF 2 and JSON export and import for translation tools.
-2. **Per-area splitting**: one chunk per area and locale, so a lazy route loads only its own messages.
-3. **Dates in native targets**: date and time formats taken apart from `Intl` as number formats are,
-   so a Rust, Swift or Kotlin message can say when.
+1. **Preloading a split render's areas under Bun and Next**: Bun's chunks and Turbopack's name no module, so neither says which file holds an area.

package/dist/bind-BIZNv8nU.js

@@ -0,0 +1,62 @@
+// src/runtime/bind.ts
+/** A reader of `copy` whose reads go through `track`, and whose rich reads get `tags` unless they give their own. */
+function bindCopy(copy, tags, { track = () => {}, tag, whole }) {
+	const merged = {
+		...copy.tags,
+		...tags
+	};
+	return {
+		get locale() {
+			track();
+			return copy.locale;
+		},
+		get version() {
+			track();
+			return copy.version;
+		},
+		locales: copy.locales,
+		source: copy.source,
+		tags: copy.tags,
+		ready: copy.ready,
+		t(key, ...args) {
+			track();
+			return copy.t(key, ...args);
+		},
+		has(key) {
+			track();
+			return copy.has(key);
+		},
+		setLocale: copy.setLocale,
+		subscribe: copy.subscribe,
+		number(value, options) {
+			track();
+			return copy.number(value, options);
+		},
+		date(value, options) {
+			track();
+			return copy.date(value, options);
+		},
+		list(items, options) {
+			track();
+			return copy.list(items, options);
+		},
+		relative(value, unit, options) {
+			track();
+			return copy.relative(value, unit, options);
+		},
+		rich(key, ...values) {
+			track();
+			const all = {
+				...merged,
+				...values[0]
+			};
+			if (tag !== void 0) {
+				for (const [name, value] of Object.entries(all)) if (typeof value === "function") all[name] = (chunks) => tag(value, chunks);
+			}
+			return whole(copy.rich(key, all));
+		}
+	};
+}
+export { bindCopy as t };
+
+//# sourceMappingURL=bind-BIZNv8nU.js.map

package/dist/bind-BIZNv8nU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind-BIZNv8nU.js","names":[],"sources":["../src/runtime/bind.ts"],"sourcesContent":["/**\n * What every framework binding shares: a copy read through the framework's reactivity, with a\n * provider's tag renderers under each rich read's own.\n */\nimport type { Copy } from './copy.ts';\nimport type { MessageShape, RegisteredLocale, RegisteredMessages, RichKey, RichParam, TagFn } from './types.ts';\n\ntype M = RegisteredMessages;\n\n/**\n * `Copy`, with `rich` returning `R`, a node of the framework's, whose tag renderers make `N`s. The locale is\n * a parameter so it survives a lint that, where no catalog is registered, sees `RegisteredLocale` as the default.\n */\nexport interface BoundCopy<N, R = N, L extends string = RegisteredLocale> extends Omit<Copy<M, L>, 'rich'> {\n  rich<K extends RichKey<M>>(this: void, key: K, ...values: RichParam<M[K], N>): R;\n}\n\nexport type Tags = { readonly [tag: string]: (chunks: never) => unknown };\n\nexport interface Binding<R> {\n  /** Called on every read, so the framework knows the reader depends on the copy's version. */\n  track?: () => void;\n  /** What a tag's renderer is turned into, given what it wraps. Calls it by default. */\n  tag?: (render: (chunks: never) => unknown, chunks: unknown[]) => unknown;\n  /** What a rich read returns, given its parts. */\n  whole: (parts: unknown[]) => R;\n}\n\n/** A reader of `copy` whose reads go through `track`, and whose rich reads get `tags` unless they give their own. */\nexport function bindCopy<N, R>(copy: Copy, tags: Tags, { track = () => {}, tag, whole }: Binding<R>): BoundCopy<N, R> {\n  const merged = { ...copy.tags, ...tags };\n  return {\n    get locale() {\n      track();\n      return copy.locale;\n    },\n    get version() {\n      track();\n      return copy.version;\n    },\n    locales: copy.locales,\n    source: copy.source,\n    tags: copy.tags,\n    ready: copy.ready,\n    t(key, ...args) {\n      track();\n      return copy.t(key, ...args);\n    },\n    has(key): key is keyof M & string {\n      track();\n      return copy.has(key);\n    },\n    setLocale: copy.setLocale,\n    subscribe: copy.subscribe,\n    number(value, options) {\n      track();\n      return copy.number(value, options);\n    },\n    date(value, options) {\n      track();\n      return copy.date(value, options);\n    },\n    list(items, options) {\n      track();\n      return copy.list(items, options);\n    },\n    relative(value, unit, options) {\n      track();\n      return copy.relative(value, unit, options);\n    },\n    rich(key, ...values) {\n      track();\n      const all: Record<string, unknown> = { ...merged, ...(values[0] as object | undefined) };\n      if (tag !== undefined) {\n        for (const [name, value] of Object.entries(all))\n          if (typeof value === 'function') all[name] = (chunks: unknown[]) => tag(value as (chunks: never) => unknown, chunks);\n      }\n      return whole(copy.rich(key, all as never));\n    },\n  };\n}\n\ntype NoValues<S extends MessageShape> = {} extends S['args'] & { [T in S['tags']]: unknown } ? true : false;\n\n/**\n * A `<Text>`'s props where the call site renders every tag the provider doesn't: `values` is needed\n * once the message takes arguments or wraps text in a tag.\n */\nexport type TextProps<K extends Extract<keyof M, string>, N> = { id: K } & (NoValues<M[K]> extends true\n  ? { values?: M[K]['args'] & { [T in M[K]['tags']]?: TagFn<N> } }\n  : { values: RichParam<M[K], N>[0] });\n\n/** A `<Text>`'s props where tags may come from elsewhere (slots, snippets): `values` holds arguments, and tags if you like. */\nexport type LooseTextProps<K extends Extract<keyof M, string>, N> = { id: K } & ({} extends M[K]['args']\n  ? { values?: M[K]['args'] & { [T in M[K]['tags']]?: TagFn<N> } }\n  : { values: M[K]['args'] & { [T in M[K]['tags']]?: TagFn<N> } });\n"],"mappings":";;AA6BA,SAAgB,SAAe,MAAY,MAAY,EAAE,cAAc,CAAC,GAAG,KAAK,SAAsC;CACpH,MAAM,SAAS;EAAE,GAAG,KAAK;EAAM,GAAG;CAAK;CACvC,OAAO;EACL,IAAI,SAAS;GACX,MAAM;GACN,OAAO,KAAK;EACd;EACA,IAAI,UAAU;GACZ,MAAM;GACN,OAAO,KAAK;EACd;EACA,SAAS,KAAK;EACd,QAAQ,KAAK;EACb,MAAM,KAAK;EACX,OAAO,KAAK;EACZ,EAAE,KAAK,GAAG,MAAM;GACd,MAAM;GACN,OAAO,KAAK,EAAE,KAAK,GAAG,IAAI;EAC5B;EACA,IAAI,KAA8B;GAChC,MAAM;GACN,OAAO,KAAK,IAAI,GAAG;EACrB;EACA,WAAW,KAAK;EAChB,WAAW,KAAK;EAChB,OAAO,OAAO,SAAS;GACrB,MAAM;GACN,OAAO,KAAK,OAAO,OAAO,OAAO;EACnC;EACA,KAAK,OAAO,SAAS;GACnB,MAAM;GACN,OAAO,KAAK,KAAK,OAAO,OAAO;EACjC;EACA,KAAK,OAAO,SAAS;GACnB,MAAM;GACN,OAAO,KAAK,KAAK,OAAO,OAAO;EACjC;EACA,SAAS,OAAO,MAAM,SAAS;GAC7B,MAAM;GACN,OAAO,KAAK,SAAS,OAAO,MAAM,OAAO;EAC3C;EACA,KAAK,KAAK,GAAG,QAAQ;GACnB,MAAM;GACN,MAAM,MAA+B;IAAE,GAAG;IAAQ,GAAI,OAAO;GAA0B;GACvF,IAAI,QAAQ,KAAA,GACL;SAAA,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,GAAG,GAC5C,IAAI,OAAO,UAAU,YAAY,IAAI,SAAS,WAAsB,IAAI,OAAqC,MAAM;GAAA;GAEvH,OAAO,MAAM,KAAK,KAAK,KAAK,GAAY,CAAC;EAC3C;CACF;AACF"}

package/dist/bind-ZS86jHXk.d.ts

@@ -0,0 +1,31 @@
+import { C as RichParam, S as RichKey, T as TagFn, b as RegisteredLocale, g as MessageShape, n as Copy, x as RegisteredMessages } from "./copy-BXn0aYQn.js";
+type M = RegisteredMessages;
+/**
+ * `Copy`, with `rich` returning `R`, a node of the framework's, whose tag renderers make `N`s. The locale is
+ * a parameter so it survives a lint that, where no catalog is registered, sees `RegisteredLocale` as the default.
+ */
+interface BoundCopy<N, R = N, L extends string = RegisteredLocale> extends Omit<Copy<M, L>, 'rich'> {
+  rich<K extends RichKey<M>>(this: void, key: K, ...values: RichParam<M[K], N>): R;
+}
+type NoValues<S extends MessageShape> = {} extends S['args'] & { [T in S['tags']]: unknown; } ? true : false;
+/**
+ * A `<Text>`'s props where the call site renders every tag the provider doesn't: `values` is needed
+ * once the message takes arguments or wraps text in a tag.
+ */
+type TextProps<K extends Extract<keyof M, string>, N> = {
+  id: K;
+} & (NoValues<M[K]> extends true ? {
+  values?: M[K]['args'] & { [T in M[K]['tags']]?: TagFn<N>; };
+} : {
+  values: RichParam<M[K], N>[0];
+});
+/** A `<Text>`'s props where tags may come from elsewhere (slots, snippets): `values` holds arguments, and tags if you like. */
+type LooseTextProps<K extends Extract<keyof M, string>, N> = {
+  id: K;
+} & ({} extends M[K]['args'] ? {
+  values?: M[K]['args'] & { [T in M[K]['tags']]?: TagFn<N>; };
+} : {
+  values: M[K]['args'] & { [T in M[K]['tags']]?: TagFn<N>; };
+});
+export { LooseTextProps as n, TextProps as r, BoundCopy as t };
+//# sourceMappingURL=bind-ZS86jHXk.d.ts.map

package/dist/bind-ZS86jHXk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind-ZS86jHXk.d.ts","names":[],"sources":["../src/runtime/bind.ts"],"mappings":";KAOK,IAAI;;;;;UAMQ,UAAU,GAAG,IAAI,GAAG,mBAAmB,0BAA0B,KAAK,KAAK,GAAG;EAC7F,KAAK,UAAU,QAAQ,IAAI,YAAY,KAAK,MAAM,QAAQ,UAAU,EAAE,IAAI,KAAK;;KAoE5E,SAAS,UAAU,2BAA2B,eAAe,KAAK;;;;;KAM3D,UAAU,UAAU,cAAc,YAAY;EAAO,IAAI;KAAO,SAAS,EAAE;EACjF,SAAS,EAAE,gBAAgB,KAAK,EAAE,cAAc,MAAM;;EACtD,QAAQ,UAAU,EAAE,IAAI;;;KAGlB,eAAe,UAAU,cAAc,YAAY;EAAO,IAAI;gBAAkB,EAAE;EACxF,SAAS,EAAE,gBAAgB,KAAK,EAAE,cAAc,MAAM;;EACtD,QAAQ,EAAE,gBAAgB,KAAK,EAAE,cAAc,MAAM"}

package/dist/bun.d.ts

@@ -1,5 +1,5 @@
-import { t as Prune } from "./bundle-KD-DiiFa.js";
-import { i as ProsebookConfig } from "./config-DdMkKt_N.js";
+import { t as Prune } from "./bundle-CLHY_97D.js";
+import { i as ProsebookConfig } from "./config-CzaJJQ60.js";
 import { BunPlugin } from "bun";
 export interface ProsebookBunOptions {
   /** The config, inline. Without it, `prosebook.config.*` at `root` is read. */
@@ -12,8 +12,17 @@ export interface ProsebookBunOptions {
    * check; `false` ships every message.
    */
   prune?: Prune;
-  /** Keys a build always keeps, exactly or as `prefix.*`: for keys built at runtime from data. */
+  /**
+   * Keys a build always keeps, exactly or as `prefix.*`: for keys built at runtime from data. With
+   * `split`, their areas load with the catalog.
+   */
   keep?: string[];
+  /**
+   * Split each locale by area in the page, as the Vite plugin's `split` does, so a lazy route loads
+   * only the messages it reads. `Bun.build` needs `splitting: true`. A server's own code loads whole
+   * locales.
+   */
+  split?: boolean;
   /** Under the dev server, Alt-click a string on the page to open its entry in the editor. On by default. */
   inspect?: boolean;
 }

package/dist/bun.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bun.d.ts","names":[],"sources":["../src/bun.ts"],"mappings":";;;iBAqCiB;;EAEf,SAAS;;EAET;;;;;;EAMA,QAAQ;;EAER;;EAEA;;wBAQc,UAAU,UAAS,sBAA2B;iBA6C7C;;EAEf,SAAS;;EAET;;;;;;wBAOc,UAAU,UAAS,yBAA8B,gBAAgB,KAAK,YAAY,QAAQ"}
+{"version":3,"file":"bun.d.ts","names":[],"sources":["../src/bun.ts"],"mappings":";;;iBAqDiB;;EAEf,SAAS;;EAET;;;;;;EAMA,QAAQ;;;;;EAKR;;;;;;EAMA;;EAEA;;wBAWc,UAAU,UAAS,sBAA2B;iBA0E7C;;EAEf,SAAS;;EAET;;;;;;wBAOc,UAAU,UAAS,yBAA8B,gBAAgB,KAAK,YAAY,QAAQ"}