npm - sibujs - Versions diffs - 3.4.1 → 4.0.0 - Mend

sibujs 3.4.1 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (98) hide show

package/LICENSE +21 -21
package/README.md +118 -15
package/dist/browser.cjs +410 -101
package/dist/browser.d.cts +50 -5
package/dist/browser.d.ts +50 -5
package/dist/browser.js +8 -6
package/dist/build.cjs +777 -385
package/dist/build.js +15 -15
package/dist/cdn.global.js +11 -7
package/dist/{chunk-WEZ5SP7L.js → chunk-3EKJK5FZ.js} +73 -34
package/dist/chunk-4MFZMLUU.js +147 -0
package/dist/chunk-52XFPGSN.js +123 -0
package/dist/chunk-5INI7D2L.js +194 -0
package/dist/{chunk-5MFF5EPT.js → chunk-6LG2T7LO.js} +5 -5
package/dist/{chunk-BQLVTAUZ.js → chunk-ACBT6UZS.js} +57 -22
package/dist/{chunk-F7HW2NI5.js → chunk-AW6HPJ3L.js} +1 -1
package/dist/chunk-DHDZ7IVN.js +109 -0
package/dist/{chunk-NXR2YFZB.js → chunk-DQVUBVNX.js} +16 -25
package/dist/{chunk-7PNKW3FJ.js → chunk-DR7H6UGM.js} +232 -67
package/dist/{chunk-CV7FAQ2R.js → chunk-E62UADKL.js} +9 -3
package/dist/{chunk-VQZDHAEK.js → chunk-ES2GERY2.js} +1 -1
package/dist/{chunk-FWFEBYQ6.js → chunk-EWEE7NBF.js} +115 -41
package/dist/{chunk-PBZWJQNY.js → chunk-F64ZPCFE.js} +8 -8
package/dist/{chunk-S2VW4NBA.js → chunk-GCSGGA3Q.js} +295 -198
package/dist/{chunk-EX77FXTT.js → chunk-HYCCIYNS.js} +228 -51
package/dist/{chunk-MPE75KOA.js → chunk-NF3LYCQH.js} +259 -124
package/dist/chunk-O3QQ3XOL.js +61 -0
package/dist/{chunk-X4JS367G.js → chunk-PBQEW5VW.js} +14 -10
package/dist/{chunk-QHPUFNHZ.js → chunk-RRIDJQ5C.js} +3 -3
package/dist/{chunk-S3NFJO6L.js → chunk-TIRZCERI.js} +36 -5
package/dist/{chunk-3FFCUIGV.js → chunk-VFHIVEPF.js} +309 -188
package/dist/chunk-VPP2FONR.js +142 -0
package/dist/{chunk-335KJEN2.js → chunk-W55YHPEP.js} +5 -3
package/dist/{chunk-Y22QAKJX.js → chunk-WN6WDFCB.js} +4 -4
package/dist/{chunk-YDWP3ZOU.js → chunk-WOOMUJFT.js} +228 -86
package/dist/{chunk-4I3M326N.js → chunk-Z2CE42DB.js} +19 -25
package/dist/{contracts-ey_Qh8ef.d.ts → contracts-Hg6ITAEF.d.cts} +6 -6
package/dist/{contracts-ey_Qh8ef.d.cts → contracts-Hg6ITAEF.d.ts} +6 -6
package/dist/{customElement-CPfIrbvg.d.cts → customElement-CKLoO63w.d.cts} +73 -11
package/dist/{customElement-CPfIrbvg.d.ts → customElement-CKLoO63w.d.ts} +73 -11
package/dist/data.cjs +483 -205
package/dist/data.d.cts +139 -7
package/dist/data.d.ts +139 -7
package/dist/data.js +9 -9
package/dist/devtools.cjs +222 -87
package/dist/devtools.js +8 -8
package/dist/dispose-4FZ6OFXR.js +19 -0
package/dist/ecosystem.cjs +419 -175
package/dist/ecosystem.js +11 -11
package/dist/extras.cjs +1981 -765
package/dist/extras.d.cts +7 -7
package/dist/extras.d.ts +7 -7
package/dist/extras.js +29 -26
package/dist/index.cjs +784 -385
package/dist/index.d.cts +299 -28
package/dist/index.d.ts +299 -28
package/dist/index.js +33 -18
package/dist/motion.cjs +180 -50
package/dist/motion.d.cts +26 -0
package/dist/motion.d.ts +26 -0
package/dist/motion.js +5 -5
package/dist/patterns.cjs +437 -170
package/dist/patterns.d.cts +60 -13
package/dist/patterns.d.ts +60 -13
package/dist/patterns.js +7 -7
package/dist/performance.cjs +333 -148
package/dist/performance.d.cts +55 -7
package/dist/performance.d.ts +55 -7
package/dist/performance.js +9 -9
package/dist/plugins.cjs +1371 -576
package/dist/plugins.d.cts +227 -9
package/dist/plugins.d.ts +227 -9
package/dist/plugins.js +610 -321
package/dist/{ssr-D62yFwuw.d.cts → ssr-BiPRdZ6n.d.cts} +44 -15
package/dist/{ssr-D62yFwuw.d.ts → ssr-BiPRdZ6n.d.ts} +44 -15
package/dist/{ssr-2PPULEK2.js → ssr-JFP5535P.js} +5 -4
package/dist/ssr.cjs +1104 -443
package/dist/ssr.d.cts +230 -20
package/dist/ssr.d.ts +230 -20
package/dist/ssr.js +15 -12
package/dist/{startup-0Qv6aosO.d.cts → startup-BMpaiMhP.d.cts} +1 -1
package/dist/{startup-0Qv6aosO.d.ts → startup-BMpaiMhP.d.ts} +1 -1
package/dist/testing.cjs +205 -63
package/dist/testing.d.cts +1 -1
package/dist/testing.d.ts +1 -1
package/dist/testing.js +8 -10
package/dist/ui.cjs +640 -199
package/dist/ui.d.cts +2 -2
package/dist/ui.d.ts +2 -2
package/dist/ui.js +10 -10
package/dist/widgets.cjs +207 -82
package/dist/widgets.js +9 -9
package/package.json +12 -7
package/dist/chunk-5VGSK6D2.js +0 -80
package/dist/chunk-6CAJU5TP.js +0 -38
package/dist/chunk-COY6PUD2.js +0 -34
package/dist/chunk-DLBFEAIS.js +0 -96
package/dist/chunk-L3GAGWCC.js +0 -111

package/dist/ssr.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-export { H as HydrateOptions, a as HydrationMismatch, T as TrustedHTML, c as collectStream, d as deserializeState, e as escapeScriptJson, h as hydrate, b as hydrateIslands, f as hydrateProgressively, i as isDangerousMetaRefresh, g as island, r as renderToDocument, j as renderToReadableStream, k as renderToStream, l as renderToString, m as renderToSuspenseStream, n as resetSSRState, s as serializeState, o as ssrSuspense, p as suspenseSwapScript, t as trustHTML } from './ssr-D62yFwuw.js';
+export { H as HydrateOptions, a as HydrationMismatch, T as TrustedHTML, c as collectStream, d as deserializeState, e as escapeScriptJson, h as hydrate, b as hydrateIslands, f as hydrateProgressively, i as isDangerousMetaRefresh, g as island, r as renderToDocument, j as renderToReadableStream, k as renderToStream, l as renderToString, m as renderToSuspenseStream, n as resetSSRState, s as serializeState, o as ssrSuspense, p as suspenseSwapScript, t as trustHTML } from './ssr-BiPRdZ6n.js';
 interface HeadProps {
     title?: string | (() => string);
@@ -12,6 +12,26 @@ interface HeadProps {
 }
 /**
  * Head() manages document <head> tags reactively.
+ *
+ * META SECURITY: each meta entry is committed TRANSACTIONALLY. All of its
+ * attributes — static and reactive — are resolved into one snapshot, duplicate
+ * case-insensitive names are rejected, and the assembled snapshot is validated
+ * against the shared meta-refresh policy before anything reaches the DOM. An
+ * approved snapshot is then materialised on a fresh `<meta>` element while it is
+ * still detached and swapped in with a single `replaceWith()`, so no partially
+ * updated element is ever connected. A snapshot that fails validation withdraws
+ * the element entirely. See `utils/metaRefresh.ts`; the same policy governs SSR.
+ *
+ * NATIVE REFRESH DIRECTIVES MUST BE STATIC. A browser processes a meta refresh
+ * when the element is INSERTED — it records the pending navigation there and
+ * then, and removing or replacing the element afterwards is not a defined way to
+ * cancel it. `Head()` therefore never publishes a snapshot whose effective
+ * `http-equiv` is `refresh` from an entry that contains any reactive attribute,
+ * even when the destination is allowed: what cannot be withdrawn must not be
+ * handed over. Static refresh directives work as before, and every other
+ * reactive meta entry — description, keywords, Open Graph, non-refresh
+ * `http-equiv` — is unaffected.
+ *
  * Supports dynamic title, meta tags, link tags, and structured data.
  * Each instance tracks its own elements and effects for independent cleanup.
  */
@@ -99,7 +119,7 @@ declare function createWorkerPool<TInput = unknown, TOutput = unknown>(workerFn:
  * Provides hooks and utilities to load, cache, and use WASM modules
  * for performance-critical operations.
  */
-interface WasmModuleState<T extends Record<string, unknown> = Record<string, unknown>> {
+interface WasmModuleState<T extends object = Record<string, unknown>> {
     /** The instantiated WASM module exports, null until loaded */
     instance: T | null;
     /** Loading state */
@@ -109,26 +129,47 @@ interface WasmModuleState<T extends Record<string, unknown> = Record<string, unk
     /** Whether the module has been loaded successfully */
     ready: boolean;
 }
-interface WasmConfig {
-    /** Import object passed to WebAssembly.instantiate */
-    imports?: WebAssembly.Imports;
-    /** Cache key for module caching (defaults to URL) */
-    cacheKey?: string;
+/**
+ * Configuration for the `wasm()` reactive wrapper.
+ *
+ * Deliberately the SAME option bag as the underlying `loadWasmModule()`
+ * primitive rather than a hand-copied subset. The primitive REQUIRES an
+ * explicit origin policy for URL sources (`allowedOrigins`, or an explicit
+ * `unsafelyAllowAnyOrigin` opt-in), and the wrapper previously had no way to
+ * express one — so `wasm("/math.wasm")` could only ever reject, and the public
+ * convenience API was unusable for its documented primary use case. Extending
+ * the primitive's type keeps the two from drifting again.
+ */
+interface WasmConfig extends LoadWasmOptions {
 }
 /**
  * Hook to load and use a WebAssembly module reactively.
  * Returns reactive state that updates when the module loads.
  *
+ * A URL source needs an explicit origin policy — WASM is compiled code with
+ * imports into JS memory, so fetching it from an unvetted URL is a supply-chain
+ * risk equivalent to importing a remote module (CWE-829). Pass `allowedOrigins`,
+ * or `unsafelyAllowAnyOrigin: true` to opt out deliberately. An `ArrayBuffer` /
+ * `Uint8Array` source needs neither: the bytes are already in hand.
+ *
  * @example
  * ```ts
- * const wasm = wasm<{ add: (a: number, b: number) => number }>('/math.wasm');
+ * const math = wasm<{ add: (a: number, b: number) => number }>(
+ *   'https://cdn.example.com/math.wasm',
+ *   { allowedOrigins: ['https://cdn.example.com'] },
+ * );
  * // In reactive context:
- * if (wasm.ready()) {
- *   const result = wasm.instance()!.add(1, 2);
+ * if (math.ready()) {
+ *   const result = math.instance()!.add(1, 2);
  * }
  * ```
+ *
+ * @example Same-origin asset — still an explicit decision.
+ * ```ts
+ * const math = wasm('/math.wasm', { allowedOrigins: [location.origin] });
+ * ```
  */
-declare function wasm<T extends Record<string, unknown> = Record<string, unknown>>(source: string | ArrayBuffer | Uint8Array, config?: WasmConfig): {
+declare function wasm<T extends object = Record<string, unknown>>(source: string | ArrayBuffer | Uint8Array, config?: WasmConfig): {
     instance: () => T | null;
     loading: () => boolean;
     error: () => Error | null;
@@ -156,7 +197,50 @@ interface LoadWasmOptions {
      *  a supply-chain risk equivalent to remote module import (CWE-829). */
     unsafelyAllowAnyOrigin?: boolean;
 }
-declare function loadWasmModule(source: string | ArrayBuffer | Uint8Array, imports?: WebAssembly.Imports | LoadWasmOptions, cacheKey?: string): Promise<WebAssembly.Instance>;
+/**
+ * Load and instantiate a WebAssembly module — **positional/legacy form**.
+ *
+ * The second parameter is always `WebAssembly.Imports` and the third is always
+ * the cache key. There is no structural guessing, so a module namespace legally
+ * named `imports` or `cacheKey` is passed through unharmed.
+ *
+ * It previously accepted `WebAssembly.Imports | LoadWasmOptions` and decided
+ * between them at runtime by probing for `allowedOrigins` /
+ * `unsafelyAllowAnyOrigin`. That discriminator was unsound in both directions:
+ * an options bag carrying only `imports`/`cacheKey` was read as an import
+ * namespace (so `cacheKey` was dropped and the documented keyed-singleton
+ * guarantee silently did not hold), while a genuine namespace *named*
+ * `allowedOrigins` would have been read as options. No structural test can
+ * separate the two, because both are plain objects with caller-chosen keys — so
+ * the union was removed rather than re-guessed.
+ *
+ * For anything beyond imports and a cache key — notably the origin policy a URL
+ * source requires — use {@link loadWasmModuleWithOptions}.
+ *
+ * @see loadWasmModuleWithOptions
+ */
+declare function loadWasmModule(source: string | ArrayBuffer | Uint8Array, imports?: WebAssembly.Imports, cacheKey?: string): Promise<WebAssembly.Instance>;
+/**
+ * Load and instantiate a WebAssembly module — **options form**.
+ *
+ * Unambiguous by construction: options live in their own parameter, so a WASM
+ * module namespace named `imports`, `cacheKey`, or `allowedOrigins` is just a
+ * namespace and nothing has to be inferred from object shape.
+ *
+ * This is the form to use for a URL source, since the origin policy
+ * (`allowedOrigins`, or an explicit `unsafelyAllowAnyOrigin`) can only be
+ * expressed here.
+ *
+ * @example
+ * ```ts
+ * const instance = await loadWasmModuleWithOptions("https://cdn.example.com/math.wasm", {
+ *   allowedOrigins: ["https://cdn.example.com"],
+ *   imports: { env: { log: console.log } },
+ *   cacheKey: "math",
+ * });
+ * ```
+ */
+declare function loadWasmModuleWithOptions(source: string | ArrayBuffer | Uint8Array, opts?: LoadWasmOptions): Promise<WebAssembly.Instance>;
 /**
  * Preload and compile a WASM module without instantiating it.
  * The compiled module is cached for instant instantiation later.
@@ -169,7 +253,7 @@ declare function preloadWasm(url: string, options?: {
  * Create a type-safe bridge to a WASM module with automatic memory management.
  * Provides helpers for passing strings and arrays between JS and WASM.
  */
-declare function createWasmBridge<T extends Record<string, unknown>>(instance: WebAssembly.Instance): {
+declare function createWasmBridge<T extends object>(instance: WebAssembly.Instance): {
     exports: T;
     memory: WebAssembly.Memory;
     /** Allocate bytes in WASM memory (requires WASM to export malloc) */
@@ -192,7 +276,16 @@ declare function createWasmBridge<T extends Record<string, unknown>>(instance: W
     readF64Array: (ptr: number, len: number) => Float64Array;
 };
 /**
- * Clear all cached WASM modules and instances.
+ * Invalidate the module, instance, and in-flight WASM cache generations.
+ *
+ * CONTRACT: work already started may still resolve to the callers that started
+ * it, but must never repopulate the caches after the clear. A load in flight
+ * across this call therefore still returns its instance to whoever awaited it,
+ * while the cache stays empty and the next load for that key compiles and
+ * instantiates afresh.
+ *
+ * This is an invalidation BARRIER, not a `Map.clear()`: emptying the maps alone
+ * would let the invalidated work write its results straight back in.
  */
 declare function clearWasmCache(): void;
 /**
@@ -216,7 +309,7 @@ interface MicroApp {
     /** The outer host element */
     element: HTMLElement;
 }
-interface SharedScope<T extends Record<string, unknown>> {
+interface SharedScope<T extends object> {
     /** Get the current value for a key */
     get<K extends keyof T>(key: K): T[K];
     /** Set a value for a key, notifying all subscribers */
@@ -249,9 +342,16 @@ declare function createMicroApp(config: MicroAppConfig): MicroApp;
  * Modules are cached by URL so repeated calls with the same URL return the
  * same promise without issuing another network request.
  *
+ * An origin policy is REQUIRED: importing a remote module is remote code
+ * execution, so the call is refused unless you either restrict it with
+ * `allowedOrigins` or opt out deliberately with `unsafelyAllowAnyOrigin`
+ * (CWE-829).
+ *
  * @example
  * ```ts
- * const charts = await loadRemoteModule("https://cdn.example.com/charts.js");
+ * const charts = await loadRemoteModule("https://cdn.example.com/charts.js", {
+ *   allowedOrigins: ["https://cdn.example.com"],
+ * });
  * const el = charts.BarChart({ data: [1, 2, 3] });
  * ```
  */
@@ -273,11 +373,19 @@ type RemoteLoader = () => Promise<{
  * placeholder, fetches the remote module, then swaps in the real component.
  * Subsequent calls render instantly from the cached module.
  *
+ * The load is owner-scoped: if the container is disposed before the module
+ * arrives, the module is still cached (it is shared and expensive to fetch) but
+ * the component is NOT instantiated and nothing is written into the dead
+ * container.
+ *
  * @example
  * ```ts
  * const RemoteHeader = defineRemoteComponent(
  *   "remote-header",
- *   () => loadRemoteModule("https://cdn.example.com/header.js")
+ *   () =>
+ *     loadRemoteModule("https://cdn.example.com/header.js", {
+ *       allowedOrigins: ["https://cdn.example.com"],
+ *     })
  * );
  *
  * // Use it like any local component
@@ -309,7 +417,7 @@ declare function defineRemoteComponent(name: string, loader: RemoteLoader): Comp
  * unsub();
  * ```
  */
-declare function createSharedScope<T extends Record<string, unknown>>(initialState: T): SharedScope<T>;
+declare function createSharedScope<T extends object>(initialState: T): SharedScope<T>;
 interface ServiceWorkerState {
     registration: () => ServiceWorkerRegistration | null;
@@ -321,6 +429,26 @@ interface ServiceWorkerState {
 }
 /**
  * serviceWorker registers and manages a service worker.
+ *
+ * LIFECYCLE CONTRACT
+ * ------------------
+ * Registration is asynchronous and `unregister()` can be called at any point
+ * during it, so this tracks four distinct situations rather than one boolean:
+ *
+ *   registering      register() in flight, nothing to unregister yet
+ *   active           registration adopted, listeners attached
+ *   unregister asked requested before the registration resolved — the arriving
+ *                    registration is unregistered rather than adopted, so the
+ *                    browser never keeps a worker SibuJS has forgotten
+ *   unregistered     terminal, and only entered once unregister() actually
+ *                    RETURNED TRUE
+ *
+ * The last point is the important one. `ServiceWorkerRegistration.unregister()`
+ * returns `false` when the browser declined — the worker is still installed and
+ * still controlling pages. Treating that as teardown (detaching listeners,
+ * dropping the registration) left the wrapper permanently blind to a worker
+ * that was very much alive: no update tracking, no registration, no way back.
+ * A failed unregister therefore changes nothing.
  */
 declare function serviceWorker(scriptUrl: string, options?: RegistrationOptions): ServiceWorkerState;
@@ -379,15 +507,97 @@ interface ActionResult<T> {
 declare function createAction<T>(actionFn: ActionFn<T>): ActionResult<T>;
 interface ScrollRestorationOptions {
+    /**
+     * `"auto"` (default) manages history-entry identity and restores the
+     * destination on `popstate`. It tags the entry the page started on, tags each
+     * entry you announce with `onNavigation()`, saves the outgoing position, and
+     * takes over `history.scrollRestoration` so the browser does not restore in
+     * parallel.
+     *
+     * What auto mode CANNOT do is notice a `history.pushState` it was not told
+     * about — no library can, short of monkey-patching `history` globally. Entries
+     * created without `onNavigation()` carry no identity and are simply not
+     * restored (a safe no-op, not a wrong position).
+     *
+     * `"manual"` attaches no listener, claims no native restoration, and tags
+     * nothing — you call `save()` / `restore()` yourself.
+     */
     mode?: "auto" | "manual";
+    /**
+     * Identifies the entry the user is currently on. Called once at construction
+     * to seed the current entry, and consulted as a fallback when nothing has
+     * been saved yet.
+     *
+     * Point it at whatever your app treats as a history identity — e.g.
+     * `() => router.location().key`. Pathname alone is usually wrong: `?page=2`
+     * and `#section` are distinct scroll positions to a user.
+     */
+    getKey?: () => string | null;
+    /**
+     * History-state property used to tag entries so a `popstate` can name its
+     * DESTINATION. `popstate` reports the state of the entry being restored, and
+     * that is the only reliable way to know where the user just landed.
+     */
+    stateKey?: string;
 }
 /**
  * Manages scroll position saving and restoration keyed by route/key.
- * Uses a Map to store positions and window.scrollTo to restore them.
+ *
+ * AUTO MODE
+ * ---------
+ * `"auto"` previously attached a `popstate` listener that only ever called
+ * `save()` — so the documented "save/restore on popstate" behaviour was half
+ * implemented, and going Back never returned the viewport anywhere. The whole
+ * point of the feature was the half that was missing.
+ *
+ * A real restore needs to know WHICH entry the user landed on, so auto mode
+ * tags history entries with their key (`stateKey`) and the `popstate` handler
+ * reads that tag off `event.state`. On each pop it:
+ *
+ *   1. saves the position of the entry being LEFT (unless it is also the
+ *      destination — a same-key pop is not a departure, and saving there would
+ *      overwrite the stored position with the current one, destroying exactly
+ *      the value about to be restored)
+ *   2. restores the destination's saved position, if one exists
+ *
+ * An unknown or absent destination key is a safe SibuJS no-op: no guessed
+ * position is applied. Note this is not a hand-off to the browser — auto mode
+ * leases `history.scrollRestoration` to `"manual"` while active, so nothing
+ * else is restoring either. The viewport simply stays where the engine left it.
+ *
+ * WHAT "AUTO" MEANS, EXACTLY
+ * --------------------------
+ * Reacting to `popstate` automatically is not enough on its own: the handler
+ * can only restore an entry that HAS an identity, and originally nothing ever
+ * gave one to the entry the page started on. The first Back a user pressed
+ * therefore restored nothing. Auto mode now owns identity as well as reaction:
+ *
+ *   - the INITIAL entry is tagged at construction, and
+ *   - `onNavigation(key)` tags each entry the application creates.
+ *
+ * That second half is an explicit hook rather than magic, and deliberately so:
+ * a library cannot observe arbitrary `history.pushState` calls without patching
+ * `history` globally, which would surprise every other consumer of it. So the
+ * honest contract is:
+ *
+ *   > Auto mode restores any entry it was given identity for, and never guesses
+ *   > about entries it was not told about.
+ *
+ * Auto mode also leases `history.scrollRestoration = "manual"` while active, so
+ * the browser is not restoring the viewport at the same time SibuJS is. The
+ * previous value is restored when the last controller is disposed.
  */
 declare function scrollRestoration(options?: ScrollRestorationOptions): {
     save: (key: string) => void;
     restore: (key: string) => void;
+    /**
+     * Tell auto mode that the application created a new history entry.
+     *
+     * Records the outgoing entry's position, tags the new entry with `key`, and
+     * makes it current. Call it immediately after your `pushState` (before any
+     * scrolling), so the position captured is the one the user is leaving.
+     */
+    onNavigation: (key: string) => void;
     getPosition: (key: string) => {
         x: number;
         y: number;
@@ -416,4 +626,4 @@ declare function createMiddlewareChain(): {
     }) => Promise<void>;
 };
-export { type ActionFn, type ActionResult, Head, type ISROptions, type LoadRemoteModuleOptions, type LoadWasmOptions, type MicroApp, type MicroAppConfig, type MiddlewareFn, type SSGOptions, type SSGResult, type ScrollRestorationOptions, type ServiceWorkerState, type SharedScope, type UseWorkerFnReturn, type UseWorkerReturn, type WasmConfig, type WasmModuleState, type WorkerPool, clearWasmCache, composeMiddleware, createAction, createISR, createMicroApp, createMiddlewareChain, createSharedScope, createWasmBridge, createWorkerPool, defineRemoteComponent, generateStaticSite, isWasmCached, loadRemoteModule, loadWasmModule, preloadWasm, scrollRestoration, serviceWorker, setCanonical, setStructuredData, wasm, worker, workerFn };
+export { type ActionFn, type ActionResult, Head, type ISROptions, type LoadRemoteModuleOptions, type LoadWasmOptions, type MicroApp, type MicroAppConfig, type MiddlewareFn, type SSGOptions, type SSGResult, type ScrollRestorationOptions, type ServiceWorkerState, type SharedScope, type UseWorkerFnReturn, type UseWorkerReturn, type WasmConfig, type WasmModuleState, type WorkerPool, clearWasmCache, composeMiddleware, createAction, createISR, createMicroApp, createMiddlewareChain, createSharedScope, createWasmBridge, createWorkerPool, defineRemoteComponent, generateStaticSite, isWasmCached, loadRemoteModule, loadWasmModule, loadWasmModuleWithOptions, preloadWasm, scrollRestoration, serviceWorker, setCanonical, setStructuredData, wasm, worker, workerFn };

package/dist/ssr.js CHANGED Viewed

@@ -14,6 +14,7 @@ import {
   isWasmCached,
   loadRemoteModule,
   loadWasmModule,
+  loadWasmModuleWithOptions,
   preloadWasm,
   scrollRestoration,
   serviceWorker,
@@ -22,8 +23,9 @@ import {
   wasm,
   worker,
   workerFn
-} from "./chunk-3FFCUIGV.js";
-import "./chunk-VQZDHAEK.js";
+} from "./chunk-VFHIVEPF.js";
+import "./chunk-52XFPGSN.js";
+import "./chunk-ES2GERY2.js";
 import {
   collectStream,
   deserializeState,
@@ -43,17 +45,17 @@ import {
   ssrSuspense,
   suspenseSwapScript,
   trustHTML
-} from "./chunk-EX77FXTT.js";
-import "./chunk-NXR2YFZB.js";
-import "./chunk-DLBFEAIS.js";
+} from "./chunk-HYCCIYNS.js";
+import "./chunk-DQVUBVNX.js";
+import "./chunk-4MFZMLUU.js";
+import "./chunk-5INI7D2L.js";
 import "./chunk-7ZHH77QA.js";
-import "./chunk-L3GAGWCC.js";
-import "./chunk-X4JS367G.js";
-import "./chunk-S3NFJO6L.js";
-import "./chunk-5VGSK6D2.js";
-import "./chunk-335KJEN2.js";
-import "./chunk-BQLVTAUZ.js";
-import "./chunk-COY6PUD2.js";
+import "./chunk-PBQEW5VW.js";
+import "./chunk-TIRZCERI.js";
+import "./chunk-DHDZ7IVN.js";
+import "./chunk-W55YHPEP.js";
+import "./chunk-ACBT6UZS.js";
+import "./chunk-VPP2FONR.js";
 export {
   Head,
   clearWasmCache,
@@ -78,6 +80,7 @@ export {
   island,
   loadRemoteModule,
   loadWasmModule,
+  loadWasmModuleWithOptions,
   preloadWasm,
   renderToDocument,
   renderToReadableStream,

package/dist/{startup-0Qv6aosO.d.cts → startup-BMpaiMhP.d.cts} RENAMED Viewed

@@ -25,7 +25,7 @@ declare function createModuleRegistry(): {
  * Each key maps to a factory function that is invoked lazily on first access.
  * Returns an object with only the requested exports.
  */
-declare function createBundle<T extends Record<string, unknown>>(modules: Record<string, () => unknown>): T;
+declare function createBundle<T extends object>(modules: Record<string, () => unknown>): T;
 /**
  * Lazy module loader that only imports a module when first accessed.
  * Uses ES module dynamic import under the hood.

package/dist/{startup-0Qv6aosO.d.ts → startup-BMpaiMhP.d.ts} RENAMED Viewed

@@ -25,7 +25,7 @@ declare function createModuleRegistry(): {
  * Each key maps to a factory function that is invoked lazily on first access.
  * Returns an object with only the requested exports.
  */
-declare function createBundle<T extends Record<string, unknown>>(modules: Record<string, () => unknown>): T;
+declare function createBundle<T extends object>(modules: Record<string, () => unknown>): T;
 /**
  * Lazy module loader that only imports a module when first accessed.
  * Uses ES module dynamic import under the hood.