@nifrajs/web-svelte 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nifra Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# @nifrajs/web-svelte
+
+Svelte 5 render adapter for @nifrajs/web — SSR + hydration + the .svelte compiler Bun-plugin.
+
+Part of the **[nifra](https://nifra.dev)** full-stack TypeScript framework — one core, five UI libraries, every runtime. Scaffold a new app with `bun create nifra`.
+
+## Install
+
+```sh
+bun add @nifrajs/web-svelte
+```
+
+## Docs
+
+- Reference: <https://nifra.dev/docs>
+- AI-readable: <https://nifra.dev/llms.txt>
+
+MIT

package/dist/Await.svelte

@@ -0,0 +1,27 @@
+<!--
+  Await.svelte — the `<Await>` primitive for deferred loader/action data (`defer()`), built on Svelte's
+  native `{#await}` block + scoped-snippet props: `children(value)` (resolved), `pending`, `error(err)`.
+
+  Svelte SSR renders the PENDING branch of `{#await}` (it does not block on the promise), so the server
+  emits the fallback and the client resolves it (hydration / soft-nav) — matching nifra's non-blocking
+  `defer()` (like the Vue adapter; contrast React/Preact, which stream the resolved content into the SSR
+  HTML). An already-resolved `resolve` (a plain value, or a client nav that awaited it) renders directly.
+  Plain-JS script (no TS) so it needs no svelte TS preprocessor.
+-->
+<script>
+  let { resolve, children, pending, error } = $props()
+  const isDeferred = (v) =>
+    v != null && typeof v === "object" && v.__velo_deferred === true
+</script>
+
+{#if isDeferred(resolve)}
+  {#await resolve.promise}
+    {@render pending?.()}
+  {:then value}
+    {@render children?.(value)}
+  {:catch err}
+    {@render error?.(err)}
+  {/await}
+{:else}
+  {@render children?.(resolve)}
+{/if}

package/dist/Await.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { Deferred } from "@nifrajs/web"
+import type { Component, Snippet } from "svelte"
+
+/**
+ * Hand-written types for `Await.svelte` (svelte-package would generate this from the component). The
+ * internal build resolves `*.svelte` via the ambient `svelte-shim.d.ts`; this file is what *consumers*
+ * resolve through the `./await` export's `types` condition.
+ */
+export interface AwaitProps {
+  /** A `Deferred<T>` from a loader/action's `defer(...)`, or an already-resolved value. */
+  resolve: Deferred<unknown> | unknown
+  /** Rendered with the resolved value (the default snippet). */
+  children?: Snippet<[unknown]>
+  /** Rendered while the deferred is pending (the SSR + pre-resolve state). */
+  pending?: Snippet
+  /** Rendered if the deferred rejects. */
+  error?: Snippet<[unknown]>
+}
+
+declare const Await: Component<AwaitProps>
+export default Await

package/dist/Chain.svelte

@@ -0,0 +1,35 @@
+<!--
+  Chain.svelte — folds a nifra layout chain (outermost layout → page) into nested Svelte components:
+  the page (innermost, chain[last]) receives `props` (the loader data); each layout wraps the rest via
+  its `children` snippet ({@render children()} in the layout). Recurses on itself. This is the Svelte
+  analogue of the React/Vue `compose` — Svelte components are compiled (not callable), so the fold is a
+  component, not a function returning a node.
+-->
+<script>
+  import Self from "./Chain.svelte"
+  let { chain, props } = $props()
+</script>
+
+{#if chain.length <= 1}
+  {#if chain[0]}
+    {@const Page = chain[0]}
+    <Page {...props} />
+  {/if}
+{:else if chain[0] && chain[0].__veloErrorBoundary}
+  <!-- nifra `_error` boundary marker (from errorBoundary()): wrap the rest in <svelte:boundary>; the
+       `failed` snippet renders the route's _error component with the serialized error. -->
+  {@const Fallback = chain[0].__veloErrorBoundary}
+  <svelte:boundary>
+    <Self chain={chain.slice(1)} {props} />
+    {#snippet failed(error)}
+      <Fallback data={{ name: error?.name ?? "Error", message: String(error?.message ?? error) }} />
+    {/snippet}
+  </svelte:boundary>
+{:else}
+  {@const Layout = chain[0]}
+  <Layout>
+    {#snippet children()}
+      <Self chain={chain.slice(1)} {props} />
+    {/snippet}
+  </Layout>
+{/if}

package/dist/Content.svelte

@@ -0,0 +1,13 @@
+<!--
+  Content.svelte — render trusted pre-rendered HTML (e.g. a @nifrajs/content collection entry's `.html`)
+  into the DOM via Svelte's {@html}. Pairs with content collections: <Content html={entry.html} />.
+  `as` picks the wrapper element; extra attributes in `...rest` (class/style/id/data-*) pass through.
+
+  Security: {@html} injects raw HTML, so `html` MUST be trusted (your own Markdown/content, rendered at
+  build/server time) — never pass user-supplied HTML without sanitizing it first. Plain-JS script.
+-->
+<script>
+  let { html, as = "div", ...rest } = $props()
+</script>
+
+<svelte:element this={as} {...rest}>{@html html}</svelte:element>

package/dist/Content.svelte.d.ts

@@ -0,0 +1,17 @@
+import type { Component } from "svelte"
+
+/**
+ * Hand-written types for `Content.svelte` (svelte-package would generate this). Consumers resolve this
+ * through the `./content` export's `types` condition.
+ */
+export interface ContentProps {
+  /** Trusted, pre-rendered HTML (e.g. `entry.html`). */
+  html: string
+  /** Wrapper element (default `"div"`). */
+  as?: string
+  /** DOM passthrough (`class`, `style`, `id`, `data-*`, …). */
+  [key: string]: unknown
+}
+
+declare const Content: Component<ContentProps>
+export default Content

package/dist/I18nProvider.svelte

@@ -0,0 +1,20 @@
+<!--
+  I18nProvider.svelte — provides a nifra i18n `Formatter` (built from `locale` + `messages`) to the
+  subtree via Svelte context; consumers read it with `useT()` from `@nifrajs/web-svelte/i18n`. The
+  formatter is `$derived`, so switching locale rebuilds it. `locale` + `messages` are serializable, so
+  SSR renders the negotiated catalog and the client rebuilds the same formatter on hydrate (no
+  mismatch). Plain-JS script. The context key is a string (kept in sync with i18n.ts's `useT`) so this
+  component needs no `.ts` import.
+-->
+<script>
+  import { createFormatter } from "@nifrajs/i18n"
+  import { setContext } from "svelte"
+
+  let { locale, messages, children } = $props()
+
+  const formatter = $derived(createFormatter(locale, messages))
+  // A getter (not the value) so consumers read the current `$derived` formatter reactively.
+  setContext("@nifrajs/web-svelte:i18n", () => formatter)
+</script>
+
+{@render children?.()}

package/dist/I18nProvider.svelte.d.ts

@@ -0,0 +1,15 @@
+import type { Messages } from "@nifrajs/i18n"
+import type { Component, Snippet } from "svelte"
+
+/** Hand-written types for `I18nProvider.svelte` (consumers resolve these via the `./i18n` re-export). */
+export interface I18nProviderProps {
+  /** The active locale (e.g. `"en"`, `"fr-CA"`). */
+  locale: string
+  /** The ICU message catalog for `locale`. */
+  messages: Messages
+  /** The subtree that reads the formatter via `useT()`. */
+  children?: Snippet
+}
+
+declare const I18nProvider: Component<I18nProviderProps>
+export default I18nProvider

package/dist/Image.svelte

@@ -0,0 +1,27 @@
+<!--
+  Image.svelte — a CLS-safe responsive <Image> for nifra + Svelte. A thin wrapper over `resolveImage` +
+  `toHtmlAttrs` from @nifrajs/image: it computes the responsive <img> attributes (src/srcset/sizes/width/
+  height/loading/decoding/fetchpriority — lowercase HTML names) and renders an <img>. Any extra
+  attributes (class/style/id/data-*/handlers in `...rest`) pass through. `width`+`height` are required
+  (reserve layout space — no CLS); `priority` marks the LCP image. Resizing is delegated to the
+  `loader` (an image CDN); nifra bundles no codec. Plain-JS script (no TS preprocessor needed).
+-->
+<script>
+  import { resolveImage, toHtmlAttrs } from "@nifrajs/image"
+
+  let { src, width, height, alt, sizes, widths, quality, loading, priority, loader, ...rest } = $props()
+
+  // `$derived` keeps the attributes in sync if props change. Build ImageProps omitting unset optionals;
+  // resolveImage validates width/height > 0 (the CLS contract) and builds the responsive srcSet.
+  const attrs = $derived.by(() => {
+    const input = { src, width, height, alt }
+    if (sizes !== undefined) input.sizes = sizes
+    if (widths !== undefined) input.widths = widths
+    if (quality !== undefined) input.quality = quality
+    if (loading !== undefined) input.loading = loading
+    if (priority !== undefined) input.priority = priority
+    return toHtmlAttrs(resolveImage(input, loader))
+  })
+</script>
+
+<img {...rest} {...attrs} />

package/dist/Image.svelte.d.ts

@@ -0,0 +1,29 @@
+import type { ImageLoader, ImageProps } from "@nifrajs/image"
+import type { Component } from "svelte"
+import type { HTMLImgAttributes } from "svelte/elements"
+
+/**
+ * Hand-written types for `Image.svelte` (svelte-package would generate this). The internal build
+ * resolves `*.svelte` via the ambient `svelte-shim.d.ts`; this file is what *consumers* resolve through
+ * the `./image` export's `types` condition.
+ */
+type ComputedAttrs =
+  | "src"
+  | "srcset"
+  | "sizes"
+  | "width"
+  | "height"
+  | "alt"
+  | "loading"
+  | "decoding"
+  | "fetchpriority"
+
+export interface ImageComponentProps
+  extends ImageProps,
+    Omit<HTMLImgAttributes, ComputedAttrs | keyof ImageProps> {
+  /** CDN URL builder. Defaults to the identity loader (no transform — still CLS-safe + lazy). */
+  loader?: ImageLoader
+}
+
+declare const Image: Component<ImageComponentProps>
+export default Image

package/dist/Router.svelte

@@ -0,0 +1,27 @@
+<!--
+  Router.svelte — the reactive root for client navigation. Holds the agnostic store's snapshot in
+  `$state`, subscribes via `$effect` (cleaned up on unmount), and renders the matched layout chain
+  through `Chain.svelte`. `$derived` recomputes the chain + props on every store change, so client
+  navigations swap routes without a full reload. The initial snapshot matches the SSR markup (the
+  server rendered `Chain` for the same matched route), so `hydrate` reconciles cleanly.
+
+  Runes (`$state`/`$effect`/`$derived`) only work in compiled `.svelte` files — which is why this
+  reactive root is a component, not a function in `client.ts`.
+-->
+<script>
+  import Chain from "./Chain.svelte"
+  let { router, routes } = $props()
+
+  let snapshot = $state(router.snapshot())
+  $effect(() => router.subscribe(() => { snapshot = router.snapshot() }))
+
+  let chain = $derived(routes[snapshot.routeId] ?? [])
+  let props = $derived({
+    data: snapshot.data,
+    actionData: snapshot.actionData,
+    pending: snapshot.pending,
+    ...(snapshot.submission ? { submission: snapshot.submission } : {}),
+  })
+</script>
+
+<Chain {chain} {props} />

package/dist/client.d.ts

@@ -0,0 +1,12 @@
+import type { MountRouterOptions, RenderProps } from "@nifrajs/web";
+export { errorBoundary } from "./error.js";
+/** Hydrate a server-rendered Svelte layout `chain` (with the loader `props`) inside `container`. */
+export declare function hydrate(chain: readonly unknown[], props: RenderProps, container: unknown): void;
+/**
+ * Hydrate a stateful Svelte Router. The `Router` component holds the store snapshot in `$state` and
+ * re-renders the matched layout chain on each store change — so client navigations swap routes without
+ * a full reload. Its initial render matches the SSR markup (the server rendered `Chain` for the same
+ * matched route), so hydration reconciles cleanly.
+ */
+export declare function mountRouter(options: MountRouterOptions): void;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAenE,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,oGAAoG;AACpG,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,GAAG,IAAI,CAE/F;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAI7D"}

package/dist/client.js

@@ -0,0 +1,30 @@
+/**
+ * @nifrajs/web-svelte/client — Svelte 5 client runtime. `hydrate` hydrates a single SSR'd route via the
+ * recursive `Chain`; `mountRouter` hydrates the reactive `Router` component, which subscribes to the
+ * agnostic store and re-renders the matched chain on every client navigation (no full reload). Both
+ * use Svelte's `hydrate` (reconcile against the SSR markup). Kept in its own entry so server code
+ * stays out of the client bundle.
+ */
+import { hydrate as svelteHydrate } from "svelte";
+import Chain from "./Chain.svelte";
+import { setMountedRouter } from "./fetcher.js";
+import Router from "./Router.svelte";
+// The `_error` boundary marker — Chain.svelte renders it as a <svelte:boundary>. Re-exported here so
+// nifra's client codegen resolves it from `@nifrajs/web-svelte/client` alongside `mountRouter`.
+export { errorBoundary } from "./error.js";
+/** Hydrate a server-rendered Svelte layout `chain` (with the loader `props`) inside `container`. */
+export function hydrate(chain, props, container) {
+    svelteHydrate(Chain, { target: container, props: { chain, props } });
+}
+/**
+ * Hydrate a stateful Svelte Router. The `Router` component holds the store snapshot in `$state` and
+ * re-renders the matched layout chain on each store change — so client navigations swap routes without
+ * a full reload. Its initial render matches the SSR markup (the server rendered `Chain` for the same
+ * matched route), so hydration reconciles cleanly.
+ */
+export function mountRouter(options) {
+    const { router, routes, container } = options;
+    setMountedRouter(router); // expose it to useFetcher/useFetchers (same page, client-only)
+    svelteHydrate(Router, { target: container, props: { router, routes } });
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AACH,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,QAAQ,CAAA;AACjD,OAAO,KAAK,MAAM,gBAAgB,CAAA;AAClC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,MAAM,MAAM,iBAAiB,CAAA;AAEpC,qGAAqG;AACrG,gGAAgG;AAChG,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,oGAAoG;AACpG,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB,EAAE,SAAkB;IACvF,aAAa,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,SAAoB,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAA;AACjF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,OAA2B;IACrD,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAA;IAC7C,gBAAgB,CAAC,MAAM,CAAC,CAAA,CAAC,+DAA+D;IACxF,aAAa,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,SAAoB,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,CAAA;AACpF,CAAC"}

package/dist/error.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `errorBoundary` — the Svelte `_error.tsx` boundary chain element. Svelte components are compiled (not
+ * JS closures), so unlike the other adapters this can't return a component bound to `fallback`. Instead
+ * it returns a **marker** that `Chain.svelte` recognises and renders as a `<svelte:boundary>` (Svelte
+ * 5.3+) with `fallback` as the `failed` snippet. Re-exported from `@nifrajs/web-svelte/client` so nifra's
+ * client codegen inserts it before the page in the matched chain.
+ */
+export interface NifraSvelteErrorBoundary {
+    readonly __nifraErrorBoundary: unknown;
+}
+/** Wrap a route's `_error` component as a boundary marker for `Chain.svelte` to render. */
+export declare function errorBoundary(fallback: unknown): NifraSvelteErrorBoundary;
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAA;CACvC;AAED,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,GAAG,wBAAwB,CAEzE"}

package/dist/error.js

@@ -0,0 +1,5 @@
+/** Wrap a route's `_error` component as a boundary marker for `Chain.svelte` to render. */
+export function errorBoundary(fallback) {
+    return { __nifraErrorBoundary: fallback };
+}
+//# sourceMappingURL=error.js.map

package/dist/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAWA,2FAA2F;AAC3F,MAAM,UAAU,aAAa,CAAC,QAAiB;IAC7C,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,CAAA;AAC3C,CAAC"}

package/dist/fetcher.d.ts

@@ -0,0 +1,36 @@
+import type { ClientRouter, Fetcher, FetcherState } from "@nifrajs/web";
+/**
+ * `@nifrajs/web-svelte/fetcher` — Svelte bindings for concurrent fetchers, as **Svelte stores** (plain
+ * `.ts`, no runes/compiler needed). `useFetcher(key)` returns a `Readable<FetcherState>` augmented with
+ * `load`/`submit` — read it reactively in a component with `$fetcher` (auto-subscription), call
+ * `fetcher.load(...)` / `fetcher.submit(...)` imperatively. `useFetchers()` returns the live collection
+ * as a store. The store's start/stop notifier subscribes to the agnostic store lazily (on the first
+ * `$`-subscription) and unsubscribes on the last — so lifecycle is tied to the component automatically.
+ *
+ * The router that owns the fetchers is the one `mountRouter` hydrated — it registers itself here via
+ * `setMountedRouter`. On the server (no mount) there is no router, so the stores hold an idle value
+ * (fetchers are client-only); the first client render starts from the same idle snapshot — no mismatch.
+ */
+import { type Readable } from "svelte/store";
+/** Register (or clear) the router that owns fetchers — called by `mountRouter`. Not for app use. */
+export declare function setMountedRouter(router: ClientRouter | undefined): void;
+/** A fetcher store: a `Readable<FetcherState>` (read via `$`) plus imperative `load`/`submit`. */
+export type FetcherStore = Readable<FetcherState> & {
+    /** Load a route path's loader data into this fetcher (concurrent; doesn't touch the active view). */
+    readonly load: (path: string) => Promise<void>;
+    /** Submit an action into this fetcher (concurrent); honors `X-Nifra-Revalidate`. */
+    readonly submit: (action: string, body: NonNullable<RequestInit["body"]>) => Promise<void>;
+};
+/**
+ * Subscribe to the independent fetcher for `key` (created lazily, stable across renders). Returns a
+ * store of its state (`pending`/`data`/`actionData`/`submission`) augmented with `load`/`submit`.
+ * Multiple `useFetcher` calls with different keys run concurrently without disturbing the active route.
+ */
+export declare function useFetcher(key: string): FetcherStore;
+/**
+ * Subscribe to the whole live fetcher collection — for a global busy view (e.g. "3 saving…"). Read
+ * each entry's `.snapshot()` for its state. The store updates whenever any fetcher transitions or a
+ * new one is created.
+ */
+export declare function useFetchers(): Readable<readonly Fetcher[]>;
+//# sourceMappingURL=fetcher.d.ts.map

package/dist/fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetcher.d.ts","sourceRoot":"","sources":["../src/fetcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACvE;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,KAAK,QAAQ,EAAY,MAAM,cAAc,CAAA;AAMtD,oGAAoG;AACpG,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI,CAEvE;AAKD,kGAAkG;AAClG,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,YAAY,CAAC,GAAG;IAClD,qGAAqG;IACrG,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9C,oFAAoF;IACpF,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3F,CAAA;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAWpD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,QAAQ,CAAC,SAAS,OAAO,EAAE,CAAC,CAO1D"}

package/dist/fetcher.js

@@ -0,0 +1,55 @@
+/**
+ * `@nifrajs/web-svelte/fetcher` — Svelte bindings for concurrent fetchers, as **Svelte stores** (plain
+ * `.ts`, no runes/compiler needed). `useFetcher(key)` returns a `Readable<FetcherState>` augmented with
+ * `load`/`submit` — read it reactively in a component with `$fetcher` (auto-subscription), call
+ * `fetcher.load(...)` / `fetcher.submit(...)` imperatively. `useFetchers()` returns the live collection
+ * as a store. The store's start/stop notifier subscribes to the agnostic store lazily (on the first
+ * `$`-subscription) and unsubscribes on the last — so lifecycle is tied to the component automatically.
+ *
+ * The router that owns the fetchers is the one `mountRouter` hydrated — it registers itself here via
+ * `setMountedRouter`. On the server (no mount) there is no router, so the stores hold an idle value
+ * (fetchers are client-only); the first client render starts from the same idle snapshot — no mismatch.
+ */
+import { readable } from "svelte/store";
+// The active client router (set by `mountRouter`). Module-scoped: the browser mounts one app per
+// page, and fetchers never exist on the server. Shared with `client.ts`'s `mountRouter`.
+let mountedRouter;
+/** Register (or clear) the router that owns fetchers — called by `mountRouter`. Not for app use. */
+export function setMountedRouter(router) {
+    mountedRouter = router;
+}
+const IDLE = { pending: false, data: undefined };
+const noopAsync = async () => { };
+/**
+ * Subscribe to the independent fetcher for `key` (created lazily, stable across renders). Returns a
+ * store of its state (`pending`/`data`/`actionData`/`submission`) augmented with `load`/`submit`.
+ * Multiple `useFetcher` calls with different keys run concurrently without disturbing the active route.
+ */
+export function useFetcher(key) {
+    const fetcher = mountedRouter?.fetcher(key);
+    const store = readable(fetcher ? fetcher.snapshot() : IDLE, (set) => {
+        if (fetcher === undefined)
+            return;
+        set(fetcher.snapshot());
+        return fetcher.subscribe(() => set(fetcher.snapshot()));
+    });
+    return Object.assign(store, {
+        load: fetcher?.load ?? noopAsync,
+        submit: fetcher?.submit ?? noopAsync,
+    });
+}
+/**
+ * Subscribe to the whole live fetcher collection — for a global busy view (e.g. "3 saving…"). Read
+ * each entry's `.snapshot()` for its state. The store updates whenever any fetcher transitions or a
+ * new one is created.
+ */
+export function useFetchers() {
+    const router = mountedRouter;
+    return readable(router ? router.fetchers() : [], (set) => {
+        if (router === undefined)
+            return;
+        set(router.fetchers());
+        return router.subscribeFetchers(() => set(router.fetchers()));
+    });
+}
+//# sourceMappingURL=fetcher.js.map

package/dist/fetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetcher.js","sourceRoot":"","sources":["../src/fetcher.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;GAWG;AACH,OAAO,EAAiB,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEtD,iGAAiG;AACjG,yFAAyF;AACzF,IAAI,aAAuC,CAAA;AAE3C,oGAAoG;AACpG,MAAM,UAAU,gBAAgB,CAAC,MAAgC;IAC/D,aAAa,GAAG,MAAM,CAAA;AACxB,CAAC;AAED,MAAM,IAAI,GAAiB,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,CAAA;AAC9D,MAAM,SAAS,GAAG,KAAK,IAAmB,EAAE,GAAE,CAAC,CAAA;AAU/C;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,GAAW;IACpC,MAAM,OAAO,GAAG,aAAa,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;IAC3C,MAAM,KAAK,GAAG,QAAQ,CAAe,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE;QAChF,IAAI,OAAO,KAAK,SAAS;YAAE,OAAM;QACjC,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAA;QACvB,OAAO,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAA;IACzD,CAAC,CAAC,CAAA;IACF,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE;QAC1B,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,SAAS;QAChC,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,SAAS;KACrC,CAAC,CAAA;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW;IACzB,MAAM,MAAM,GAAG,aAAa,CAAA;IAC5B,OAAO,QAAQ,CAAqB,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE;QAC3E,IAAI,MAAM,KAAK,SAAS;YAAE,OAAM;QAChC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAA;QACtB,OAAO,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAA;IAC/D,CAAC,CAAC,CAAA;AACJ,CAAC"}

package/dist/i18n.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `@nifrajs/web-svelte/i18n` — Svelte bindings for `@nifrajs/i18n`: the `<I18nProvider>` component (re-exported
+ * from `I18nProvider.svelte`) plus `useT()`, which reads the provided `Formatter` from Svelte context.
+ * Call `useT()` during a component's initialization (like any `getContext`).
+ */
+import type { Formatter } from "@nifrajs/i18n";
+export { default as I18nProvider, type I18nProviderProps } from "./I18nProvider.svelte";
+/** Read the current {@link Formatter} (`{ locale, t, n, d }`). Throws if no `<I18nProvider>` is above.
+ * nifra switches locale by re-navigating, which re-runs the consuming component with the new catalog. */
+export declare function useT(): Formatter;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../src/i18n.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAG9C,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAMvF;yGACyG;AACzG,wBAAgB,IAAI,IAAI,SAAS,CAMhC"}

package/dist/i18n.js

@@ -0,0 +1,15 @@
+import { getContext } from "svelte";
+export { default as I18nProvider } from "./I18nProvider.svelte";
+// Must match the string key `I18nProvider.svelte` passes to `setContext` (a string avoids a
+// `.svelte` → `.ts` import that wouldn't resolve once the .svelte is copied to dist).
+const I18N_KEY = "@nifrajs/web-svelte:i18n";
+/** Read the current {@link Formatter} (`{ locale, t, n, d }`). Throws if no `<I18nProvider>` is above.
+ * nifra switches locale by re-navigating, which re-runs the consuming component with the new catalog. */
+export function useT() {
+    const get = getContext(I18N_KEY);
+    if (get === undefined) {
+        throw new Error("[nifra/web-svelte] useT() must be used within an <I18nProvider>");
+    }
+    return get();
+}
+//# sourceMappingURL=i18n.js.map

package/dist/i18n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.js","sourceRoot":"","sources":["../src/i18n.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AAEnC,OAAO,EAAE,OAAO,IAAI,YAAY,EAA0B,MAAM,uBAAuB,CAAA;AAEvF,4FAA4F;AAC5F,sFAAsF;AACtF,MAAM,QAAQ,GAAG,0BAA0B,CAAA;AAE3C;yGACyG;AACzG,MAAM,UAAU,IAAI;IAClB,MAAM,GAAG,GAAG,UAAU,CAAgC,QAAQ,CAAC,CAAA;IAC/D,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAA;IACpF,CAAC;IACD,OAAO,GAAG,EAAE,CAAA;AACd,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @nifrajs/web-svelte — the Svelte 5 render adapter for @nifrajs/web (server side) + the `.svelte` compiler
+ * Bun-plugin. SSR via Svelte's `render` (svelte/server), which returns HTML strings (Svelte SSR is
+ * string-based, not a stream), wrapped in a one-chunk Web `ReadableStream` (the seam's shape). The
+ * layout-chain fold is the recursive `Chain.svelte`. Client hydration lives in `@nifrajs/web-svelte/client`.
+ * Svelte components compile from `.svelte` files, so this adapter ships a build plugin (like
+ * `@nifrajs/web-solid`'s Babel plugin) — there is no callable-component runtime.
+ */
+import type { RenderAdapter } from "@nifrajs/web";
+export { svelteBunPlugin } from "./plugin.js";
+/** The Svelte server render adapter — pass to @nifrajs/web's `renderPage`. */
+export declare const svelteAdapter: RenderAdapter;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAOjD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAa7C,8EAA8E;AAC9E,eAAO,MAAM,aAAa,EAAE,aAqB3B,CAAA"}

package/dist/index.js

@@ -0,0 +1,40 @@
+import { render } from "svelte/server";
+import Chain from "./Chain.svelte";
+// Re-export the compiler plugin for convenience. NOTE: the SSR preload must import it from
+// `@nifrajs/web-svelte/plugin` (not from here) — importing this module eagerly loads `Chain.svelte`,
+// which must be compiled by the already-registered plugin.
+export { svelteBunPlugin } from "./plugin.js";
+// Svelte SSR yields a complete HTML string; the seam wants a stream, so emit it as one chunk.
+function oneChunk(html) {
+    const bytes = new TextEncoder().encode(html);
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue(bytes);
+            controller.close();
+        },
+    });
+}
+/** The Svelte server render adapter — pass to @nifrajs/web's `renderPage`. */
+export const svelteAdapter = {
+    // Svelte SSR is already synchronous + string-based, so this is the native shape: `renderToString`
+    // returns the body directly (renderPage buffers it on the non-deferred fast path), and
+    // `renderToStream` wraps the same string in a one-chunk stream for the deferred path. No streaming
+    // renderer to skip here — but going straight to a string avoids the per-request stream allocation.
+    renderToString(chain, props) {
+        return render(Chain, { props: { chain, props } }).body;
+    },
+    renderToStream(chain, props) {
+        // `Chain` folds the layout chain (page innermost gets `props`; layouts wrap via their `children`
+        // snippet). Svelte's `render` returns { head, body }; the body goes into #root. (Svelte's dynamic
+        // `head` — from <svelte:head> — isn't surfaced through the seam's static `hydrationHead`; nifra's
+        // own meta/head API manages the document head instead.)
+        const { body } = render(Chain, { props: { chain, props } });
+        return oneChunk(body);
+    },
+    // Svelte's client `hydrate` reconciles against the existing DOM; no per-document bootstrap script is
+    // needed (contrast Solid's generateHydrationScript) — the seam allows the empty string.
+    hydrationHead() {
+        return "";
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AACtC,OAAO,KAAK,MAAM,gBAAgB,CAAA;AAElC,2FAA2F;AAC3F,qGAAqG;AACrG,2DAA2D;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAE7C,8FAA8F;AAC9F,SAAS,QAAQ,CAAC,IAAY;IAC5B,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC5C,OAAO,IAAI,cAAc,CAAC;QACxB,KAAK,CAAC,UAAU;YACd,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;YACzB,UAAU,CAAC,KAAK,EAAE,CAAA;QACpB,CAAC;KACF,CAAC,CAAA;AACJ,CAAC;AAED,8EAA8E;AAC9E,MAAM,CAAC,MAAM,aAAa,GAAkB;IAC1C,kGAAkG;IAClG,uFAAuF;IACvF,mGAAmG;IACnG,mGAAmG;IACnG,cAAc,CAAC,KAAK,EAAE,KAAK;QACzB,OAAO,MAAM,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,IAAI,CAAA;IACxD,CAAC;IACD,cAAc,CAAC,KAAK,EAAE,KAAK;QACzB,iGAAiG;QACjG,kGAAkG;QAClG,kGAAkG;QAClG,wDAAwD;QACxD,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAA;QAC3D,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAA;IACvB,CAAC;IACD,qGAAqG;IACrG,wFAAwF;IACxF,aAAa;QACX,OAAO,EAAE,CAAA;IACX,CAAC;CACF,CAAA"}

package/dist/mdx.d.ts

@@ -0,0 +1,5 @@
+import type { BunPlugin } from "bun";
+/** Build a `Bun.build` plugin that loads `.mdx` files as Svelte components via mdsvex. `generate`:
+ * `"ssr"` for the server build, `"dom"` for the client (matches `svelteBunPlugin`). */
+export declare function svelteMdxBunPlugin(generate: "dom" | "ssr"): BunPlugin;
+//# sourceMappingURL=mdx.d.ts.map

package/dist/mdx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mdx.d.ts","sourceRoot":"","sources":["../src/mdx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAsBpC;uFACuF;AACvF,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,CA+CrE"}