@nifrajs/web-svelte 2.1.0 → 2.3.0

package/README.md

@@ -1,8 +1,8 @@
 # @nifrajs/web-svelte
 
-Svelte 5 render adapter for @nifrajs/web — SSR + hydration + the .svelte compiler Bun-plugin.
+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`.
+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
 
@@ -19,7 +19,7 @@ MIT
 
 ## For AI agents
 
-Start with [`LLM.md`](./LLM.md) — this package's contract card (the exports you call + its footguns),
+Start with [`LLM.md`](./LLM.md) - this package's contract card (the exports you call + its footguns),
 one cheap read instead of the whole corpus. For the wider framework: the repo's
 [`AGENTS.md`](../../AGENTS.md) is the copy-paste quick reference, and
 [`llms-full.txt`](../../llms-full.txt) is the full machine-readable corpus. Run `nifra check` as the

package/dist/Await.svelte

@@ -1,9 +1,9 @@
 <!--
-  Await.svelte — the `<Await>` primitive for deferred loader/action data (`defer()`), built on Svelte's
+  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
+  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.

package/dist/Chain.svelte

@@ -1,13 +1,23 @@
 <!--
-  Chain.svelte — folds a nifra layout chain (outermost layout → page) into nested Svelte components:
+  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
+  analogue of the React/Vue `compose` - Svelte components are compiled (not callable), so the fold is a
   component, not a function returning a node.
+
+  `layoutData` is the per-layout loader data, aligned with the chain's LEADING layout prefix. It is
+  sliced in lockstep with `chain` as each layout is consumed, so a layout always reads its own entry.
+  The `_error` boundary marker deliberately does NOT consume from it: the marker sits after every
+  layout, so the array is already empty by then, and leaving it alone keeps that true if it ever moves.
 -->
 <script>
+  import { setContext } from "svelte"
   import Self from "./Chain.svelte"
-  let { chain, props } = $props()
+  let { chain, props, layoutData } = $props()
+  // Provide the validated search as a getter (so `useSearch` reads the current value reactively) - the
+  // same value the server put in RenderProps.search, so a query-reading page hydrates with no drift. The
+  // key string is kept in sync with router.ts's `useSearch`.
+  setContext("@nifrajs/web-svelte:search", () => props.search ?? {})
 </script>
 
 {#if chain.length <= 1}
@@ -20,16 +30,16 @@
        `failed` snippet renders the route's _error component with the serialized error. -->
   {@const Fallback = chain[0].__nifraErrorBoundary}
   <svelte:boundary>
-    <Self chain={chain.slice(1)} {props} />
+    <Self chain={chain.slice(1)} {props} {layoutData} />
     {#snippet failed(error)}
       <Fallback data={{ name: error?.name ?? "Error", message: String(error?.message ?? error) }} />
     {/snippet}
   </svelte:boundary>
 {:else}
   {@const Layout = chain[0]}
-  <Layout>
+  <Layout data={layoutData?.[0] ?? null}>
     {#snippet children()}
-      <Self chain={chain.slice(1)} {props} />
+      <Self chain={chain.slice(1)} {props} layoutData={layoutData?.slice(1)} />
     {/snippet}
   </Layout>
 {/if}

package/dist/Content.svelte

@@ -1,10 +1,10 @@
 <!--
-  Content.svelte — render trusted pre-rendered HTML (e.g. a @nifrajs/content collection entry's `.html`)
+  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.
+  build/server time) - never pass user-supplied HTML without sanitizing it first. Plain-JS script.
 -->
 <script>
   let { html, as = "div", ...rest } = $props()

package/dist/I18nProvider.svelte

@@ -1,5 +1,5 @@
 <!--
-  I18nProvider.svelte — provides a nifra i18n `Formatter` (built from `locale` + `messages`) to the
+  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

package/dist/Image.svelte

@@ -1,9 +1,9 @@
 <!--
-  Image.svelte — a CLS-safe responsive <Image> for nifra + Svelte. A thin wrapper over `resolveImage` +
+  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
+  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
+  (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>

package/dist/Image.svelte.d.ts

@@ -21,7 +21,7 @@ type ComputedAttrs =
 export interface ImageComponentProps
   extends ImageProps,
     Omit<HTMLImgAttributes, ComputedAttrs | keyof ImageProps> {
-  /** CDN URL builder. Defaults to the identity loader (no transform — still CLS-safe + lazy). */
+  /** CDN URL builder. Defaults to the identity loader (no transform - still CLS-safe + lazy). */
   loader?: ImageLoader
 }
 

package/dist/Router.svelte

@@ -1,26 +1,33 @@
 <!--
-  Router.svelte — the reactive root for client navigation. Holds the agnostic store's snapshot in
+  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
+  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 { searchOfChain } from "@nifrajs/web"
   import Chain from "./Chain.svelte"
-  let { router, routes } = $props()
+  let { router, routes, searchSchemas } = $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 } : {}),
+  let props = $derived.by(() => {
+    // This route's typed search from the URL + schema chain (the SAME searchOfChain the server ran), so
+    // useSearch stays reactive across navigation and matches the SSR value on hydration.
+    const q = snapshot.path.indexOf("?")
+    return {
+      data: snapshot.data,
+      actionData: snapshot.actionData,
+      pending: snapshot.pending,
+      search: searchOfChain(searchSchemas?.[snapshot.routeId] ?? [], q === -1 ? "" : snapshot.path.slice(q)),
+      ...(snapshot.submission ? { submission: snapshot.submission } : {}),
+    }
   })
 </script>
 

package/dist/client.d.ts

@@ -4,7 +4,7 @@ export { errorBoundary } from "./error.js";
 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
+ * 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.
  */

package/dist/client.d.ts.map

@@ -1 +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"}
+{"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,CAK/F;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAI7D"}

package/dist/client.js

@@ -1,5 +1,5 @@
 /**
- * @nifrajs/web-svelte/client — Svelte 5 client runtime. `hydrate` hydrates a single SSR'd route via the
+ * @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
@@ -9,22 +9,25 @@ 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
+// 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 } });
+    svelteHydrate(Chain, {
+        target: container,
+        props: { chain, props, layoutData: props.layoutData },
+    });
 }
 /**
  * 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
+ * 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;
+    const { router, routes, searchSchemas, container } = options;
     setMountedRouter(router); // expose it to useFetcher/useFetchers (same page, client-only)
-    svelteHydrate(Router, { target: container, props: { router, routes } });
+    svelteHydrate(Router, { target: container, props: { router, routes, searchSchemas } });
 }
 //# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -1 +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"}
+{"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;QACnB,MAAM,EAAE,SAAoB;QAC5B,KAAK,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE;KACtD,CAAC,CAAA;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,OAA2B;IACrD,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,GAAG,OAAO,CAAA;IAC5D,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,aAAa,EAAE,EAAE,CAAC,CAAA;AACnG,CAAC"}

package/dist/error.d.ts

@@ -1,5 +1,5 @@
 /**
- * `errorBoundary` — the Svelte `_error.tsx` boundary chain element. Svelte components are compiled (not
+ * `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

package/dist/fetcher.d.ts

@@ -1,18 +1,18 @@
 import type { ClientRouter, Fetcher, FetcherState } from "@nifrajs/web";
 /**
- * `@nifrajs/web-svelte/fetcher` — Svelte bindings for concurrent fetchers, as **Svelte stores** (plain
+ * `@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
+ * `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.
+ * `$`-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
+ * 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.
+ * (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. */
+/** 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> & {
@@ -28,7 +28,7 @@ export type FetcherStore = Readable<FetcherState> & {
  */
 export declare function useFetcher(key: string): FetcherStore;
 /**
- * Subscribe to the whole live fetcher collection — for a global busy view (e.g. "3 saving…"). Read
+ * 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.
  */

package/dist/fetcher.js

@@ -1,20 +1,20 @@
 /**
- * `@nifrajs/web-svelte/fetcher` — Svelte bindings for concurrent fetchers, as **Svelte stores** (plain
+ * `@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
+ * `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.
+ * `$`-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
+ * 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.
+ * (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. */
+/** Register (or clear) the router that owns fetchers - called by `mountRouter`. Not for app use. */
 export function setMountedRouter(router) {
     mountedRouter = router;
 }
@@ -39,7 +39,7 @@ export function useFetcher(key) {
     });
 }
 /**
- * Subscribe to the whole live fetcher collection — for a global busy view (e.g. "3 saving…"). Read
+ * 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.
  */

package/dist/fn.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `@nifrajs/web-svelte/fn` - Svelte binding for a server function's pending/error state.
+ *
+ * Calling a server function needs no hook: the client stub is `(input) => Promise<Output>`. This adds
+ * the part a component usually wants around it - in flight, last result, last error - and nothing more.
+ *
+ * The state machine is `@nifrajs/web`'s `createServerFnStore`, shared with every other adapter, so
+ * "is it pending" has one answer rather than five that drift. This file contributes only a `readable` fed by the store.
+ */
+import type { ServerFnReference } from "@nifrajs/web/fn";
+import { type ServerFnState } from "@nifrajs/web/fn-state";
+import { type Readable } from "svelte/store";
+/** A server function's readable state plus the call itself. */
+export interface ServerFnHandle<Input, Output> {
+    /** Reactive state; subscribe with `$state` in a component. */
+    readonly state: Readable<ServerFnState<Output>>;
+    /** Invoke it. Records state, and rejects on failure - attach `.catch` if you only render state. */
+    readonly call: (input: Input) => Promise<Output>;
+    /** Back to idle. */
+    readonly reset: () => void;
+}
+/**
+ * Track one server function's call state.
+ *
+ * The `readable` subscribes on first use and unsubscribes when the last subscriber leaves, so a
+ * component that never reads the state never attaches a listener.
+ */
+export declare function useServerFn<Input, Output>(fn: ServerFnReference<Input, Output>): ServerFnHandle<Input, Output>;
+//# sourceMappingURL=fn.d.ts.map

package/dist/fn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn.d.ts","sourceRoot":"","sources":["../src/fn.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxE,OAAO,EAA0C,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAClG,OAAO,EAAE,KAAK,QAAQ,EAAY,MAAM,cAAc,CAAA;AAEtD,+DAA+D;AAC/D,MAAM,WAAW,cAAc,CAAC,KAAK,EAAE,MAAM;IAC3C,8DAA8D;IAC9D,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAA;IAC/C,mGAAmG;IACnG,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAChD,oBAAoB;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAA;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EACvC,EAAE,EAAE,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,GACnC,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,CAY/B"}

package/dist/fn.js

@@ -0,0 +1,31 @@
+/**
+ * `@nifrajs/web-svelte/fn` - Svelte binding for a server function's pending/error state.
+ *
+ * Calling a server function needs no hook: the client stub is `(input) => Promise<Output>`. This adds
+ * the part a component usually wants around it - in flight, last result, last error - and nothing more.
+ *
+ * The state machine is `@nifrajs/web`'s `createServerFnStore`, shared with every other adapter, so
+ * "is it pending" has one answer rather than five that drift. This file contributes only a `readable` fed by the store.
+ */
+import { createServerFnStore, idleServerFnState } from "@nifrajs/web/fn-state";
+import { readable } from "svelte/store";
+/**
+ * Track one server function's call state.
+ *
+ * The `readable` subscribes on first use and unsubscribes when the last subscriber leaves, so a
+ * component that never reads the state never attaches a listener.
+ */
+export function useServerFn(fn) {
+    const store = createServerFnStore(fn);
+    const state = readable(idleServerFnState(), (set) => {
+        // Prime before subscribing, exactly as `useFetcher` does in this package. `readable` runs this
+        // start function only on the FIRST subscription, so without the snapshot a store attached after a
+        // call has already run reports its initial value - idle - for a call that finished. The four
+        // sibling adapters read a snapshot on mount, so skipping it here made Svelte the one place where
+        // "is it pending" disagreed with the shared state machine it exists to report.
+        set(store.snapshot());
+        return store.subscribe(() => set(store.snapshot()));
+    });
+    return { state, call: store.call, reset: store.reset };
+}
+//# sourceMappingURL=fn.js.map

package/dist/fn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn.js","sourceRoot":"","sources":["../src/fn.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAsB,MAAM,uBAAuB,CAAA;AAClG,OAAO,EAAiB,QAAQ,EAAE,MAAM,cAAc,CAAA;AAYtD;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CACzB,EAAoC;IAEpC,MAAM,KAAK,GAAG,mBAAmB,CAAC,EAAmC,CAAC,CAAA;IACtE,MAAM,KAAK,GAAG,QAAQ,CAAwB,iBAAiB,EAAU,EAAE,CAAC,GAAG,EAAE,EAAE;QACjF,+FAA+F;QAC/F,kGAAkG;QAClG,6FAA6F;QAC7F,iGAAiG;QACjG,+EAA+E;QAC/E,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAA;QACrB,OAAO,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAA;IACrD,CAAC,CAAC,CAAA;IACF,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAA;AACxD,CAAC"}

package/dist/i18n.d.ts

@@ -1,5 +1,5 @@
 /**
- * `@nifrajs/web-svelte/i18n` — Svelte bindings for `@nifrajs/i18n`: the `<I18nProvider>` component (re-exported
+ * `@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`).
  */

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 /**
- * @nifrajs/web-svelte — the Svelte 5 render adapter for @nifrajs/web (server side) + the `.svelte` compiler
+ * @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.
+ * `@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`. */
+/** The Svelte server render adapter - pass to @nifrajs/web's `renderPage`. */
 export declare const svelteAdapter: RenderAdapter;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,7 +1,7 @@
 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`,
+// `@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.
@@ -14,25 +14,25 @@ function oneChunk(html) {
         },
     });
 }
-/** The Svelte server render adapter — pass to @nifrajs/web's `renderPage`. */
+/** 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.
+    // 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;
+        return render(Chain, { props: { chain, props, layoutData: props.layoutData } }).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
+        // `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 } });
+        const { body } = render(Chain, { props: { chain, props, layoutData: props.layoutData } });
         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.
+    // needed (contrast Solid's generateHydrationScript) - the seam allows the empty string.
     hydrationHead() {
         return "";
     },

package/dist/index.js.map

@@ -1 +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"}
+{"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,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,IAAI,CAAA;IACtF,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,UAAU,EAAE,KAAK,CAAC,UAAU,EAAE,EAAE,CAAC,CAAA;QACzF,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.js

@@ -8,9 +8,9 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 };
 import { compile } from "svelte/compiler";
 /**
- * `@nifrajs/web-svelte/mdx` — compile `.mdx` routes/files to **Svelte** components. Svelte has no JSX
- * runtime, so (unlike the JSX-family `mdxBunPlugin`) MDX-for-Svelte goes through `mdsvex` — Svelte's
- * own Markdown compiler — which produces a `.svelte` module, then the standard `svelte/compiler` runs
+ * `@nifrajs/web-svelte/mdx` - compile `.mdx` routes/files to **Svelte** components. Svelte has no JSX
+ * runtime, so (unlike the JSX-family `mdxBunPlugin`) MDX-for-Svelte goes through `mdsvex` - Svelte's
+ * own Markdown compiler - which produces a `.svelte` module, then the standard `svelte/compiler` runs
  * (`generate: "server"` for SSR, `"client"` for the browser). Pass it to `buildClient`/`buildServer`'s
  * `plugins` alongside `svelteBunPlugin` (one handles `.svelte`, this one `.mdx`). `mdsvex` is an
  * optional peer, lazy-loaded at build time.
@@ -33,12 +33,12 @@ export function svelteMdxBunPlugin(generate) {
                 mdsvexCompile = (await import(__rewriteRelativeImportExtension(MDSVEX_MODULE))).compile;
             }
             catch {
-                throw new Error("@nifrajs/web-svelte/mdx: compiling `.mdx` for Svelte needs the `mdsvex` package — install it (`bun add mdsvex`).");
+                throw new Error("@nifrajs/web-svelte/mdx: compiling `.mdx` for Svelte needs the `mdsvex` package - install it (`bun add mdsvex`).");
             }
             build.onLoad({ filter: /\.mdx(\?|$)/ }, async (args) => {
                 const path = args.path.split("?")[0] ?? args.path;
                 // 1. Markdown/MDX → Svelte source (mdsvex). `extensions` must include `.mdx` or mdsvex skips the
-                // file (returns undefined — it only processes its configured extensions, default `.svx`).
+                // file (returns undefined - it only processes its configured extensions, default `.svx`).
                 const pre = await mdsvexCompile(await Bun.file(path).text(), {
                     filename: path,
                     extensions: [".mdx", ".svx", ".md"],

package/dist/plugin.js

@@ -1,9 +1,9 @@
 import { compile } from "svelte/compiler";
 /**
- * `@nifrajs/web-svelte/plugin` — the `.svelte` compiler Bun-plugin, in its OWN module (no `.svelte`
+ * `@nifrajs/web-svelte/plugin` - the `.svelte` compiler Bun-plugin, in its OWN module (no `.svelte`
  * imports). This matters for the SSR preload: `bun --preload` must register the plugin BEFORE any
  * `.svelte` file is loaded. Importing it from the package root (`./index`) would eagerly load
- * `Chain.svelte` (the adapter's fold) before the plugin is registered — so it lives here instead.
+ * `Chain.svelte` (the adapter's fold) before the plugin is registered - so it lives here instead.
  *
  * `generate: "server"` for SSR, `"client"` for the browser (Svelte 5's client output is hydratable).
  * Preload it for SSR (`bun --preload`) and pass it to `buildClient({ plugins: [...] })` for the client
@@ -13,12 +13,12 @@ import { compile } from "svelte/compiler";
  * the markup (both client + server output), so SSR HTML is already scoped. The **client** build emits
  * the scoped stylesheet as a virtual `?svelte-css` module that `Bun.build`'s CSS bundler folds into the
  * app stylesheet (served as a `<link>`); the SSR build drops it (the stylesheet ships from the client
- * build — no double-emit). With `nifra dev`, `@sveltejs/vite-plugin-svelte` injects the CSS instead.
+ * build - no double-emit). With `nifra dev`, `@sveltejs/vite-plugin-svelte` injects the CSS instead.
  */
 const STYLE_SUFFIX = "?svelte-css";
 const STYLE_NS = "nifra-svelte-css";
 export function svelteBunPlugin(generate) {
-    // Compiled scoped CSS per `.svelte` file (client build only) — read back by the virtual-module loader.
+    // Compiled scoped CSS per `.svelte` file (client build only) - read back by the virtual-module loader.
     const cssByPath = new Map();
     return {
         name: `nifra-svelte-${generate}`,

package/dist/query.d.ts

@@ -1,12 +1,12 @@
 import { type QueryClient, type QueryState } from "@nifrajs/web";
 /**
- * `@nifrajs/web-svelte/query` — Svelte bindings for the keyed query-cache, as **Svelte stores** (plain
- * `.ts`). `useQuery(key, fn)` returns a `Readable<QueryState<T>>` augmented with `refetch` — read it
+ * `@nifrajs/web-svelte/query` - Svelte bindings for the keyed query-cache, as **Svelte stores** (plain
+ * `.ts`). `useQuery(key, fn)` returns a `Readable<QueryState<T>>` augmented with `refetch` - read it
  * reactively with `$query`. The store fetches on mount (the start notifier fires on the first
  * `$`-subscription) and subscribes to the cache entry; concurrent `useQuery`s with the same key share
  * one entry + one in-flight fetch (dedup). `useQueryClient` exposes `invalidateQueries`.
  *
- * The query client is created lazily **client-side only** (the `typeof window` guard) — on the server
+ * The query client is created lazily **client-side only** (the `typeof window` guard) - on the server
  * there is none, so `useQuery` holds the idle/pending state (queries are client-first; loaders are the
  * SSR data source). The first client render uses the same idle snapshot, so no mismatch.
  */

package/dist/query.js

@@ -1,12 +1,12 @@
 import { createQueryClient, } from "@nifrajs/web";
 /**
- * `@nifrajs/web-svelte/query` — Svelte bindings for the keyed query-cache, as **Svelte stores** (plain
- * `.ts`). `useQuery(key, fn)` returns a `Readable<QueryState<T>>` augmented with `refetch` — read it
+ * `@nifrajs/web-svelte/query` - Svelte bindings for the keyed query-cache, as **Svelte stores** (plain
+ * `.ts`). `useQuery(key, fn)` returns a `Readable<QueryState<T>>` augmented with `refetch` - read it
  * reactively with `$query`. The store fetches on mount (the start notifier fires on the first
  * `$`-subscription) and subscribes to the cache entry; concurrent `useQuery`s with the same key share
  * one entry + one in-flight fetch (dedup). `useQueryClient` exposes `invalidateQueries`.
  *
- * The query client is created lazily **client-side only** (the `typeof window` guard) — on the server
+ * The query client is created lazily **client-side only** (the `typeof window` guard) - on the server
  * there is none, so `useQuery` holds the idle/pending state (queries are client-first; loaders are the
  * SSR data source). The first client render uses the same idle snapshot, so no mismatch.
  */

package/dist/router.d.ts

@@ -0,0 +1,45 @@
+import type { InferOutput, StandardSchemaV1 } from "@nifrajs/core/server";
+import { type Blocker, type BlockerFunction, type NavigateFunction } from "@nifrajs/web";
+/**
+ * `@nifrajs/web-svelte/router` - Svelte routing bindings over the agnostic `@nifrajs/web` history layer,
+ * as plain `.ts` (no runes/compiler needed): `useNavigate` (programmatic navigation), `useBlocker` (the
+ * unsaved-changes guard), and `useSearch` (the route's typed, validated search, as a reactive accessor).
+ * Navigation goes through `@nifrajs/web`'s DOM-free bridges (`getBrowserNavigate` / `registerBlocker`,
+ * populated by `installHistory`); `useSearch` reads the accessor `Chain.svelte` provides via Svelte
+ * context on SSR + client alike. Idle before hydration (native `<a>` navigation still works). SSR-safe.
+ */
+import { type Readable } from "svelte/store";
+export type { Blocker, BlockerFunction, BlockerState, NavigateFunction } from "@nifrajs/web";
+/**
+ * The route's typed, validated search params as a reactive accessor - the SAME value the loader received
+ * as `ctx.search`. SSR-correct: `Chain.svelte` provides it from the URL server-side and from the
+ * identical client derivation, so a value rendered from it doesn't flash on hydration. Call it (in a
+ * `$derived` or the template) to read the current search - it updates on navigation. Pass the route's
+ * `searchSchema` as the type argument for its output type.
+ *
+ * ```svelte
+ * <script>
+ *   const search = useSearch() // () => { page: number, ... }
+ * </script>
+ * <span>{search().page}</span>
+ * ```
+ */
+export declare function useSearch<Schema extends StandardSchemaV1 | undefined = undefined>(): () => Schema extends StandardSchemaV1 ? InferOutput<Schema> : Record<string, unknown>;
+/** Get the {@link NavigateFunction} (a string path, a history delta, or a typed `{ to, search }` object).
+ * Resolves the browser navigate at call time, so it works as soon as `installHistory` has run and no-ops
+ * before then / on the server. */
+export declare function useNavigate(): NavigateFunction;
+/**
+ * Guard navigation away from a page with unsaved work, confirming with your OWN async UI. Mirrors
+ * react-router's `useBlocker`: pass a boolean or a `({ currentLocation, nextLocation }) => boolean`
+ * predicate, and get back a {@link Blocker} store (read with `$blocker`). When a navigation (an anchor
+ * click, `useNavigate`, or a browser back/forward) is intercepted, `$blocker.state` becomes `"blocked"`
+ * and `proceed`/`reset` go live - show a dialog and call `proceed()` to continue or `reset()` to stay.
+ * It also arms the browser's native "Leave site?" prompt on tab close / reload. Idle on the server and
+ * before hydration.
+ *
+ * The store is created once, so to track a CHANGING flag pass a function - `useBlocker(() => dirty)` -
+ * re-evaluated at navigation time. A constant boolean is fine as-is.
+ */
+export declare function useBlocker(shouldBlock: boolean | BlockerFunction): Readable<Blocker>;
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACzE,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,eAAe,EAGpB,KAAK,gBAAgB,EAKtB,MAAM,cAAc,CAAA;AAErB;;;;;;;GAOG;AACH,OAAO,EAAE,KAAK,QAAQ,EAAY,MAAM,cAAc,CAAA;AAEtD,YAAY,EAAE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAQ5F;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACvB,MAAM,SAAS,gBAAgB,GAAG,SAAS,GAAG,SAAS,KACpD,MAAM,MAAM,SAAS,gBAAgB,GAAG,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzF;AAED;;kCAEkC;AAClC,wBAAgB,WAAW,IAAI,gBAAgB,CAO9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,WAAW,EAAE,OAAO,GAAG,eAAe,GAAG,QAAQ,CAAC,OAAO,CAAC,CAOpF"}