@lankajs/svelte 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lankajs contributors
+
+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,42 @@
+# @lankajs/svelte
+
+**▸ module** · Svelte binding
+
+> One function — `useLankaVM` — over `createSubscriber`, and the access tracking core already does.
+
+A library in the same box. The app imports and calls it; core does not know it exists.
+
+**Runs in:** the browser.
+
+**Requires:** Svelte. Enforced by `check-runtime.mjs`, which refuses an import of any other.
+
+**How to use it:** [GUIDE.md](./GUIDE.md) — the user guide, with examples. **How to change it:** [SKILL.md](./SKILL.md).
+
+## Contents
+
+- `useLankaVM` — the one name, and the same one every member of this shelf publishes
+- `renderWithLanka` (from `@lankajs/svelte/testing`) — a render with a bootstrapped framework
+
+## `createSubscriber`, not the store contract
+
+Svelte 5 reads a `{ subscribe }` object as a store, and a ViewModel nearly is one —
+the shapes differ only in that Svelte calls the listener immediately and lanka does
+not. Bridging that is two lines, and it was rejected anyway: the store contract is
+Svelte 4's way, it does not compose with `$state`, and a consumer would have written
+`$todoVM` where every other framework writes a plain read.
+
+`createSubscriber` from `svelte/reactivity` is the current answer, and it is plain
+TypeScript — which is why this package needs no compiler and builds with `tsup` like
+every other one here. What a consumer gets back is an object whose properties are
+getters, so reading one inside an effect or a template subscribes to it.
+
+## The getters are the tracking, not a convenience
+
+Svelte's reactivity is read-driven: it knows what an effect depends on because the
+effect READ it. That is the same question `createLankaAccessTracker` answers, so the
+two line up exactly — a component reading `state.todos` records `todos` in the
+tracker AND registers with Svelte's graph in one access.
+
+---
+
+Repository map: [../../../README.md](../../../README.md)

package/dist/chunk-5WRI5ZAA.js

@@ -0,0 +1,31 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};
+//# sourceMappingURL=chunk-5WRI5ZAA.js.map

package/dist/chunk-5WRI5ZAA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,130 @@
+import { ILankaReadableVM } from 'lanka/viewmodel';
+
+/** How a subscriber stops listening. */
+type TLankaVMUnsubscriber = () => void;
+/**
+ * Svelte's store contract, which is an interface and not a class — satisfied by
+ * a ViewModel rather than by a store of ours.
+ *
+ * One method. Anything with it works with `$store`, `derived`, `get` and every
+ * helper in `svelte/store` — which is the whole reason the contract is that
+ * small.
+ */
+interface ILankaSvelteVM<TValue> {
+    subscribe: (run: (value: TValue) => void) => TLankaVMUnsubscriber;
+}
+/**
+ * A ViewModel that satisfies Svelte's store contract, so `$` works on it.
+ *
+ * ```svelte
+ * <script lang="ts">
+ * 	import { toLankaSvelteVM } from "@lankajs/svelte";
+ * 	const todos = toLankaSvelteVM(todosVM);
+ * </script>
+ *
+ * {#each $todos.rows as row}<li>{row}</li>{/each}
+ * ```
+ *
+ * ## Why this exists beside `useLankaVM`
+ *
+ * `useLankaVM` answers an object of getters, which is Svelte 5's own shape and
+ * the right default: a read registers with the reactivity graph and with the
+ * access tracker in ONE access, and nothing needs a `$`.
+ *
+ * The store contract is the other half of Svelte, and it has not gone anywhere.
+ * `$page`, `$navigating` and every store SvelteKit hands a route are read with a
+ * `$`; `derived`, `get` and `writable` all speak it; and a codebase that has not
+ * moved to runes speaks nothing else. A consumer with that habit reaches for
+ * `$todosVM`, and without this they are told a ViewModel is not a store.
+ *
+ * ## It is the same subscription
+ *
+ * One `subscribe` on the ViewModel per Svelte subscriber, the access tracker's
+ * decision about whether a change is worth an update, and no state of its own —
+ * the rules the parity canon sets for an idiom. What it does NOT do is share one
+ * ViewModel subscription between Svelte subscribers: each gets its own tracker,
+ * because two readers of one ViewModel read different keys and must be woken for
+ * different changes. That is the same rule every binding on the shelf follows.
+ *
+ * ## The contract's own rule: call `run` immediately
+ *
+ * Svelte requires the current value on subscription, synchronously, before
+ * `subscribe` returns — `$store` reads it during the component's first render
+ * and would otherwise be `undefined`. `subscribe` on the ViewModel does NOT fire
+ * on registration, which is correct for a port and is why the first call is made
+ * here by hand.
+ */
+declare const toLankaSvelteVM: <TState extends object>(viewModel: ILankaReadableVM<TState>) => ILankaSvelteVM<TState>;
+
+/** A ViewModel read from Svelte: the state by getters, and a way to stop reading. */
+/**
+ * What a TRACKED read answers: the state's own keys, as getters.
+ *
+ * Reading one registers with Svelte's graph and with the access tracker in a
+ * single access, which is why this shape and not a ref.
+ */
+type TLankaVMView<TValue> = TValue & {
+    stop: () => void;
+};
+/**
+ * What a SELECTED read answers: one value, under `current`.
+ *
+ * `.current` is Svelte's own convention for a reactive value a class exposes —
+ * `MediaQuery` and the rest of `svelte/reactivity` read that way — so a consumer
+ * needs no explanation.
+ *
+ * A getter object rather than the state's keys, and that is not a preference. A
+ * selector may answer anything, including a number, and there are no keys to
+ * define on a number: the shape that carried the selection's own keys accepted
+ * `TSelected extends object` and refused `(state) => state.count`, which is a
+ * member of this shelf NARROWING the shared name. The conformance suite's
+ * selector scenes found it.
+ */
+type TLankaVMSelectedView<TSelected> = {
+    readonly current: TSelected;
+    stop: () => void;
+};
+/**
+ * Reads a ViewModel from Svelte.
+ *
+ * ```svelte
+ * <script lang="ts">
+ *   const state = useLankaVM(todoVM);
+ * </script>
+ *
+ * {#each state.todos as todo (todo.id)}
+ *   <li>{todo.title}</li>
+ * {/each}
+ * ```
+ *
+ * Without a selector the view records which keys were read and updates only when
+ * one of THOSE moves. With a selector the selector decides and tracking is
+ * bypassed.
+ *
+ * ## `createSubscriber`, and not the store contract
+ *
+ * Svelte reads a `{ subscribe }` object as a store, and a ViewModel nearly is
+ * one — the shapes differ only in that Svelte calls the listener immediately.
+ * Bridging that is two lines and was rejected anyway: the store contract is
+ * Svelte 4's way, it does not compose with `$state`, and a consumer would write
+ * `$todoVM` where every other framework writes a plain read.
+ *
+ * `createSubscriber` is plain TypeScript, which is why this package needs no
+ * compiler and builds like every other one here.
+ *
+ * ## Why the properties are getters
+ *
+ * Svelte's reactivity is read-driven: an effect depends on what it READ. That is
+ * the same question `createLankaAccessTracker` answers, so the two line up
+ * exactly — reading `state.todos` records `todos` in the tracker AND registers
+ * the effect with Svelte's graph, in one access.
+ *
+ * ## What this function does NOT contain
+ *
+ * The recording, the comparison and the blind-spot warning are in core. If this
+ * file ever needs more than the port gives it, the port has the defect.
+ */
+declare function useLankaVM<TState extends object>(viewModel: ILankaReadableVM<TState>): TLankaVMView<TState>;
+declare function useLankaVM<TState extends object, TSelected>(viewModel: ILankaReadableVM<TState>, selector: (state: TState) => TSelected): TLankaVMSelectedView<TSelected>;
+
+export { type ILankaSvelteVM, type TLankaVMUnsubscriber, type TLankaVMView, toLankaSvelteVM, useLankaVM };

package/dist/index.js

@@ -0,0 +1,78 @@
+import "./chunk-5WRI5ZAA.js";
+
+// src/to-lanka-svelte-vm/toLankaSvelteVM.ts
+import { createLankaViewSubscription } from "lanka/extend";
+var toLankaSvelteVM = (viewModel) => ({
+  subscribe: (run) => {
+    const view = createLankaViewSubscription(viewModel, () => run(view.read()));
+    run(view.read());
+    return view.stop;
+  }
+});
+
+// src/use-lanka-vm/useLankaVM.ts
+import { createSubscriber } from "svelte/reactivity";
+import { createLankaAccessTracker } from "lanka/extend";
+function useLankaVM(viewModel, selector) {
+  const tracker = createLankaAccessTracker(viewModel);
+  let stop = () => void 0;
+  let selected = selector ? selector(viewModel.getState()) : void 0;
+  const subscribe = createSubscriber((update) => {
+    stop = viewModel.subscribe((next, prev) => {
+      if (selector) {
+        const picked = selector(next);
+        if (Object.is(picked, selected)) return;
+        selected = picked;
+        update();
+        return;
+      }
+      if (!tracker.shouldNotify(next, prev)) {
+        tracker.reportSkipped(next, prev);
+        return;
+      }
+      update();
+    });
+    return () => {
+      stop();
+    };
+  });
+  if (selector) {
+    const selectedView = {};
+    Object.defineProperty(selectedView, "current", {
+      enumerable: true,
+      get: () => {
+        subscribe();
+        return selector(viewModel.getState());
+      }
+    });
+    Object.defineProperty(selectedView, "stop", {
+      enumerable: false,
+      value: () => {
+        stop();
+      }
+    });
+    return selectedView;
+  }
+  const view = {};
+  for (const key of Object.keys(viewModel.getState())) {
+    Object.defineProperty(view, key, {
+      enumerable: true,
+      get: () => {
+        subscribe();
+        return tracker.read()[key];
+      }
+    });
+  }
+  Object.defineProperty(view, "stop", {
+    enumerable: false,
+    value: () => {
+      stop();
+    }
+  });
+  return view;
+}
+export {
+  toLankaSvelteVM,
+  useLankaVM
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/to-lanka-svelte-vm/toLankaSvelteVM.ts","../src/use-lanka-vm/useLankaVM.ts"],"sourcesContent":["import { createLankaViewSubscription } from \"lanka/extend\";\nimport type { ILankaReadableVM } from \"lanka/viewmodel\";\n\n/** How a subscriber stops listening. */\nexport type TLankaVMUnsubscriber = () => void;\n\n/**\n * Svelte's store contract, which is an interface and not a class — satisfied by\n * a ViewModel rather than by a store of ours.\n *\n * One method. Anything with it works with `$store`, `derived`, `get` and every\n * helper in `svelte/store` — which is the whole reason the contract is that\n * small.\n */\nexport interface ILankaSvelteVM<TValue> {\n\tsubscribe: (run: (value: TValue) => void) => TLankaVMUnsubscriber;\n}\n\n/**\n * A ViewModel that satisfies Svelte's store contract, so `$` works on it.\n *\n * ```svelte\n * <script lang=\"ts\">\n * \timport { toLankaSvelteVM } from \"@lankajs/svelte\";\n * \tconst todos = toLankaSvelteVM(todosVM);\n * </script>\n *\n * {#each $todos.rows as row}<li>{row}</li>{/each}\n * ```\n *\n * ## Why this exists beside `useLankaVM`\n *\n * `useLankaVM` answers an object of getters, which is Svelte 5's own shape and\n * the right default: a read registers with the reactivity graph and with the\n * access tracker in ONE access, and nothing needs a `$`.\n *\n * The store contract is the other half of Svelte, and it has not gone anywhere.\n * `$page`, `$navigating` and every store SvelteKit hands a route are read with a\n * `$`; `derived`, `get` and `writable` all speak it; and a codebase that has not\n * moved to runes speaks nothing else. A consumer with that habit reaches for\n * `$todosVM`, and without this they are told a ViewModel is not a store.\n *\n * ## It is the same subscription\n *\n * One `subscribe` on the ViewModel per Svelte subscriber, the access tracker's\n * decision about whether a change is worth an update, and no state of its own —\n * the rules the parity canon sets for an idiom. What it does NOT do is share one\n * ViewModel subscription between Svelte subscribers: each gets its own tracker,\n * because two readers of one ViewModel read different keys and must be woken for\n * different changes. That is the same rule every binding on the shelf follows.\n *\n * ## The contract's own rule: call `run` immediately\n *\n * Svelte requires the current value on subscription, synchronously, before\n * `subscribe` returns — `$store` reads it during the component's first render\n * and would otherwise be `undefined`. `subscribe` on the ViewModel does NOT fire\n * on registration, which is correct for a port and is why the first call is made\n * here by hand.\n */\nexport const toLankaSvelteVM = <TState extends object>(\n\tviewModel: ILankaReadableVM<TState>,\n): ILankaSvelteVM<TState> => ({\n\tsubscribe: (run) => {\n\t\tconst view = createLankaViewSubscription(viewModel, () => run(view.read()));\n\n\t\t// The contract's own rule: the current value, synchronously, before\n\t\t// `subscribe` returns. `$store` reads it during the first render and would\n\t\t// otherwise be `undefined` — and the ViewModel's `subscribe` deliberately\n\t\t// does not fire on registration, which is correct for a port.\n\t\trun(view.read());\n\n\t\treturn view.stop;\n\t},\n});\n","import { createSubscriber } from \"svelte/reactivity\";\nimport { createLankaAccessTracker } from \"lanka/extend\";\nimport type { ILankaReadableVM } from \"lanka/viewmodel\";\n\n/** A ViewModel read from Svelte: the state by getters, and a way to stop reading. */\n/**\n * What a TRACKED read answers: the state's own keys, as getters.\n *\n * Reading one registers with Svelte's graph and with the access tracker in a\n * single access, which is why this shape and not a ref.\n */\nexport type TLankaVMView<TValue> = TValue & {\n\tstop: () => void;\n};\n\n/**\n * What a SELECTED read answers: one value, under `current`.\n *\n * `.current` is Svelte's own convention for a reactive value a class exposes —\n * `MediaQuery` and the rest of `svelte/reactivity` read that way — so a consumer\n * needs no explanation.\n *\n * A getter object rather than the state's keys, and that is not a preference. A\n * selector may answer anything, including a number, and there are no keys to\n * define on a number: the shape that carried the selection's own keys accepted\n * `TSelected extends object` and refused `(state) => state.count`, which is a\n * member of this shelf NARROWING the shared name. The conformance suite's\n * selector scenes found it.\n */\nexport type TLankaVMSelectedView<TSelected> = {\n\treadonly current: TSelected;\n\tstop: () => void;\n};\n\n/**\n * Reads a ViewModel from Svelte.\n *\n * ```svelte\n * <script lang=\"ts\">\n *   const state = useLankaVM(todoVM);\n * </script>\n *\n * {#each state.todos as todo (todo.id)}\n *   <li>{todo.title}</li>\n * {/each}\n * ```\n *\n * Without a selector the view records which keys were read and updates only when\n * one of THOSE moves. With a selector the selector decides and tracking is\n * bypassed.\n *\n * ## `createSubscriber`, and not the store contract\n *\n * Svelte reads a `{ subscribe }` object as a store, and a ViewModel nearly is\n * one — the shapes differ only in that Svelte calls the listener immediately.\n * Bridging that is two lines and was rejected anyway: the store contract is\n * Svelte 4's way, it does not compose with `$state`, and a consumer would write\n * `$todoVM` where every other framework writes a plain read.\n *\n * `createSubscriber` is plain TypeScript, which is why this package needs no\n * compiler and builds like every other one here.\n *\n * ## Why the properties are getters\n *\n * Svelte's reactivity is read-driven: an effect depends on what it READ. That is\n * the same question `createLankaAccessTracker` answers, so the two line up\n * exactly — reading `state.todos` records `todos` in the tracker AND registers\n * the effect with Svelte's graph, in one access.\n *\n * ## What this function does NOT contain\n *\n * The recording, the comparison and the blind-spot warning are in core. If this\n * file ever needs more than the port gives it, the port has the defect.\n */\nexport function useLankaVM<TState extends object>(\n\tviewModel: ILankaReadableVM<TState>,\n): TLankaVMView<TState>;\n\nexport function useLankaVM<TState extends object, TSelected>(\n\tviewModel: ILankaReadableVM<TState>,\n\tselector: (state: TState) => TSelected,\n): TLankaVMSelectedView<TSelected>;\n\nexport function useLankaVM<TState extends object, TSelected>(\n\tviewModel: ILankaReadableVM<TState>,\n\tselector?: (state: TState) => TSelected,\n): TLankaVMView<TState> | TLankaVMSelectedView<TSelected> {\n\tconst tracker = createLankaAccessTracker(viewModel);\n\n\tlet stop = (): void => undefined;\n\tlet selected: TSelected | undefined = selector ? selector(viewModel.getState()) : undefined;\n\n\tconst subscribe = createSubscriber((update) => {\n\t\tstop = viewModel.subscribe((next, prev) => {\n\t\t\tif (selector) {\n\t\t\t\tconst picked = selector(next);\n\n\t\t\t\t// Only when the SELECTION moved. `update()` invalidates whoever read\n\t\t\t\t// this view, and a selected reader that invalidated on every change\n\t\t\t\t// would be narrowing what it READS and nothing else — which is what\n\t\t\t\t// the suite's selector scenes refuse.\n\t\t\t\tif (Object.is(picked, selected)) return;\n\n\t\t\t\tselected = picked;\n\t\t\t\tupdate();\n\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif (!tracker.shouldNotify(next, prev)) {\n\t\t\t\t// No update will follow. If the changed key is linked to this view\n\t\t\t\t// through a getter it read, the screen froze — and in development core\n\t\t\t\t// says so by name.\n\t\t\t\ttracker.reportSkipped(next, prev);\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tupdate();\n\t\t});\n\n\t\treturn () => {\n\t\t\tstop();\n\t\t};\n\t});\n\n\t/**\n\t * A selected read answers ONE value, under `current`.\n\t *\n\t * Svelte's own convention for a reactive value — `MediaQuery` and the rest of\n\t * `svelte/reactivity` read that way — and the only shape that can carry a\n\t * selection which is not an object.\n\t */\n\tif (selector) {\n\t\tconst selectedView = {} as Record<string, unknown>;\n\n\t\tObject.defineProperty(selectedView, \"current\", {\n\t\t\tenumerable: true,\n\t\t\tget: () => {\n\t\t\t\tsubscribe();\n\n\t\t\t\treturn selector(viewModel.getState());\n\t\t\t},\n\t\t});\n\t\tObject.defineProperty(selectedView, \"stop\", {\n\t\t\tenumerable: false,\n\t\t\tvalue: () => {\n\t\t\t\tstop();\n\t\t\t},\n\t\t});\n\n\t\treturn selectedView as TLankaVMSelectedView<TSelected>;\n\t}\n\n\t/**\n\t * One getter per key, over the keys the ViewModel has right now.\n\t *\n\t * Built from the CURRENT state rather than left to a Proxy, because Svelte's\n\t * compiler and its `$inspect` walk an object's own descriptors: a Proxy would\n\t * track correctly and show a consumer nothing in devtools.\n\t */\n\tconst view = {} as Record<string, unknown>;\n\n\tfor (const key of Object.keys(viewModel.getState())) {\n\t\tObject.defineProperty(view, key, {\n\t\t\tenumerable: true,\n\t\t\tget: () => {\n\t\t\t\tsubscribe();\n\n\t\t\t\t// `tracker.read()` and not a shared `read` helper: this getter is only\n\t\t\t\t// built on the TRACKED path — the selected view returns above it — so a\n\t\t\t\t// helper that branched on the selector carried an arm nothing could\n\t\t\t\t// reach, and an unreachable branch is a line no test can ever cover.\n\t\t\t\treturn (tracker.read() as Record<string, unknown>)[key];\n\t\t\t},\n\t\t});\n\t}\n\n\tObject.defineProperty(view, \"stop\", {\n\t\tenumerable: false,\n\t\tvalue: () => {\n\t\t\tstop();\n\t\t},\n\t});\n\n\treturn view as TLankaVMView<TState>;\n}\n"],"mappings":";;;AAAA,SAAS,mCAAmC;AA2DrC,IAAM,kBAAkB,CAC9B,eAC6B;AAAA,EAC7B,WAAW,CAAC,QAAQ;AACnB,UAAM,OAAO,4BAA4B,WAAW,MAAM,IAAI,KAAK,KAAK,CAAC,CAAC;AAM1E,QAAI,KAAK,KAAK,CAAC;AAEf,WAAO,KAAK;AAAA,EACb;AACD;;;ACzEA,SAAS,wBAAwB;AACjC,SAAS,gCAAgC;AAkFlC,SAAS,WACf,WACA,UACyD;AACzD,QAAM,UAAU,yBAAyB,SAAS;AAElD,MAAI,OAAO,MAAY;AACvB,MAAI,WAAkC,WAAW,SAAS,UAAU,SAAS,CAAC,IAAI;AAElF,QAAM,YAAY,iBAAiB,CAAC,WAAW;AAC9C,WAAO,UAAU,UAAU,CAAC,MAAM,SAAS;AAC1C,UAAI,UAAU;AACb,cAAM,SAAS,SAAS,IAAI;AAM5B,YAAI,OAAO,GAAG,QAAQ,QAAQ,EAAG;AAEjC,mBAAW;AACX,eAAO;AAEP;AAAA,MACD;AAEA,UAAI,CAAC,QAAQ,aAAa,MAAM,IAAI,GAAG;AAItC,gBAAQ,cAAc,MAAM,IAAI;AAChC;AAAA,MACD;AAEA,aAAO;AAAA,IACR,CAAC;AAED,WAAO,MAAM;AACZ,WAAK;AAAA,IACN;AAAA,EACD,CAAC;AASD,MAAI,UAAU;AACb,UAAM,eAAe,CAAC;AAEtB,WAAO,eAAe,cAAc,WAAW;AAAA,MAC9C,YAAY;AAAA,MACZ,KAAK,MAAM;AACV,kBAAU;AAEV,eAAO,SAAS,UAAU,SAAS,CAAC;AAAA,MACrC;AAAA,IACD,CAAC;AACD,WAAO,eAAe,cAAc,QAAQ;AAAA,MAC3C,YAAY;AAAA,MACZ,OAAO,MAAM;AACZ,aAAK;AAAA,MACN;AAAA,IACD,CAAC;AAED,WAAO;AAAA,EACR;AASA,QAAM,OAAO,CAAC;AAEd,aAAW,OAAO,OAAO,KAAK,UAAU,SAAS,CAAC,GAAG;AACpD,WAAO,eAAe,MAAM,KAAK;AAAA,MAChC,YAAY;AAAA,MACZ,KAAK,MAAM;AACV,kBAAU;AAMV,eAAQ,QAAQ,KAAK,EAA8B,GAAG;AAAA,MACvD;AAAA,IACD,CAAC;AAAA,EACF;AAEA,SAAO,eAAe,MAAM,QAAQ;AAAA,IACnC,YAAY;AAAA,IACZ,OAAO,MAAM;AACZ,WAAK;AAAA,IACN;AAAA,EACD,CAAC;AAED,SAAO;AACR;","names":[]}

package/dist/testing.d.ts

@@ -0,0 +1,53 @@
+import { render } from '@testing-library/svelte';
+import { IPrepareLankaRenderOptions } from '@lankajs/tool-testing';
+import { ILankaInstance } from 'lanka';
+
+type TSvelteRender = typeof render;
+interface IRenderWithLankaOptions extends Omit<NonNullable<Parameters<TSvelteRender>[1]>, "wrapper">, IPrepareLankaRenderOptions {
+}
+/**
+ * What a render answers, plus the instance it used.
+ *
+ * An intersection rather than an `interface … extends`: Svelte Testing Library's
+ * result carries a string index signature for its queries, and a named member
+ * added by extension has to satisfy it. An intersection does not ask that.
+ */
+/**
+ * What a render with a bootstrapped framework ADDS to the library's own result.
+ *
+ * An interface over the addition rather than over the whole result, and the same
+ * in all five bindings: Svelte Testing Library's result carries a string index
+ * signature for its bound queries, so a named member added by extension has to
+ * satisfy it — and `lanka` is an instance, not a query. Describing only the
+ * addition is true of every library and needs no cast anywhere.
+ */
+interface IRenderWithLankaResult {
+    /** The instance the render used. */
+    lanka: ILankaInstance;
+}
+/**
+ * Rendering a Svelte tree with a bootstrapped framework.
+ *
+ * ## Why
+ *
+ * A component reading a ViewModel needs a live instance: without one the first
+ * scenario or locator access fails. Assembling bootstrap in every component test
+ * is twenty lines of preamble that diverge between files silently.
+ *
+ * ## What is here, and what is in the kit
+ *
+ * The five bindings publish this name and differ only in which `render` they
+ * call. Everything else — a fresh instance, the doubles, the caller's setup and
+ * the scenario layer brought up in that order — is `prepareLankaRender` in
+ * `@lankajs/tool-testing`, which is the one place all five already look.
+ *
+ * ## The option and result types are DERIVED, not named
+ *
+ * Svelte Testing Library's `RenderResult` is generic over the component and its
+ * queries, so naming it here would mean guessing three type arguments and
+ * re-guessing them whenever the library changes. Reading them off `render`
+ * itself cannot drift.
+ */
+declare const renderWithLanka: (ui: Parameters<TSvelteRender>[0], options?: IRenderWithLankaOptions) => ReturnType<TSvelteRender> & IRenderWithLankaResult;
+
+export { type IRenderWithLankaOptions, type IRenderWithLankaResult, renderWithLanka };