foldkit 0.156.0 → 0.157.0

package/dist/html/lazy.d.ts

@@ -1,15 +1,15 @@
 import { type VNode } from '../vdom.js';
 /** Creates a memoization slot for a view function. On each render, if the
- *  function reference, dispatch, and all arguments are referentially equal
- *  (`===`) to the previous call, the cached VNode is returned without
+ *  function reference, dispatchers, Mount render owner, and all arguments are
+ *  equal to the previous call, the cached VNode is returned without
  *  re-running the view function. Snabbdom's `patchVnode` short-circuits when
  *  it sees the same VNode reference, so both VNode construction and subtree
  *  diffing are skipped.
  *
- *  Dispatch is part of the cache key because event handlers in the cached
- *  VNode close over the dispatch active when the VNode was built. Returning
- *  a VNode built under a different dispatch would silently misroute every
- *  event from that subtree.
+ *  Dispatchers and Mount render ownership are part of the cache key because
+ *  event handlers and Mounts in the cached VNode close over the frame active
+ *  when the VNode was built. Returning a VNode built under a different frame
+ *  would silently misroute events or retain the wrong Mount lifecycle owner.
  *
  *  The cached VNode must be rendered at a single position in the tree.
  *  Snabbdom tracks the real DOM through each VNode's mutable `.elm` field

package/dist/html/lazy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/html/lazy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,KAAK,EAAwC,MAAM,YAAY,CAAA;AAmF7E;;;;;;;;;;;;;;;;;oCAiBoC;AACpC,eAAO,MAAM,UAAU,QAAO,CAAC,CAAC,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,EACjE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,KAAK,GAAG,IAAI,EACnC,IAAI,EAAE,IAAI,KACP,KAAK,GAAG,IAAI,CAUhB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;iDAsBiD;AACjD,eAAO,MAAM,eAAe,QAAO,CAAC,CAAC,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,EACtE,GAAG,EAAE,WAAW,EAChB,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,KAAK,GAAG,IAAI,EACnC,IAAI,EAAE,IAAI,KACP,KAAK,GAAG,IAAI,CAWhB,CAAA"}
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/html/lazy.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,KAAK,EAAwC,MAAM,YAAY,CAAA;AAyG7E;;;;;;;;;;;;;;;;;oCAiBoC;AACpC,eAAO,MAAM,UAAU,QAAO,CAAC,CAAC,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,EACjE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,KAAK,GAAG,IAAI,EACnC,IAAI,EAAE,IAAI,KACP,KAAK,GAAG,IAAI,CAUhB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;iDAsBiD;AACjD,eAAO,MAAM,eAAe,QAAO,CAAC,CAAC,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,EACtE,GAAG,EAAE,WAAW,EAChB,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,KAAK,GAAG,IAAI,EACnC,IAAI,EAAE,IAAI,KACP,KAAK,GAAG,IAAI,CAehB,CAAA"}

package/dist/html/lazy.js

@@ -1,7 +1,7 @@
 import { Predicate } from 'effect';
 import { dedupeMemoizedResult, memoizedVNodes } from '../vdom.js';
-import { beginLazyTracking, endLazyTracking, markSeenForLazyHit, } from './boundary.js';
-import { requireBoundary, requireDispatch, } from './runtimeSingleton.js';
+import { beginLazyTracking, endLazyTracking, registerBoundaryWrapTransactionRollback, restoreBoundaryWrapsForLazyHit, } from './boundary.js';
+import { requireBoundary, requireDispatch, requireMountDispatch, requireMountRenderOwner, } from './runtimeSingleton.js';
 const argsEqual = (previous, current) => {
     if (previous.length !== current.length) {
         return false;
@@ -15,16 +15,24 @@ const argsEqual = (previous, current) => {
 };
 const resolveOrCache = (previousEntry, fn, args, onCache) => {
     const dispatch = requireDispatch();
+    const mountDispatch = requireMountDispatch();
+    const mountRenderOwner = requireMountRenderOwner();
     const { registry } = requireBoundary();
-    // NOTE: dispatch identity in the cache key matters for the DevTools
-    // jumpTo path: a replay render installs `noOpDispatch`, and without
-    // this check a subsequent live render could return a vnode whose
-    // handlers still reference the noOp.
+    // NOTE: dispatcher identities and Mount render ownership belong in the
+    // cache key because the cached VNode closes over them. Current frame
+    // construction makes the Mount dispatcher identity derivable from the
+    // ordinary dispatcher's owner and boundary, so the second identity cannot
+    // change a cache decision today. Keeping both roles explicit prevents a
+    // future renderer that separates them from retaining stale handler or Mount
+    // lifecycle closures. Custom renderers can also use one dispatcher for both
+    // owners, so the owner remains a separate key member.
     if (Predicate.isNotUndefined(previousEntry) &&
         previousEntry.fn === fn &&
         previousEntry.dispatch === dispatch &&
+        previousEntry.mountDispatch === mountDispatch &&
+        previousEntry.mountRenderOwner === mountRenderOwner &&
         argsEqual(previousEntry.args, args)) {
-        markSeenForLazyHit(registry, previousEntry.trackedBoundaries);
+        restoreBoundaryWrapsForLazyHit(registry, previousEntry.trackedBoundaries);
         return previousEntry.vnode;
     }
     const trackedBoundaries = beginLazyTracking(registry);
@@ -45,20 +53,29 @@ const resolveOrCache = (previousEntry, fn, args, onCache) => {
     if (Predicate.isNotNull(deduped)) {
         memoizedVNodes.add(deduped);
     }
-    onCache({ fn, args, dispatch, vnode: deduped, trackedBoundaries });
+    onCache({
+        fn,
+        args,
+        dispatch,
+        mountDispatch,
+        mountRenderOwner,
+        vnode: deduped,
+        trackedBoundaries,
+    });
+    registerBoundaryWrapTransactionRollback(registry, previousEntry, onCache);
     return deduped;
 };
 /** Creates a memoization slot for a view function. On each render, if the
- *  function reference, dispatch, and all arguments are referentially equal
- *  (`===`) to the previous call, the cached VNode is returned without
+ *  function reference, dispatchers, Mount render owner, and all arguments are
+ *  equal to the previous call, the cached VNode is returned without
  *  re-running the view function. Snabbdom's `patchVnode` short-circuits when
  *  it sees the same VNode reference, so both VNode construction and subtree
  *  diffing are skipped.
  *
- *  Dispatch is part of the cache key because event handlers in the cached
- *  VNode close over the dispatch active when the VNode was built. Returning
- *  a VNode built under a different dispatch would silently misroute every
- *  event from that subtree.
+ *  Dispatchers and Mount render ownership are part of the cache key because
+ *  event handlers and Mounts in the cached VNode close over the frame active
+ *  when the VNode was built. Returning a VNode built under a different frame
+ *  would silently misroute events or retain the wrong Mount lifecycle owner.
  *
  *  The cached VNode must be rendered at a single position in the tree.
  *  Snabbdom tracks the real DOM through each VNode's mutable `.elm` field
@@ -98,6 +115,11 @@ export const createLazy = () => {
 export const createKeyedLazy = () => {
     const cache = new Map();
     return (key, fn, args) => resolveOrCache(cache.get(key), fn, args, entry => {
-        cache.set(key, entry);
+        if (entry === undefined) {
+            cache.delete(key);
+        }
+        else {
+            cache.set(key, entry);
+        }
     });
 };

package/dist/html/public.d.ts

@@ -1,3 +1,3 @@
 export { childAttributes, ClickOptions, createKeyedLazy, createLazy, DefaultAction, EventPropagation, inertHtml, TextDirection, } from './index.js';
-export type { Attribute, ChildAttribute, Document, Html, HtmlBuilder, KeyboardModifiers, TagName, } from './index.js';
+export type { Attribute, ChildAttribute, Document, Html, HtmlBuilder, KeyboardModifiers, TagName, TextareaAttribute, } from './index.js';
 //# sourceMappingURL=public.d.ts.map

package/dist/html/public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/html/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,YAAY,EACZ,eAAe,EACf,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,SAAS,EACT,aAAa,GACd,MAAM,YAAY,CAAA;AAEnB,YAAY,EACV,SAAS,EACT,cAAc,EACd,QAAQ,EACR,IAAI,EACJ,WAAW,EACX,iBAAiB,EACjB,OAAO,GACR,MAAM,YAAY,CAAA"}
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/html/public.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,YAAY,EACZ,eAAe,EACf,UAAU,EACV,aAAa,EACb,gBAAgB,EAChB,SAAS,EACT,aAAa,GACd,MAAM,YAAY,CAAA;AAEnB,YAAY,EACV,SAAS,EACT,cAAc,EACd,QAAQ,EACR,IAAI,EACJ,WAAW,EACX,iBAAiB,EACjB,OAAO,EACP,iBAAiB,GAClB,MAAM,YAAY,CAAA"}

package/dist/html/runtimeSingleton.d.ts

@@ -2,8 +2,17 @@ import type { Context } from 'effect';
 import { type BoundaryId, type BoundaryRegistry } from './boundary.js';
 /** Synchronous message dispatcher provided to view-time element constructors. */
 export type DispatchSync = (message: unknown) => void;
+/** Identifies which kind of render acquired a Mount. */
+export type MountRenderOwner = 'Live' | 'Replay';
+/** Resolves the render-owned dispatcher for a Mount at insertion time. */
+export type MountDispatchResolver = Readonly<{
+    owner: MountRenderOwner;
+    resolve: () => DispatchSync;
+}>;
 export type Frame = Readonly<{
     outerDispatch: DispatchSync;
+    mountOuterDispatch: DispatchSync;
+    mountRenderOwner: MountRenderOwner;
     runtimeContext: Context.Context<never>;
     boundaryRegistry: BoundaryRegistry;
     boundaryId: BoundaryId;
@@ -19,7 +28,7 @@ export type Frame = Readonly<{
  *  omitted (e.g. crash views, test helpers that don't use Submodels), a
  *  fresh empty registry is created. The frame starts in the root
  *  boundary. */
-export declare const setRuntime: (dispatch: DispatchSync, runtimeContext: Context.Context<never>, boundaryRegistry?: BoundaryRegistry) => void;
+export declare const setRuntime: (dispatch: DispatchSync, runtimeContext: Context.Context<never>, boundaryRegistry?: BoundaryRegistry, mountRenderOwner?: MountRenderOwner) => void;
 /** Pushes a new frame that inherits the current frame's dispatch, context,
  *  and registry, but uses a different boundary. Used by `h.submodel` to
  *  enter a child Submodel's wrapping context. Must be paired with
@@ -52,6 +61,12 @@ export declare const clearRuntime: () => void;
  *  is a cached per-boundary dispatcher that applies the wrapping chain at
  *  event-fire time. Throws when called outside of a runtime frame. */
 export declare const requireDispatch: () => DispatchSync;
+/** Returns the render-owned root dispatcher for Mount results. A live render
+ *  supplies live dispatch, while a historical render supplies no-op dispatch
+ *  for acquisitions owned by that replay. */
+export declare const requireMountDispatch: () => DispatchSync;
+/** Returns whether the current frame is rendering the live or replayed view. */
+export declare const requireMountRenderOwner: () => MountRenderOwner;
 /** A function that, given a message, resolves it through the current
  *  boundary's wrapping chain immediately and returns a thunk that dispatches
  *  the fully wrapped root message. */
@@ -62,12 +77,18 @@ export type UnmountResolver = (message: unknown) => () => void;
  *  patch. Throws when called outside of a runtime frame. */
 export declare const requireUnmountResolver: () => UnmountResolver;
 /** Returns the current frame's Submodel wrapping chain (innermost first), or an
- *  empty array at the root boundary. `OnMount` calls this at build time to
- *  snapshot the lift a Submodel-embedded mount's result travels through in
- *  production (via `ctx.dispatch`), so the Scene test harness can replay it when
- *  the mount is resolved. Returns `[]` when there is no active frame, mirroring
- *  the lazy tolerance of handler-free Html built outside a render. */
+ *  empty array at the root boundary. `OnMount` records this build-time snapshot
+ *  for the Scene test harness, which replays the chain when the Mount is
+ *  resolved. Production Mount dispatch uses the ownership-aware resolver below.
+ *  Returns `[]` when there is no active frame, mirroring the lazy tolerance of
+ *  handler-free Html built outside a render. */
 export declare const requireBoundaryMappers: () => ReadonlyArray<(message: unknown) => unknown>;
+/** Returns a resolver bound to the current frame's render owner and Submodel
+ *  boundary. Mounts invoke it from their insert hook, so a cached VNode uses
+ *  the dispatcher for the render that acquires it. That dispatcher follows
+ *  later wrapper registrations from the same owner without crossing between
+ *  live and replay renders. */
+export declare const requireMountDispatchResolver: () => MountDispatchResolver;
 /** Returns the current runtime Effect Context, used by Mount integrations
  *  that fork message-producing Effects against the live runtime services. */
 export declare const requireRuntimeContext: () => Context.Context<never>;

package/dist/html/runtimeSingleton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtimeSingleton.d.ts","sourceRoot":"","sources":["../../src/html/runtimeSingleton.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAErC,OAAO,EACL,KAAK,UAAU,EACf,KAAK,gBAAgB,EAMtB,MAAM,eAAe,CAAA;AAEtB,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;AAErD,MAAM,MAAM,KAAK,GAAG,QAAQ,CAAC;IAC3B,aAAa,EAAE,YAAY,CAAA;IAC3B,cAAc,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IACtC,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,UAAU,EAAE,UAAU,CAAA;CACvB,CAAC,CAAA;AAIF;;;;;;;;;;gBAUgB;AAChB,eAAO,MAAM,UAAU,aACX,YAAY,kBACN,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,qBACpB,gBAAgB,KACjC,IAOF,CAAA;AAED;;;4BAG4B;AAC5B,eAAO,MAAM,YAAY,eAAgB,UAAU,KAAG,IAarD,CAAA;AAED;;;;;;;;;;;0DAW0D;AAC1D,eAAO,MAAM,SAAS,UAAW,KAAK,KAAG,IAExC,CAAA;AAED;;;;;;;6BAO6B;AAC7B,eAAO,MAAM,YAAY,QAAO,IAU/B,CAAA;AAED;;;sEAGsE;AACtE,eAAO,MAAM,eAAe,QAAO,YAelC,CAAA;AAED;;sCAEsC;AACtC,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,IAAI,CAAA;AAE9D;;;4DAG4D;AAC5D,eAAO,MAAM,sBAAsB,QAAO,eAiBzC,CAAA;AAED;;;;;sEAKsE;AACtE,eAAO,MAAM,sBAAsB,QAAO,aAAa,CACrD,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAO9B,CAAA;AAED;6EAC6E;AAC7E,eAAO,MAAM,qBAAqB,QAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAW7D,CAAA;AAED;;mEAEmE;AACnE,eAAO,MAAM,eAAe,QAAO,QAAQ,CAAC;IAC1C,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,UAAU,EAAE,UAAU,CAAA;CACvB,CAQA,CAAA;AAED;;;;;8CAK8C;AAC9C,eAAO,MAAM,eAAe,QAAO,KAQlC,CAAA"}
+{"version":3,"file":"runtimeSingleton.d.ts","sourceRoot":"","sources":["../../src/html/runtimeSingleton.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAErC,OAAO,EACL,KAAK,UAAU,EACf,KAAK,gBAAgB,EAOtB,MAAM,eAAe,CAAA;AAEtB,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;AAErD,wDAAwD;AACxD,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,QAAQ,CAAA;AAEhD,0EAA0E;AAC1E,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,KAAK,EAAE,gBAAgB,CAAA;IACvB,OAAO,EAAE,MAAM,YAAY,CAAA;CAC5B,CAAC,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,QAAQ,CAAC;IAC3B,aAAa,EAAE,YAAY,CAAA;IAC3B,kBAAkB,EAAE,YAAY,CAAA;IAChC,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,cAAc,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IACtC,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,UAAU,EAAE,UAAU,CAAA;CACvB,CAAC,CAAA;AAiBF;;;;;;;;;;gBAUgB;AAChB,eAAO,MAAM,UAAU,aACX,YAAY,kBACN,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,qBACpB,gBAAgB,qBAChB,gBAAgB,KACjC,IASF,CAAA;AAED;;;4BAG4B;AAC5B,eAAO,MAAM,YAAY,eAAgB,UAAU,KAAG,IAerD,CAAA;AAED;;;;;;;;;;;0DAW0D;AAC1D,eAAO,MAAM,SAAS,UAAW,KAAK,KAAG,IAExC,CAAA;AAED;;;;;;;6BAO6B;AAC7B,eAAO,MAAM,YAAY,QAAO,IAU/B,CAAA;AAED;;;sEAGsE;AACtE,eAAO,MAAM,eAAe,QAAO,YAOlC,CAAA;AAED;;6CAE6C;AAC7C,eAAO,MAAM,oBAAoB,QAAO,YAEvC,CAAA;AAED,gFAAgF;AAChF,eAAO,MAAM,uBAAuB,QAAO,gBAE1C,CAAA;AAED;;sCAEsC;AACtC,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,IAAI,CAAA;AAE9D;;;4DAG4D;AAC5D,eAAO,MAAM,sBAAsB,QAAO,eASzC,CAAA;AAED;;;;;gDAKgD;AAChD,eAAO,MAAM,sBAAsB,QAAO,aAAa,CACrD,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAO9B,CAAA;AAED;;;;+BAI+B;AAC/B,eAAO,MAAM,4BAA4B,QAAO,qBAW/C,CAAA;AAED;6EAC6E;AAC7E,eAAO,MAAM,qBAAqB,QAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAE7D,CAAA;AAED;;mEAEmE;AACnE,eAAO,MAAM,eAAe,QAAO,QAAQ,CAAC;IAC1C,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,UAAU,EAAE,UAAU,CAAA;CACvB,CAQA,CAAA;AAED;;;;;8CAK8C;AAC9C,eAAO,MAAM,eAAe,QAAO,KAQlC,CAAA"}

package/dist/html/runtimeSingleton.js

@@ -1,5 +1,15 @@
-import { ROOT_BOUNDARY, boundaryMappers, createBoundaryRegistry, getOrCreateBoundaryDispatch, resolveBoundaryDispatchThunk, } from './boundary.js';
+import { ROOT_BOUNDARY, boundaryMappers, createBoundaryRegistry, getOrCreateBoundaryDispatch, resolveBoundaryDispatchThunk, resolveMountBoundaryDispatch, } from './boundary.js';
 const stack = [];
+const requireFrame = () => {
+    const frame = stack[stack.length - 1];
+    if (frame === undefined) {
+        throw new Error('Foldkit: html element constructors must be called inside a runtime-driven ' +
+            'render. The element was built outside a view, or foldkit was loaded as ' +
+            'more than one instance (a bundler split foldkit and @foldkit/ui into ' +
+            'separate copies).');
+    }
+    return frame;
+};
 /** Pushes a new dispatch and runtime context onto the singleton stack. The
  *  runtime calls this before invoking a user `view`, and any test or
  *  framework helper that builds VNodes outside of a normal render uses the
@@ -11,9 +21,11 @@ const stack = [];
  *  omitted (e.g. crash views, test helpers that don't use Submodels), a
  *  fresh empty registry is created. The frame starts in the root
  *  boundary. */
-export const setRuntime = (dispatch, runtimeContext, boundaryRegistry = createBoundaryRegistry()) => {
+export const setRuntime = (dispatch, runtimeContext, boundaryRegistry = createBoundaryRegistry(), mountRenderOwner = 'Live') => {
     stack.push({
         outerDispatch: dispatch,
+        mountOuterDispatch: dispatch,
+        mountRenderOwner,
         runtimeContext,
         boundaryRegistry,
         boundaryId: ROOT_BOUNDARY,
@@ -30,6 +42,8 @@ export const pushBoundary = (boundaryId) => {
     }
     stack.push({
         outerDispatch: parent.outerDispatch,
+        mountOuterDispatch: parent.mountOuterDispatch,
+        mountRenderOwner: parent.mountRenderOwner,
         runtimeContext: parent.runtimeContext,
         boundaryRegistry: parent.boundaryRegistry,
         boundaryId,
@@ -72,35 +86,33 @@ export const clearRuntime = () => {
  *  is a cached per-boundary dispatcher that applies the wrapping chain at
  *  event-fire time. Throws when called outside of a runtime frame. */
 export const requireDispatch = () => {
-    const frame = stack[stack.length - 1];
-    if (frame === undefined) {
-        throw new Error('Foldkit: html element constructors must be called inside a runtime-driven ' +
-            'render. The element was built outside a view, or foldkit was loaded as ' +
-            'more than one instance (a bundler split foldkit and @foldkit/ui into ' +
-            'separate copies).');
-    }
+    const frame = requireFrame();
     return getOrCreateBoundaryDispatch(frame.boundaryRegistry, frame.outerDispatch, frame.boundaryId);
 };
+/** Returns the render-owned root dispatcher for Mount results. A live render
+ *  supplies live dispatch, while a historical render supplies no-op dispatch
+ *  for acquisitions owned by that replay. */
+export const requireMountDispatch = () => {
+    return requireFrame().mountOuterDispatch;
+};
+/** Returns whether the current frame is rendering the live or replayed view. */
+export const requireMountRenderOwner = () => {
+    return requireFrame().mountRenderOwner;
+};
 /** Returns an {@link UnmountResolver} bound to the current frame's boundary.
  *  `OnUnmount` calls the resolver at build time (boundary alive) to capture a
  *  dispatch thunk that survives the boundary being torn down during the same
  *  patch. Throws when called outside of a runtime frame. */
 export const requireUnmountResolver = () => {
-    const frame = stack[stack.length - 1];
-    if (frame === undefined) {
-        throw new Error('Foldkit: html element constructors must be called inside a runtime-driven ' +
-            'render. The element was built outside a view, or foldkit was loaded as ' +
-            'more than one instance (a bundler split foldkit and @foldkit/ui into ' +
-            'separate copies).');
-    }
+    const frame = requireFrame();
     return message => resolveBoundaryDispatchThunk(frame.boundaryRegistry, frame.outerDispatch, frame.boundaryId, message);
 };
 /** Returns the current frame's Submodel wrapping chain (innermost first), or an
- *  empty array at the root boundary. `OnMount` calls this at build time to
- *  snapshot the lift a Submodel-embedded mount's result travels through in
- *  production (via `ctx.dispatch`), so the Scene test harness can replay it when
- *  the mount is resolved. Returns `[]` when there is no active frame, mirroring
- *  the lazy tolerance of handler-free Html built outside a render. */
+ *  empty array at the root boundary. `OnMount` records this build-time snapshot
+ *  for the Scene test harness, which replays the chain when the Mount is
+ *  resolved. Production Mount dispatch uses the ownership-aware resolver below.
+ *  Returns `[]` when there is no active frame, mirroring the lazy tolerance of
+ *  handler-free Html built outside a render. */
 export const requireBoundaryMappers = () => {
     const frame = stack[stack.length - 1];
     if (frame === undefined) {
@@ -108,17 +120,22 @@ export const requireBoundaryMappers = () => {
     }
     return boundaryMappers(frame.boundaryRegistry, frame.boundaryId);
 };
+/** Returns a resolver bound to the current frame's render owner and Submodel
+ *  boundary. Mounts invoke it from their insert hook, so a cached VNode uses
+ *  the dispatcher for the render that acquires it. That dispatcher follows
+ *  later wrapper registrations from the same owner without crossing between
+ *  live and replay renders. */
+export const requireMountDispatchResolver = () => {
+    const frame = requireFrame();
+    return {
+        owner: frame.mountRenderOwner,
+        resolve: () => resolveMountBoundaryDispatch(frame.boundaryRegistry, frame.mountOuterDispatch, frame.boundaryId),
+    };
+};
 /** Returns the current runtime Effect Context, used by Mount integrations
  *  that fork message-producing Effects against the live runtime services. */
 export const requireRuntimeContext = () => {
-    const frame = stack[stack.length - 1];
-    if (frame === undefined) {
-        throw new Error('Foldkit: html element constructors must be called inside a runtime-driven ' +
-            'render. The element was built outside a view, or foldkit was loaded as ' +
-            'more than one instance (a bundler split foldkit and @foldkit/ui into ' +
-            'separate copies).');
-    }
-    return frame.runtimeContext;
+    return requireFrame().runtimeContext;
 };
 /** Returns the current frame's boundary registry and boundary id. Used by
  *  `h.submodel` to register wrapping descriptors and compute child

package/dist/html/submodel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"submodel.d.ts","sourceRoot":"","sources":["../../src/html/submodel.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"submodel.d.ts","sourceRoot":"","sources":["../../src/html/submodel.ts"],"names":[],"mappings":"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"}

package/dist/html/submodel.js

@@ -1,5 +1,5 @@
 import { memoizedVNodes } from '../vdom.js';
-import { composeBoundary, deregisterBoundaryWrap, registerBoundaryWrap, } from './boundary.js';
+import { beginBoundaryWrapTransaction, commitBoundaryWrapTransaction, composeBoundary, deregisterBoundaryWrap, registerBoundaryWrap, rollbackBoundaryWrapTransaction, } from './boundary.js';
 import { isChildAttribute } from './childAttribute.js';
 import { clearRuntime, getCurrentFrame, pushBoundary, pushFrame, } from './runtimeSingleton.js';
 // NOTE: string key (not Symbol) so SubmodelView types from different
@@ -136,23 +136,12 @@ const wrapViewInputsForOuterBoundary = (viewInputs, outerFrame) => {
  *
  *  See `submodel.test.ts` for the cache-hit-survival and
  *  destroy-deregisters-wrap assertions. */
-const withBoundaryCleanup = (vnode, registry, boundaryId) => {
+const withBoundaryCleanup = (vnode, registry, boundaryId, descriptor, mountOuterDispatch) => {
     const data = vnode.data ?? {};
     const hook = data.hook ?? {};
     const previousDestroy = hook.destroy;
     const compositeDestroy = (removed) => {
-        // NOTE: a Submodel whose root vnode changes snabbdom identity across
-        // renders (e.g. a keyed root whose key changed) re-registers its
-        // boundary in the new view phase, then snabbdom destroys the OLD root
-        // vnode in the following patch phase. That destroy must not evict the
-        // freshly re-registered wrap. `seenThisRender` is cleared in
-        // `beginRender`, so during patch it still reflects the just-completed
-        // view phase: the boundary's presence there means it is live this cycle
-        // (a remount), not a true unmount. Deleting it here would surface later
-        // as `dispatchAcrossBoundary missing wrap`.
-        if (!registry.seenThisRender.has(boundaryId)) {
-            deregisterBoundaryWrap(registry, boundaryId);
-        }
+        deregisterBoundaryWrap(registry, boundaryId, descriptor, mountOuterDispatch);
         if (previousDestroy !== undefined) {
             previousDestroy(removed);
         }
@@ -184,21 +173,23 @@ export const submodel = (config, htmlBuilderSingleton) => {
     const parentFrame = getCurrentFrame();
     const registry = parentFrame.boundaryRegistry;
     const childBoundaryId = composeBoundary(parentFrame.boundaryId, config.slotId);
-    registerBoundaryWrap(registry, childBoundaryId, {
+    const descriptor = {
         toParentMessage: 
         /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
         config.toParentMessage,
-    });
-    // NOTE: the builder handed to the child view is the process-wide
-    // singleton retyped to the child's Message. The value carries no
-    // Message state (dispatch resolves from the frame pushed below), so
-    // the cast is the entire mechanism, exactly like the brand cast in
-    // `defineView`.
-    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
-    const childBuilder = htmlBuilderSingleton;
-    let vnode;
-    pushBoundary(childBoundaryId);
+    };
+    const transaction = beginBoundaryWrapTransaction(registry);
     try {
+        registerBoundaryWrap(registry, childBoundaryId, descriptor, parentFrame.mountOuterDispatch);
+        // NOTE: the builder handed to the child view is the process-wide
+        // singleton retyped to the child's Message. The value carries no
+        // Message state (dispatch resolves from the frame pushed below), so
+        // the cast is the entire mechanism, exactly like the brand cast in
+        // `defineView`.
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
+        const childBuilder = htmlBuilderSingleton;
+        let vnode;
+        pushBoundary(childBoundaryId);
         try {
             if (!Object.hasOwn(config, 'viewInputs')) {
                 /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
@@ -214,21 +205,19 @@ export const submodel = (config, htmlBuilderSingleton) => {
                 vnode = view(config.model, wrappedViewInputs, childBuilder);
             }
         }
-        catch (error) {
-            // The view threw; the registered wrap would otherwise leak with
-            // no destroy hook ever firing. Drop it before propagating.
-            deregisterBoundaryWrap(registry, childBoundaryId);
-            throw error;
+        finally {
+            clearRuntime();
         }
+        if (vnode === null) {
+            rollbackBoundaryWrapTransaction(registry, transaction);
+            return null;
+        }
+        const vnodeWithCleanup = withBoundaryCleanup(vnode, registry, childBoundaryId, descriptor, parentFrame.mountOuterDispatch);
+        commitBoundaryWrapTransaction(registry, transaction);
+        return vnodeWithCleanup;
     }
-    finally {
-        clearRuntime();
-    }
-    if (vnode === null) {
-        // No vnode means no destroy hook will ever fire; deregister now so
-        // the wrap doesn't leak.
-        deregisterBoundaryWrap(registry, childBoundaryId);
-        return null;
+    catch (error) {
+        rollbackBoundaryWrapTransaction(registry, transaction);
+        throw error;
     }
-    return withBoundaryCleanup(vnode, registry, childBoundaryId);
 };

package/dist/http/http.d.ts

@@ -29,7 +29,7 @@ import { HttpClient } from 'effect/unstable/http';
  *   execute: Effect.gen(function* () {
  *     const client = yield* HttpClient.HttpClient
  *     const response = yield* client.get('/api/count')
- *     const { count } = yield* S.decodeUnknownEffect(CountResponse)(
+ *     const { count } = yield* Schema.decodeUnknownEffect(CountResponse)(
  *       yield* response.json,
  *     )
  *     return SucceededFetchCount({ count })

package/dist/http/http.js

@@ -29,7 +29,7 @@ import { FetchHttpClient, HttpClient } from 'effect/unstable/http';
  *   execute: Effect.gen(function* () {
  *     const client = yield* HttpClient.HttpClient
  *     const response = yield* client.get('/api/count')
- *     const { count } = yield* S.decodeUnknownEffect(CountResponse)(
+ *     const { count } = yield* Schema.decodeUnknownEffect(CountResponse)(
  *       yield* response.json,
  *     )
  *     return SucceededFetchCount({ count })

package/dist/managedResource/managedResource.d.ts

@@ -54,7 +54,7 @@ type EntryBrand<Model, Message> = {
 };
 /**
  * The requirements value the runtime hands to `acquire`. When the requirements
- * schema is wrapped in `S.Option`, the runtime unwraps the `Some` before
+ * schema is wrapped in `Schema.Option`, the runtime unwraps the `Some` before
  * calling `acquire`, so the parameter is the inner type.
  */
 type AcquireParams<Requirements> = Requirements extends Option.Option<infer Params> ? Params : Requirements;
@@ -99,7 +99,7 @@ export type ServicesOf<Resources> = {
  * on the config literal) lets TypeScript fully resolve the requirements type
  * before contextually typing `modelToMaybeRequirements` and `acquire`, so
  * destructuring patterns are inferred correctly even when the schema uses
- * transforms like `S.Option`.
+ * transforms like `Schema.Option`.
  *
  * The `onAcquired` field is typed as `OnAcquired` intersected with the
  * concrete `(value: Value) => Message` signature: the concrete member keeps
@@ -153,7 +153,7 @@ export type EntryBuilder<Model, Message> = <RequirementsSchema extends Schema.Sc
  * - `modelToMaybeRequirements` — Extracts requirements from the model.
  *   `Option.none()` means "release", `Option.some(params)` means
  *   "acquire/re-acquire if params changed". For resources with no
- *   parameters, use `S.Option(S.Null)` and return `Option.some(null)`.
+ *   parameters, use `Schema.Option(Schema.Null)` and return `Option.some(null)`.
  * - `acquire` — Creates the resource from the unwrapped params. The returned
  *   Effect should fail when acquisition fails: errors in the error channel
  *   flow to `onAcquireError` as a message instead of crashing the runtime.
@@ -179,7 +179,7 @@ export type EntryBuilder<Model, Message> = <RequirementsSchema extends Schema.Sc
  * const CameraStream = ManagedResource.tag<MediaStream>()('CameraStream')
  *
  * const managedResources = ManagedResource.make<Model, Message>()(entry => ({
- *   camera: entry(S.Option(S.Struct({ facingMode: S.String })), {
+ *   camera: entry(Schema.Option(Schema.Struct({ facingMode: Schema.String })), {
  *     resource: CameraStream,
  *     modelToMaybeRequirements: model =>
  *       pipe(
@@ -218,7 +218,7 @@ type ChildMessageOf<Resources> = Resources[keyof Resources] extends Entry<any, i
  * `Option.none()` to release), and a child Submodel that owns a managed
  * resource is itself something that mounts and unmounts. A missing child is
  * just another `None` and flows through the same acquire/release channel, so
- * each lifted entry's requirements must be `S.Option`-wrapped.
+ * each lifted entry's requirements must be `Schema.Option`-wrapped.
  */
 export declare const lift: <Resources extends Record<string, Entry<any, any, Option.Option<any>, any, any>>>(resources: Resources) => <ParentModel, ParentMessage>(config: {
     readonly toChildModel: (parentModel: ParentModel) => Option.Option<ChildModelOf<Resources>>;

package/dist/managedResource/managedResource.js

@@ -55,7 +55,7 @@ export const tag = () => (key) => {
  * - `modelToMaybeRequirements` — Extracts requirements from the model.
  *   `Option.none()` means "release", `Option.some(params)` means
  *   "acquire/re-acquire if params changed". For resources with no
- *   parameters, use `S.Option(S.Null)` and return `Option.some(null)`.
+ *   parameters, use `Schema.Option(Schema.Null)` and return `Option.some(null)`.
  * - `acquire` — Creates the resource from the unwrapped params. The returned
  *   Effect should fail when acquisition fails: errors in the error channel
  *   flow to `onAcquireError` as a message instead of crashing the runtime.
@@ -81,7 +81,7 @@ export const tag = () => (key) => {
  * const CameraStream = ManagedResource.tag<MediaStream>()('CameraStream')
  *
  * const managedResources = ManagedResource.make<Model, Message>()(entry => ({
- *   camera: entry(S.Option(S.Struct({ facingMode: S.String })), {
+ *   camera: entry(Schema.Option(Schema.Struct({ facingMode: Schema.String })), {
  *     resource: CameraStream,
  *     modelToMaybeRequirements: model =>
  *       pipe(
@@ -130,7 +130,7 @@ export const make = () =>
  * `Option.none()` to release), and a child Submodel that owns a managed
  * resource is itself something that mounts and unmounts. A missing child is
  * just another `None` and flows through the same acquire/release channel, so
- * each lifted entry's requirements must be `S.Option`-wrapped.
+ * each lifted entry's requirements must be `Schema.Option`-wrapped.
  */
 export const lift = (resources) => (config) => 
 /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */