foldkit 0.156.0 → 0.157.0

package/dist/html/boundary.js

@@ -13,8 +13,12 @@ const splitBoundary = (boundaryId) => boundaryId === ROOT_BOUNDARY ? [] : bounda
 export const createBoundaryRegistry = () => ({
     wraps: new Map(),
     boundaryDispatches: new WeakMap(),
+    mountWraps: new WeakMap(),
+    mountWrapOwners: new Map(),
     seenThisRender: new Map(),
     lazyTrackingStack: [],
+    boundaryWrapTransactionLog: [],
+    activeBoundaryWrapTransaction: undefined,
     dedupeSeen: new Set(),
 });
 const captureCallSite = () => {
@@ -22,10 +26,14 @@ const captureCallSite = () => {
     const lines = stack.split('\n');
     for (const line of lines) {
         const trimmed = line.trim();
+        const isLazyInternalFrame = /[/\\]html[/\\]lazy\.[cm]?[jt]s/.test(trimmed);
         if (trimmed.length === 0 ||
             trimmed.startsWith('Error') ||
             trimmed.includes('captureCallSite') ||
+            trimmed.includes('assertBoundaryNotSeen') ||
             trimmed.includes('registerBoundaryWrap') ||
+            trimmed.includes('restoreBoundaryWrapsForLazyHit') ||
+            isLazyInternalFrame ||
             trimmed.includes('at submodel')) {
             continue;
         }
@@ -33,7 +41,7 @@ const captureCallSite = () => {
     }
     return '(call site unavailable)';
 };
-export const registerBoundaryWrap = (registry, boundaryId, descriptor) => {
+const assertBoundaryNotSeen = (registry, boundaryId) => {
     const existingCallSite = registry.seenThisRender.get(boundaryId);
     if (existingCallSite !== undefined) {
         const ownSlotId = boundaryId.includes(BOUNDARY_SEPARATOR)
@@ -49,16 +57,47 @@ export const registerBoundaryWrap = (registry, boundaryId, descriptor) => {
             `needs its own id (e.g. "desktop-foo", "mobile-foo"). For lists, use a stable ` +
             `per-item identifier.`);
     }
+};
+export const registerBoundaryWrap = (registry, boundaryId, descriptor, mountOuterDispatch) => {
+    assertBoundaryNotSeen(registry, boundaryId);
     // NOTE: compute the call site before writing either map. If
     // captureCallSite throws (e.g. hardened runtime without
     // Error.stack), neither map is mutated, so a later registration
     // with the same slotId throws the duplicate error correctly instead
     // of silently overwriting after a half-finished prior write.
     const callSite = captureCallSite();
+    writeBoundaryWrap(registry, boundaryId, descriptor, mountOuterDispatch, callSite);
+};
+const writeBoundaryWrap = (registry, boundaryId, descriptor, mountOuterDispatch, callSite) => {
+    const previousDescriptor = registry.wraps.get(boundaryId);
+    const existingMountWraps = registry.mountWraps.get(mountOuterDispatch);
+    const previousMountDescriptor = existingMountWraps?.get(boundaryId);
+    if (registry.activeBoundaryWrapTransaction !== undefined) {
+        registry.boundaryWrapTransactionLog.push({
+            _tag: 'Registration',
+            boundaryId,
+            descriptor,
+            mountOuterDispatch,
+            previousDescriptor,
+            previousMountDescriptor,
+        });
+    }
     registry.wraps.set(boundaryId, descriptor);
+    let mountWraps = existingMountWraps;
+    if (mountWraps === undefined) {
+        mountWraps = new Map();
+        registry.mountWraps.set(mountOuterDispatch, mountWraps);
+    }
+    mountWraps.set(boundaryId, descriptor);
+    let mountWrapOwners = registry.mountWrapOwners.get(boundaryId);
+    if (mountWrapOwners === undefined) {
+        mountWrapOwners = new Set();
+        registry.mountWrapOwners.set(boundaryId, mountWrapOwners);
+    }
+    mountWrapOwners.add(mountOuterDispatch);
     registry.seenThisRender.set(boundaryId, callSite);
     for (const tracked of registry.lazyTrackingStack) {
-        tracked.set(boundaryId, callSite);
+        tracked.set(boundaryId, { callSite, descriptor, mountOuterDispatch });
     }
 };
 /** Starts capturing boundary registrations on a fresh set pushed onto
@@ -81,28 +120,37 @@ export const endLazyTracking = (registry) => {
     }
     registry.lazyTrackingStack.pop();
 };
-/** Replays a set of boundary ids captured during a previous lazy run
- *  into `seenThisRender` so the duplicate-slotId guard sees them. Also
- *  forwards them into any active tracking sets so an outer lazy
- *  wrapping this cache hit captures the ids in its own snapshot.
+/** Restores boundary registrations captured during a previous lazy run and
+ *  replays their ids into `seenThisRender` so the duplicate-slotId guard sees
+ *  them. Also forwards them into active tracking maps so an outer lazy
+ *  wrapping this cache hit captures the registrations in its own snapshot.
  *
- *  Skips ids already present in `seenThisRender` to preserve the
- *  original call site of the live entry (the first registration this
- *  render still wins the error message). */
-export const markSeenForLazyHit = (registry, trackedIds) => {
-    for (const [boundaryId, callSite] of trackedIds) {
-        if (!registry.seenThisRender.has(boundaryId)) {
-            registry.seenThisRender.set(boundaryId, callSite);
-        }
+ *  A registration that still occupies both lookup tables needs only its seen
+ *  marker restored. A registration evicted when the cached VNode left the DOM
+ *  is written back transactionally, so a surrounding Submodel render that
+ *  later fails can still roll the cache hit back. */
+export const restoreBoundaryWrapsForLazyHit = (registry, trackedBoundaries) => {
+    for (const [boundaryId, trackedBoundary] of trackedBoundaries) {
+        const { callSite, descriptor, mountOuterDispatch } = trackedBoundary;
+        assertBoundaryNotSeen(registry, boundaryId);
+        registry.seenThisRender.set(boundaryId, callSite);
         for (const outerTracked of registry.lazyTrackingStack) {
             if (!outerTracked.has(boundaryId)) {
-                outerTracked.set(boundaryId, callSite);
+                outerTracked.set(boundaryId, trackedBoundary);
             }
         }
+        if (registry.wraps.get(boundaryId) === descriptor &&
+            registry.mountWraps.get(mountOuterDispatch)?.get(boundaryId) ===
+                descriptor) {
+            continue;
+        }
+        writeBoundaryWrap(registry, boundaryId, descriptor, mountOuterDispatch, callSite);
     }
 };
-/** Removes a boundary's wrap. Called by `h.submodel`'s destroy hook when
- *  the corresponding vnode leaves the DOM.
+/** Removes a boundary's wrap when it still matches the descriptor owned by the
+ *  VNode being destroyed. A replacement registered earlier in the same patch
+ *  is left intact. Called by `h.submodel`'s destroy hook when the corresponding
+ *  VNode leaves the DOM.
  *
  *  Does not touch `boundaryDispatches`: it is a WeakMap keyed by
  *  outerDispatch, so per-outerDispatch inner Maps become unreachable and
@@ -111,8 +159,108 @@ export const markSeenForLazyHit = (registry, trackedIds) => {
  *  when it cannot find an ancestor wrap, which surfaces a clear error
  *  rather than letting events from a destroyed boundary silently
  *  misroute. */
-export const deregisterBoundaryWrap = (registry, boundaryId) => {
-    registry.wraps.delete(boundaryId);
+export const deregisterBoundaryWrap = (registry, boundaryId, descriptor, mountOuterDispatch) => {
+    if (registry.wraps.get(boundaryId) === descriptor) {
+        registry.wraps.delete(boundaryId);
+        const mountWrapOwners = registry.mountWrapOwners.get(boundaryId);
+        if (mountWrapOwners !== undefined) {
+            for (const owner of mountWrapOwners) {
+                registry.mountWraps.get(owner)?.delete(boundaryId);
+            }
+            registry.mountWrapOwners.delete(boundaryId);
+        }
+        return;
+    }
+    const mountWraps = registry.mountWraps.get(mountOuterDispatch);
+    if (mountWraps?.get(boundaryId) === descriptor) {
+        mountWraps.delete(boundaryId);
+        const mountWrapOwners = registry.mountWrapOwners.get(boundaryId);
+        mountWrapOwners?.delete(mountOuterDispatch);
+        if (mountWrapOwners?.size === 0) {
+            registry.mountWrapOwners.delete(boundaryId);
+        }
+    }
+};
+/** Restores the registry entries replaced by one boundary registration that
+ *  did not produce a VNode. Used when a Submodel view throws or returns
+ *  `null`, where no destroy hook will run and cleanup must undo only that
+ *  render owner's write without evicting descriptors retained by the
+ *  currently rendered tree. */
+const rollbackBoundaryWrapRegistration = (registry, boundaryId, descriptor, mountOuterDispatch, previousDescriptor, previousMountDescriptor) => {
+    if (registry.wraps.get(boundaryId) === descriptor) {
+        if (previousDescriptor === undefined) {
+            registry.wraps.delete(boundaryId);
+        }
+        else {
+            registry.wraps.set(boundaryId, previousDescriptor);
+        }
+    }
+    const mountWraps = registry.mountWraps.get(mountOuterDispatch);
+    if (mountWraps?.get(boundaryId) !== descriptor) {
+        return;
+    }
+    if (previousMountDescriptor === undefined) {
+        mountWraps.delete(boundaryId);
+        const mountWrapOwners = registry.mountWrapOwners.get(boundaryId);
+        mountWrapOwners?.delete(mountOuterDispatch);
+        if (mountWrapOwners?.size === 0) {
+            registry.mountWrapOwners.delete(boundaryId);
+        }
+    }
+    else {
+        mountWraps.set(boundaryId, previousMountDescriptor);
+    }
+};
+/** Starts a nested boundary-registration transaction for one Submodel view. */
+export const beginBoundaryWrapTransaction = (registry) => {
+    const transaction = {
+        parent: registry.activeBoundaryWrapTransaction,
+        startIndex: registry.boundaryWrapTransactionLog.length,
+    };
+    registry.activeBoundaryWrapTransaction = transaction;
+    return transaction;
+};
+/** Commits a Submodel view's boundary registrations. Nested registrations stay
+ *  in the parent transaction until that parent also produces a VNode. */
+export const commitBoundaryWrapTransaction = (registry, transaction) => {
+    if (registry.activeBoundaryWrapTransaction !== transaction) {
+        throw new Error('Foldkit: boundary wrap transactions must commit in order.');
+    }
+    registry.activeBoundaryWrapTransaction = transaction.parent;
+    if (transaction.parent === undefined) {
+        registry.boundaryWrapTransactionLog.length = 0;
+    }
+};
+/** Registers an internal cache restoration with the active Submodel boundary
+ *  transaction. Calls outside a Submodel view need no rollback and are ignored. */
+export const registerBoundaryWrapTransactionRollback = (registry, value, restore) => {
+    if (registry.activeBoundaryWrapTransaction !== undefined) {
+        registry.boundaryWrapTransactionLog.push({
+            _tag: 'Rollback',
+            rollback: () => {
+                restore(value);
+            },
+        });
+    }
+};
+/** Restores every boundary registration performed since a Submodel view began,
+ *  including registrations from nested Submodels whose VNodes never reached
+ *  snabbdom. */
+export const rollbackBoundaryWrapTransaction = (registry, transaction) => {
+    if (registry.activeBoundaryWrapTransaction !== transaction) {
+        throw new Error('Foldkit: boundary wrap transactions must roll back in order.');
+    }
+    const entries = registry.boundaryWrapTransactionLog.splice(transaction.startIndex);
+    entries.reverse();
+    for (const entry of entries) {
+        if (entry._tag === 'Registration') {
+            rollbackBoundaryWrapRegistration(registry, entry.boundaryId, entry.descriptor, entry.mountOuterDispatch, entry.previousDescriptor, entry.previousMountDescriptor);
+        }
+        else {
+            entry.rollback();
+        }
+    }
+    registry.activeBoundaryWrapTransaction = transaction.parent;
 };
 // NOTE: reading `_tag` can itself throw, through a getter or a Proxy trap. This
 // runs while reporting another failure, so an escape here would replace the
@@ -160,6 +308,55 @@ const liftAcrossBoundary = (descriptor, boundaryId, message) => {
             `parent's boundary.`, { cause });
     }
 };
+const missingBoundaryWrapError = (mode, ancestorBoundary, boundaryId) => {
+    if (mode === 'Dispatch') {
+        return new Error(`Foldkit: dispatchAcrossBoundary missing wrap for ancestor ` +
+            `"${ancestorBoundary}" of boundary "${boundaryId}". The Submodel's ` +
+            `wrap was absent from the registry at dispatch time. A known cause: ` +
+            `a slot callback (an h.submodel \`viewInputs\` function value) was ` +
+            `invoked from a deferred context (setTimeout, Promise.then, a ` +
+            `stored callback) after the parent Submodel unmounted. Slot ` +
+            `callbacks must be invoked synchronously inside the render that ` +
+            `created them. It can also mean foldkit was loaded as more than ` +
+            `one instance (a bundler split foldkit and @foldkit/ui), so the ` +
+            `wrap was registered in one copy and read from another.`);
+    }
+    else if (mode === 'OnUnmount') {
+        return new Error(`Foldkit: resolveBoundaryDispatchThunk missing wrap for ancestor ` +
+            `"${ancestorBoundary}" of boundary "${boundaryId}" while resolving an ` +
+            `OnUnmount message. The Submodel's wrap was absent from the registry ` +
+            `at resolve time, which should not happen during a live render.`);
+    }
+    else if (mode === 'Scene') {
+        return new Error(`Foldkit: boundaryMappers missing wrap for ancestor ` +
+            `"${ancestorBoundary}" of boundary "${boundaryId}" while snapshotting ` +
+            `an OnMount lift. The Submodel's wrap was absent from the registry ` +
+            `during render, which should not happen for a live boundary.`);
+    }
+    else {
+        return new Error(`Foldkit: Mount dispatch missing wrap for ancestor ` +
+            `"${ancestorBoundary}" of boundary "${boundaryId}". The ` +
+            `Submodel's wrap was absent from the Mount's render owner.`);
+    }
+};
+const foldBoundaryChain = (wraps, boundaryId, mode, initial, fold) => {
+    let result = initial;
+    const parts = splitBoundary(boundaryId);
+    for (let depth = parts.length; depth > 0; depth--) {
+        const ancestorBoundary = parts.slice(0, depth).join(BOUNDARY_SEPARATOR);
+        const descriptor = wraps.get(ancestorBoundary);
+        if (descriptor === undefined) {
+            throw missingBoundaryWrapError(mode, ancestorBoundary, boundaryId);
+        }
+        result = fold(result, descriptor, ancestorBoundary);
+    }
+    return result;
+};
+const liftBoundaryMessage = (message, descriptor, ancestorBoundary) => liftAcrossBoundary(descriptor, ancestorBoundary, message);
+const collectBoundaryMapper = (mappers, descriptor) => {
+    mappers.push(descriptor.toParentMessage);
+    return mappers;
+};
 /** Applies the wrapping chain for `boundaryId` from innermost to
  *  outermost, then dispatches the fully-wrapped message via
  *  `outerDispatch`. Called at event-fire time by the dispatcher closure
@@ -175,25 +372,7 @@ const liftAcrossBoundary = (descriptor, boundaryId, message) => {
  *  wraps would produce a malformed Message that the outermost
  *  `Match.tagsExhaustive` would then crash on with no useful trace. */
 const dispatchAcrossBoundary = (registry, outerDispatch, boundaryId, message) => {
-    let wrapped = message;
-    const parts = splitBoundary(boundaryId);
-    for (let depth = parts.length; depth > 0; depth--) {
-        const ancestorBoundary = parts.slice(0, depth).join(BOUNDARY_SEPARATOR);
-        const descriptor = registry.wraps.get(ancestorBoundary);
-        if (descriptor === undefined) {
-            throw new Error(`Foldkit: dispatchAcrossBoundary missing wrap for ancestor ` +
-                `"${ancestorBoundary}" of boundary "${boundaryId}". The Submodel's ` +
-                `wrap was absent from the registry at dispatch time. A known cause: ` +
-                `a slot callback (an h.submodel \`viewInputs\` function value) was ` +
-                `invoked from a deferred context (setTimeout, Promise.then, a ` +
-                `stored callback) after the parent Submodel unmounted. Slot ` +
-                `callbacks must be invoked synchronously inside the render that ` +
-                `created them. It can also mean foldkit was loaded as more than ` +
-                `one instance (a bundler split foldkit and @foldkit/ui), so the ` +
-                `wrap was registered in one copy and read from another.`);
-        }
-        wrapped = liftAcrossBoundary(descriptor, ancestorBoundary, wrapped);
-    }
+    const wrapped = foldBoundaryChain(registry.wraps, boundaryId, 'Dispatch', message, liftBoundaryMessage);
     outerDispatch(wrapped);
 };
 /** Resolves a message through `boundaryId`'s wrapping chain immediately,
@@ -213,20 +392,7 @@ export const resolveBoundaryDispatchThunk = (registry, outerDispatch, boundaryId
     if (boundaryId === ROOT_BOUNDARY) {
         return () => outerDispatch(message);
     }
-    let wrapped = message;
-    const parts = splitBoundary(boundaryId);
-    for (let depth = parts.length; depth > 0; depth--) {
-        const ancestorBoundary = parts.slice(0, depth).join(BOUNDARY_SEPARATOR);
-        const descriptor = registry.wraps.get(ancestorBoundary);
-        if (descriptor === undefined) {
-            throw new Error(`Foldkit: resolveBoundaryDispatchThunk missing wrap for ancestor ` +
-                `"${ancestorBoundary}" of boundary "${boundaryId}" while resolving an ` +
-                `OnUnmount message. The Submodel's wrap was absent from the registry ` +
-                `at resolve time, which should not happen during a live render.`);
-        }
-        wrapped = liftAcrossBoundary(descriptor, ancestorBoundary, wrapped);
-    }
-    const rootMessage = wrapped;
+    const rootMessage = foldBoundaryChain(registry.wraps, boundaryId, 'OnUnmount', message, liftBoundaryMessage);
     return () => outerDispatch(rootMessage);
 };
 /** Collects the `toParentMessage` wrapping chain for `boundaryId`, innermost
@@ -238,20 +404,7 @@ export const resolveBoundaryDispatchThunk = (registry, outerDispatch, boundaryId
  *  it when the mount is resolved. Throws when an ancestor wrap is missing
  *  (boundary alive at call time), matching {@link dispatchAcrossBoundary}. */
 export const boundaryMappers = (registry, boundaryId) => {
-    const parts = splitBoundary(boundaryId);
-    const mappers = [];
-    for (let depth = parts.length; depth > 0; depth--) {
-        const ancestorBoundary = parts.slice(0, depth).join(BOUNDARY_SEPARATOR);
-        const descriptor = registry.wraps.get(ancestorBoundary);
-        if (descriptor === undefined) {
-            throw new Error(`Foldkit: boundaryMappers missing wrap for ancestor ` +
-                `"${ancestorBoundary}" of boundary "${boundaryId}" while snapshotting ` +
-                `an OnMount lift. The Submodel's wrap was absent from the registry ` +
-                `during render, which should not happen for a live boundary.`);
-        }
-        mappers.push(descriptor.toParentMessage);
-    }
-    return mappers;
+    return foldBoundaryChain(registry.wraps, boundaryId, 'Scene', [], collectBoundaryMapper);
 };
 export const getOrCreateBoundaryDispatch = (registry, outerDispatch, boundaryId) => {
     if (boundaryId === ROOT_BOUNDARY) {
@@ -272,17 +425,31 @@ export const getOrCreateBoundaryDispatch = (registry, outerDispatch, boundaryId)
     perOuterDispatch.set(boundaryId, dispatch);
     return dispatch;
 };
+/** Returns a dispatcher for a Mount acquired inside `boundaryId`.
+ *  The root dispatcher identifies the render owner: live and replay renders
+ *  therefore consult separate wrap tables. Within that owner, the dispatcher
+ *  resolves the current wrapping chain at emission time so a surviving Mount
+ *  follows later live `toParentMessage` closures just like an event handler. */
+export const resolveMountBoundaryDispatch = (registry, mountOuterDispatch, boundaryId) => {
+    if (boundaryId === ROOT_BOUNDARY) {
+        return mountOuterDispatch;
+    }
+    const dispatch = message => {
+        const mountWraps = registry.mountWraps.get(mountOuterDispatch);
+        if (mountWraps === undefined) {
+            throw new Error(`Foldkit: Mount dispatch missing wraps for boundary "${boundaryId}". ` +
+                `The Mount's render owner has no registered Submodel boundaries.`);
+        }
+        const wrapped = foldBoundaryChain(mountWraps, boundaryId, 'Mount', message, liftBoundaryMessage);
+        mountOuterDispatch(wrapped);
+    };
+    return dispatch;
+};
 /** Called at the start of each top-level render. Clears the
  *  per-render duplicate-slotId tracking map so siblings inside the
- *  same parent boundary can be re-validated. Does NOT touch `wraps`
- *  or `boundaryDispatches`. Those persist across renders and are
- *  evicted by vnode destroy hooks instead.
- *
- *  Clear `seenThisRender` only here, at the start of a cycle, never
- *  between the view and patch phases. The Submodel destroy hook reads
- *  it during patch to tell a same-cycle remount (a keyed root whose
- *  key changed) from a true unmount; clearing it mid-cycle would
- *  resurrect the `dispatchAcrossBoundary missing wrap` crash. */
+ *  same parent boundary can be re-validated. Does not touch the wrap
+ *  or dispatcher tables. Those persist across renders and are evicted
+ *  by VNode destroy hooks instead. */
 export const beginRender = (registry) => {
     registry.seenThisRender.clear();
     registry.dedupeSeen.clear();

package/dist/html/childAttribute.d.ts

@@ -1,4 +1,4 @@
-import { type DispatchSync } from './runtimeSingleton.js';
+import { type DispatchSync, type MountDispatchResolver } from './runtimeSingleton.js';
 declare const BRAND = "__childAttribute";
 /** An attribute carrying a handler that dispatches through a Submodel
  *  boundary's wrapping chain. Published by Submodels (typically Foldkit's
@@ -10,9 +10,10 @@ declare const BRAND = "__childAttribute";
  *  `resolveUnmount` snapshots the boundary's wrapping chain at the time the
  *  group was published (child boundary alive) so `OnUnmount` can dispatch a
  *  root message from a destroy hook that fires after the boundary has been
- *  torn down. `boundaryMappers` snapshots the same chain as a pure list of
- *  `toParentMessage` lifts (innermost first) so `OnMount` can stamp it on the
- *  mount marker; the Scene test harness folds it to replay the lift.
+ *  torn down. `boundaryMappers` snapshots the `toParentMessage` lifts
+ *  (innermost first) for the Scene test harness. Groups containing `OnMount`
+ *  also carry `resolveMountDispatch`, which binds the Mount to the acquiring
+ *  render's dispatch owner while following that owner's current live wrappers.
  *
  *  Created via {@link childAttributes}. Element constructors accept
  *  `ChildAttribute` alongside `Attribute<Message>` in their attribute
@@ -23,6 +24,7 @@ export type ChildAttribute = Readonly<{
     readonly dispatch: DispatchSync;
     readonly resolveUnmount: (message: unknown) => () => void;
     readonly boundaryMappers: ReadonlyArray<(message: unknown) => unknown>;
+    readonly resolveMountDispatch?: MountDispatchResolver;
 }>;
 export declare const isChildAttribute: (value: unknown) => value is ChildAttribute;
 /** Captures the current boundary's dispatcher and wraps each attribute

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

@@ -1 +1 @@
-{"version":3,"file":"childAttribute.d.ts","sourceRoot":"","sources":["../../src/html/childAttribute.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EAIlB,MAAM,uBAAuB,CAAA;AAE9B,QAAA,MAAM,KAAK,qBAAqB,CAAA;AAEhC;;;;;;;;;;;;;;;;cAgBc;AACd,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,IAAI,CAAA;IACtB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAA;IAC/B,QAAQ,CAAC,cAAc,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,IAAI,CAAA;IACzD,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,CAAA;CACvE,CAAC,CAAA;AAEF,eAAO,MAAM,gBAAgB,UAAW,OAAO,KAAG,KAAK,IAAI,cACI,CAAA;AAE/D;;;;;;;;;;;;;;;;;;;;;;oCAsBoC;AACpC,eAAO,MAAM,eAAe,GAAI,SAAS,cAC3B,aAAa,CAAC,SAAS,CAAC,KACnC,aAAa,CAAC,cAAc,CAW9B,CAAA"}
+{"version":3,"file":"childAttribute.d.ts","sourceRoot":"","sources":["../../src/html/childAttribute.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAK3B,MAAM,uBAAuB,CAAA;AAE9B,QAAA,MAAM,KAAK,qBAAqB,CAAA;AAKhC;;;;;;;;;;;;;;;;;cAiBc;AACd,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,QAAQ,CAAC,CAAC,KAAK,CAAC,EAAE,IAAI,CAAA;IACtB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAA;IAC/B,QAAQ,CAAC,cAAc,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,IAAI,CAAA;IACzD,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,CAAA;IACtE,QAAQ,CAAC,oBAAoB,CAAC,EAAE,qBAAqB,CAAA;CACtD,CAAC,CAAA;AAEF,eAAO,MAAM,gBAAgB,UAAW,OAAO,KAAG,KAAK,IAAI,cACI,CAAA;AAE/D;;;;;;;;;;;;;;;;;;;;;;oCAsBoC;AACpC,eAAO,MAAM,eAAe,GAAI,SAAS,cAC3B,aAAa,CAAC,SAAS,CAAC,KACnC,aAAa,CAAC,cAAc,CAe9B,CAAA"}

package/dist/html/childAttribute.js

@@ -1,5 +1,7 @@
-import { requireBoundaryMappers, requireDispatch, requireUnmountResolver, } from './runtimeSingleton.js';
+import { Predicate } from 'effect';
+import { requireBoundaryMappers, requireDispatch, requireMountDispatchResolver, requireUnmountResolver, } from './runtimeSingleton.js';
 const BRAND = '__childAttribute';
+const isOnMountAttribute = (attribute) => Predicate.isTagged(attribute, 'OnMount');
 export const isChildAttribute = (value) => typeof value === 'object' && value !== null && BRAND in value;
 /** Captures the current boundary's dispatcher and wraps each attribute
  *  so handlers inside it route through that boundary's wrapping chain at
@@ -28,11 +30,15 @@ export const childAttributes = (attributes) => {
     const dispatch = requireDispatch();
     const resolveUnmount = requireUnmountResolver();
     const boundaryMappers = requireBoundaryMappers();
+    const resolveMountDispatch = attributes.some(isOnMountAttribute)
+        ? requireMountDispatchResolver()
+        : undefined;
     return attributes.map(attribute => ({
         [BRAND]: true,
         attribute,
         dispatch,
         resolveUnmount,
         boundaryMappers,
+        ...(resolveMountDispatch !== undefined && { resolveMountDispatch }),
     }));
 };

package/dist/html/index.d.ts

@@ -1,6 +1,7 @@
-import { Data, Option, Schema as S } from 'effect';
+import { Data, Option, Schema } from 'effect';
 import type { File } from '../file/index.js';
 import type { MountAction } from '../mount/index.js';
+import { beginReplayUnmountRender, endReplayUnmountRender, flushReplayUnmountsAfterPatchFailure } from '../onUnmountModule.js';
 import { VNode } from '../vdom.js';
 import { type ChildAttribute } from './childAttribute.js';
 import { clearRuntime, requireDispatch, setRuntime } from './runtimeSingleton.js';
@@ -61,23 +62,23 @@ export type Html = VNode | null;
 export type Child = Html | string;
 /** Whether an event handler leaves the browser's default action in place or
  *  prevents it synchronously. */
-export declare const DefaultAction: S.Literals<readonly ["Allow", "Prevent"]>;
+export declare const DefaultAction: Schema.Literals<readonly ["Allow", "Prevent"]>;
 /** Whether an event handler leaves the browser's default action in place or
  *  prevents it synchronously. */
 export type DefaultAction = typeof DefaultAction.Type;
 /** Whether an event continues through its DOM propagation path or stops after
  *  the handlers on its current element have run. */
-export declare const EventPropagation: S.Literals<readonly ["Bubble", "Stop"]>;
+export declare const EventPropagation: Schema.Literals<readonly ["Bubble", "Stop"]>;
 /** Whether an event continues through its DOM propagation path or stops after
  *  the handlers on its current element have run. */
 export type EventPropagation = typeof EventPropagation.Type;
 /** Declarative controls for an `OnClick` handler. Omitted
  *  fields keep the browser default, allow the click to bubble, and leave focus
  *  unchanged. */
-export declare const ClickOptions: S.Struct<{
-    readonly defaultAction: S.optional<S.Literals<readonly ["Allow", "Prevent"]>>;
-    readonly propagation: S.optional<S.Literals<readonly ["Bubble", "Stop"]>>;
-    readonly focusSelector: S.optional<S.String>;
+export declare const ClickOptions: Schema.Struct<{
+    readonly defaultAction: Schema.optional<Schema.Literals<readonly ["Allow", "Prevent"]>>;
+    readonly propagation: Schema.optional<Schema.Literals<readonly ["Bubble", "Stop"]>>;
+    readonly focusSelector: Schema.optional<Schema.String>;
 }>;
 /** Declarative controls for an `OnClick` handler. Omitted
  *  fields keep the browser default, allow the click to bubble, and leave focus
@@ -85,7 +86,7 @@ export declare const ClickOptions: S.Struct<{
 export type ClickOptions = typeof ClickOptions.Type;
 /** Text direction for the document root, applied to `dir` on the `<html>`
  *  element. `Auto` defers to the browser's first-strong-character heuristic. */
-export declare const TextDirection: S.Literals<readonly ["Ltr", "Rtl", "Auto"]>;
+export declare const TextDirection: Schema.Literals<readonly ["Ltr", "Rtl", "Auto"]>;
 /** Text direction for the document root, applied to `dir` on the `<html>`
  *  element. `Auto` defers to the browser's first-strong-character heuristic. */
 export type TextDirection = typeof TextDirection.Type;
@@ -125,13 +126,16 @@ export type Document = Readonly<{
 export type TagName = 'a' | 'abbr' | 'address' | 'area' | 'article' | 'aside' | 'audio' | 'b' | 'base' | 'bdi' | 'bdo' | 'blockquote' | 'body' | 'br' | 'button' | 'canvas' | 'caption' | 'cite' | 'code' | 'col' | 'colgroup' | 'data' | 'datalist' | 'dd' | 'del' | 'details' | 'dfn' | 'dialog' | 'div' | 'dl' | 'dt' | 'em' | 'embed' | 'fieldset' | 'figcaption' | 'figure' | 'footer' | 'form' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'head' | 'header' | 'hgroup' | 'hr' | 'html' | 'i' | 'iframe' | 'img' | 'input' | 'ins' | 'kbd' | 'label' | 'legend' | 'li' | 'link' | 'main' | 'map' | 'mark' | 'menu' | 'meta' | 'meter' | 'nav' | 'noscript' | 'object' | 'ol' | 'optgroup' | 'option' | 'output' | 'p' | 'picture' | 'portal' | 'pre' | 'progress' | 'q' | 'rp' | 'rt' | 'ruby' | 's' | 'samp' | 'script' | 'search' | 'section' | 'select' | 'slot' | 'small' | 'source' | 'span' | 'strong' | 'style' | 'sub' | 'summary' | 'sup' | 'table' | 'tbody' | 'td' | 'template' | 'textarea' | 'tfoot' | 'th' | 'thead' | 'time' | 'title' | 'tr' | 'track' | 'u' | 'ul' | 'var' | 'video' | 'wbr' | 'animate' | 'animateMotion' | 'animateTransform' | 'circle' | 'clipPath' | 'defs' | 'desc' | 'ellipse' | 'feBlend' | 'feColorMatrix' | 'feComponentTransfer' | 'feComposite' | 'feConvolveMatrix' | 'feDiffuseLighting' | 'feDisplacementMap' | 'feDistantLight' | 'feDropShadow' | 'feFlood' | 'feFuncA' | 'feFuncB' | 'feFuncG' | 'feFuncR' | 'feGaussianBlur' | 'feImage' | 'feMerge' | 'feMergeNode' | 'feMorphology' | 'feOffset' | 'fePointLight' | 'feSpecularLighting' | 'feSpotLight' | 'feTile' | 'feTurbulence' | 'filter' | 'foreignObject' | 'g' | 'image' | 'line' | 'linearGradient' | 'marker' | 'mask' | 'metadata' | 'mpath' | 'path' | 'pattern' | 'polygon' | 'polyline' | 'radialGradient' | 'rect' | 'set' | 'stop' | 'svg' | 'switch' | 'symbol' | 'text' | 'textPath' | 'tspan' | 'use' | 'view' | 'annotation' | 'annotation-xml' | 'math' | 'maction' | 'menclose' | 'merror' | 'mfenced' | 'mfrac' | 'mglyph' | 'mi' | 'mlabeledtr' | 'mlongdiv' | 'mmultiscripts' | 'mn' | 'mo' | 'mover' | 'mpadded' | 'mphantom' | 'mprescripts' | 'mroot' | 'mrow' | 'ms' | 'mscarries' | 'mscarry' | 'msgroup' | 'msline' | 'mspace' | 'msqrt' | 'msrow' | 'mstack' | 'mstyle' | 'msub' | 'msubsup' | 'msup' | 'mtable' | 'mtd' | 'mtext' | 'mtr' | 'munder' | 'munderover' | 'semantics';
 /** Opens a replay-render window. The runtime calls this immediately before a
  *  DevTools time-travel render and closes it with {@link __endReplayRender}
- *  afterward, so any `OnUnmount` destroy hook that fires while the replayed
- *  tree is patched in skips its dispatch. Without the gate the hook would
+ *  afterward, so the `OnUnmount` module can defer live callbacks while the
+ *  replayed tree is patched in. Without the gate the callback would
  *  enqueue a hygiene Message into live history during mere inspection of past
  *  state. */
-export declare const __beginReplayRender: () => void;
+export declare const __beginReplayRender: typeof beginReplayUnmountRender;
 /** Closes the replay-render window opened by {@link __beginReplayRender}. */
-export declare const __endReplayRender: () => void;
+export declare const __endReplayRender: typeof endReplayUnmountRender;
+/** Dispatches the live `OnUnmount` callbacks deferred by a replay patch that
+ *  failed and forced the runtime to discard the damaged DOM. */
+export declare const __flushReplayUnmountsAfterPatchFailure: typeof flushReplayUnmountsAfterPatchFailure;
 /** Key under which the OnMount attribute stamps a `{ name }` marker on the
  *  snabbdom `VNodeData`. Snabbdom passes unknown data fields through without
  *  rendering them to the DOM, so the marker is invisible at runtime but
@@ -142,8 +146,9 @@ export declare const FOLDKIT_MOUNT_KEY: 'foldkitMount';
  *  introspection can identify pending mounts. When the mount lives inside a
  *  Submodel boundary, it also carries that boundary's `toParentMessage` chain
  *  (innermost first), snapshotted at render time, so `Scene.Mount.resolve` can
- *  replay the lift the result travels through in production. The chain is read
- *  only by the Scene harness; production dispatch lifts via `ctx.dispatch`. */
+ *  replay the lift the result travels through in production. Production keeps
+ *  the Mount bound to the dispatcher owned by its acquiring render, then
+ *  resolves that owner's latest chain when the Mount emits. */
 export type FoldkitMountMarker = Readonly<{
     name: string;
     args?: Record<string, unknown>;
@@ -1116,6 +1121,16 @@ export { Prop, OnCustomEvent };
 export declare const customElement: <Message>() => (tagName: string) => (attributes?: ReadonlyArray<Attribute<Message> | ChildAttribute>, children?: ReadonlyArray<Child>) => Html;
 type ElementFunction<Message> = (attributes: ReadonlyArray<Attribute<Message> | ChildAttribute>, children?: ReadonlyArray<Child>) => Html;
 type VoidElementFunction<Message> = (attributes: ReadonlyArray<Attribute<Message> | ChildAttribute>) => Html;
+/** An attribute accepted by textarea builders. Textarea content must use
+ *  `h.Value`; innerHTML does not keep the live value tracking the Model after
+ *  the field is dirty. */
+export type TextareaAttribute<Message> = Exclude<Attribute<Message>, Readonly<{
+    _tag: 'InnerHTML';
+}>>;
+type TextValueElementFunction<Message> = (attributes: ReadonlyArray<TextareaAttribute<Message> | ChildAttribute>) => Html;
+type KeyedElementFunction<Message> = (key: PropertyKey, attributes?: ReadonlyArray<Attribute<Message> | ChildAttribute>, children?: ReadonlyArray<Child>) => Html;
+type KeyedTextValueElementFunction<Message> = (key: PropertyKey, attributes?: ReadonlyArray<TextareaAttribute<Message> | ChildAttribute>) => Html;
+type KeyedFunction<Message> = <Name extends TagName>(tagName: Name) => Name extends 'textarea' ? KeyedTextValueElementFunction<Message> : KeyedElementFunction<Message>;
 type HtmlElements<Message> = {
     a: ElementFunction<Message>;
     abbr: ElementFunction<Message>;
@@ -1217,7 +1232,7 @@ type HtmlElements<Message> = {
     tbody: ElementFunction<Message>;
     td: ElementFunction<Message>;
     template: ElementFunction<Message>;
-    textarea: ElementFunction<Message>;
+    textarea: TextValueElementFunction<Message>;
     tfoot: ElementFunction<Message>;
     th: ElementFunction<Message>;
     thead: ElementFunction<Message>;
@@ -2653,7 +2668,7 @@ type MessageUniverse<Message> = Readonly<{
  */
 export type HtmlBuilder<Message> = MessageUniverse<Message> & HtmlElements<Message> & HtmlAttributes<Message> & Readonly<{
     empty: null;
-    keyed: (tagName: TagName) => (key: PropertyKey, attributes?: ReadonlyArray<Attribute<Message> | ChildAttribute>, children?: ReadonlyArray<Child>) => Html;
+    keyed: KeyedFunction<Message>;
     submodel: <View extends AnySubmodelView>(config: SubmodelConfig<View, Message>) => Html;
 }>;
 /** @internal Returns the process-wide builder singleton retyped to a frame's