foldkit 0.127.0 → 0.128.0

package/dist/experimental/machine/machine.js

@@ -0,0 +1,237 @@
+import { Array, Match as M, Option, Predicate, Record, pipe, } from 'effect';
+const makeEdge = (target, build, commands) => {
+    const narrowGuardValue = (input) => {
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
+        return input;
+    };
+    return {
+        _tag: 'Edge',
+        target,
+        build: input => build(narrowGuardValue(input)),
+        maybeCommands: commands === undefined
+            ? Option.none()
+            : Option.some(input => commands(narrowGuardValue(input))),
+    };
+};
+/**
+ * Declares a transition Edge to the state variant named by `target`. The
+ * `build` callback receives an {@link EdgeInput} whose state and Message are
+ * narrowed to the variants the Edge sits under in the transition table, and
+ * must return the target variant. Optional `commands` attach transition-time
+ * effects.
+ *
+ * Only meaningful inside a {@link TransitionTable}: the source and trigger
+ * types flow in from the table position contextually.
+ */
+export const to = (target, build, commands) => makeEdge(target, build, commands);
+/**
+ * Guards an Edge. Guard lists run in order, and the first guard that passes
+ * fires its Edge. A guard either resolves the state and Message to an
+ * `Option` (returning `Option.some` passes, and the wrapped value flows into
+ * the Edge's build and commands callbacks as `guardValue`) or returns a
+ * plain boolean when there is nothing to extract (returning `true` passes,
+ * and `guardValue` is `void`).
+ *
+ * The state and Message parameters are `NoInfer` so they resolve from the
+ * guard list's table position alone.
+ */
+export const when = (guard, target, build, commands) => ({
+    _tag: 'When',
+    guard: (state, message) => {
+        const result = guard(state, message);
+        if (Predicate.isBoolean(result)) {
+            return result ? Option.some(undefined) : Option.none();
+        }
+        else {
+            return result;
+        }
+    },
+    edge: makeEdge(target, build, commands),
+});
+/** The unconditional fallback at the end of a guard list. The parameter is `NoInfer` for the same reason as {@link when}'s. */
+export const otherwise = (edge) => ({
+    _tag: 'Otherwise',
+    edge,
+});
+const isGuardList = (edgeOrGuardedEdges) => globalThis.Array.isArray(edgeOrGuardedEdges);
+const extractLiteralTag = (tagField) => {
+    if (Predicate.hasProperty(tagField, 'literal') &&
+        Predicate.isString(tagField.literal)) {
+        return Option.some(tagField.literal);
+    }
+    else if (Predicate.hasProperty(tagField, 'schema')) {
+        return extractLiteralTag(tagField.schema);
+    }
+    else {
+        return Option.none();
+    }
+};
+const extractMemberTag = (member) => pipe(Option.some(member), Option.filter(Predicate.hasProperty('fields')), Option.map(struct => struct.fields), Option.filter(Predicate.hasProperty('_tag')), Option.flatMap(fields => extractLiteralTag(fields._tag)));
+/**
+ * Compiles a declarative transition table into a {@link Machine}.
+ *
+ * Two stages: the first takes the state and Message union Schemas and fixes
+ * the type parameters, the second takes the initial state and the transition
+ * table. The split is what lets TypeScript narrow `state` and `message`
+ * inside every Edge from its table position: a single-call form checks the
+ * table while the type parameters are still being inferred, and the
+ * narrowing collapses.
+ *
+ * The Machine is not a runtime: `transition` has the same shape as a Foldkit
+ * `update` branch and returns `[nextState, commands]`, so the machine state
+ * lives in the Model and the Foldkit runtime never learns the Machine
+ * exists. Messages that match no Edge leave the state unchanged; use `step`
+ * when the `Ignored` outcome should be observable.
+ *
+ * Because every Edge names a literal target tag, the Edge set is plain data:
+ * `reachableFrom`, `unreachableStates`, `deadTransitions`, and `toMermaid`
+ * all read it directly.
+ */
+export const define = (schemas) => (definition) => {
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
+    const looseStates = definition.states;
+    const initialTag = definition.initial._tag;
+    const stateTags = pipe(schemas.state.members, Array.map(member => Option.getOrThrowWith(extractMemberTag(member), () => new Error('Machine.define: every member of the state union Schema must be a Struct with a literal _tag field'))), 
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions */
+    tags => tags);
+    const makeEdgeSummary = (from, messageTag, target, guard) => ({ from, messageTag, target, guard });
+    const summarizeEntry = (from, messageTag, edgeOrGuardedEdges) => isGuardList(edgeOrGuardedEdges)
+        ? Array.map(edgeOrGuardedEdges, (guardedEdge, position) => guardedEdge._tag === 'When'
+            ? makeEdgeSummary(from, messageTag, guardedEdge.edge.target, {
+                _tag: 'When',
+                position,
+            })
+            : makeEdgeSummary(from, messageTag, guardedEdge.edge.target, {
+                _tag: 'Otherwise',
+                position,
+            }))
+        : [
+            makeEdgeSummary(from, messageTag, edgeOrGuardedEdges.target, {
+                _tag: 'Unguarded',
+            }),
+        ];
+    const edges = pipe(Record.toEntries(looseStates), Array.flatMap(([sourceTag, stateEntry]) => pipe(Record.toEntries(stateEntry.on), Array.flatMap(([messageTag, edgeOrGuardedEdges]) => summarizeEntry(sourceTag, messageTag, edgeOrGuardedEdges)))));
+    const selectFromGuardList = (guardedEdges, state, message) => Array.matchLeft(guardedEdges, {
+        onEmpty: () => Option.none(),
+        onNonEmpty: (guardedEdge, rest) => {
+            if (guardedEdge._tag === 'When') {
+                const maybeGuardValue = guardedEdge.guard(state, message);
+                if (Option.isSome(maybeGuardValue)) {
+                    return Option.some({
+                        edge: guardedEdge.edge,
+                        guardValue: maybeGuardValue.value,
+                    });
+                }
+                else {
+                    return selectFromGuardList(rest, state, message);
+                }
+            }
+            else {
+                return Option.some({
+                    edge: guardedEdge.edge,
+                    guardValue: undefined,
+                });
+            }
+        },
+    });
+    const chooseEdge = (edgeOrGuardedEdges, state, message) => isGuardList(edgeOrGuardedEdges)
+        ? selectFromGuardList(edgeOrGuardedEdges, state, message)
+        : Option.some({ edge: edgeOrGuardedEdges, guardValue: undefined });
+    const makeTransitioned = (state, message, selectedEdge) => ({
+        _tag: 'Transitioned',
+        from: state._tag,
+        target: selectedEdge.edge.target,
+        messageTag: message._tag,
+        state: selectedEdge.edge.build({
+            state,
+            message,
+            guardValue: selectedEdge.guardValue,
+        }),
+        commands: Option.match(selectedEdge.edge.maybeCommands, {
+            onNone: () => [],
+            onSome: buildCommands => buildCommands({
+                state,
+                message,
+                guardValue: selectedEdge.guardValue,
+            }),
+        }),
+    });
+    const makeIgnored = (state, message) => ({
+        _tag: 'Ignored',
+        stateTag: state._tag,
+        messageTag: message._tag,
+        state,
+    });
+    const step = (state, message) => pipe(Record.get(looseStates, state._tag), Option.flatMap(stateEntry => Record.get(stateEntry.on, message._tag)), Option.flatMap(edgeOrGuardedEdges => chooseEdge(edgeOrGuardedEdges, state, message)), Option.match({
+        onNone: () => makeIgnored(state, message),
+        onSome: selectedEdge => makeTransitioned(state, message, selectedEdge),
+    }));
+    const transition = (state, message) => {
+        const result = step(state, message);
+        if (result._tag === 'Transitioned') {
+            return [result.state, result.commands];
+        }
+        else {
+            return [result.state, []];
+        }
+    };
+    const targetsFrom = (tag) => pipe(edges, Array.filter(edgeSummary => edgeSummary.from === tag), Array.map(edgeSummary => edgeSummary.target));
+    const reachableFrom = (tag) => {
+        const visit = (frontier, visited) => Array.matchLeft(frontier, {
+            onEmpty: () => visited,
+            onNonEmpty: (head, tail) => visited.has(head)
+                ? visit(tail, visited)
+                : visit([...tail, ...targetsFrom(head)], new Set([...visited, head])),
+        });
+        return visit([tag], new Set());
+    };
+    const unreachableStates = () => {
+        const reachable = reachableFrom(initialTag);
+        return Array.filter(stateTags, stateTag => !reachable.has(stateTag));
+    };
+    const makeDeadTransition = (edge, reason) => ({ edge, reason });
+    const guardPosition = (edgeSummary) => edgeSummary.guard._tag === 'Unguarded'
+        ? Option.none()
+        : Option.some(edgeSummary.guard.position);
+    const shadowedEdges = () => pipe(edges, Array.groupBy(edgeSummary => `${edgeSummary.from}|${edgeSummary.messageTag}`), Record.values, Array.flatMap(group => {
+        const maybeOtherwisePosition = pipe(group, Array.findFirst(edgeSummary => edgeSummary.guard._tag === 'Otherwise'), Option.flatMap(guardPosition));
+        return Option.match(maybeOtherwisePosition, {
+            onNone: () => [],
+            onSome: otherwisePosition => pipe(group, Array.filter(edgeSummary => Option.match(guardPosition(edgeSummary), {
+                onNone: () => false,
+                onSome: position => position > otherwisePosition,
+            })), Array.map(edgeSummary => makeDeadTransition(edgeSummary, 'ShadowedByOtherwise'))),
+        });
+    }));
+    const deadTransitions = () => {
+        const reachable = reachableFrom(initialTag);
+        const unreachableSourceEdges = pipe(edges, Array.filter(edgeSummary => !reachable.has(edgeSummary.from)), Array.map(edgeSummary => makeDeadTransition(edgeSummary, 'UnreachableSource')));
+        return [...unreachableSourceEdges, ...shadowedEdges()];
+    };
+    const toMermaid = () => {
+        const guardLabel = (guard) => M.value(guard).pipe(M.tagsExhaustive({
+            Unguarded: () => '',
+            When: ({ position }) => ` [when ${position + 1}]`,
+            Otherwise: () => ' [otherwise]',
+        }));
+        const stateLines = Array.map(stateTags, stateTag => `  ${stateTag}`);
+        const transitionLines = Array.map(edges, edgeSummary => `  ${edgeSummary.from} --> ${edgeSummary.target}: ${edgeSummary.messageTag}${guardLabel(edgeSummary.guard)}`);
+        return Array.join([
+            'stateDiagram-v2',
+            ...stateLines,
+            `  [*] --> ${initialTag}`,
+            ...transitionLines,
+        ], '\n');
+    };
+    return {
+        initial: definition.initial,
+        stateTags,
+        edges,
+        transition,
+        step,
+        reachableFrom,
+        unreachableStates,
+        deadTransitions,
+        toMermaid,
+    };
+};

package/dist/experimental/machine/public.d.ts

@@ -0,0 +1,2 @@
+export * from './index.js';
+//# sourceMappingURL=public.d.ts.map

package/dist/experimental/machine/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../src/experimental/machine/public.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/dist/experimental/machine/public.js

@@ -0,0 +1 @@
+export * from './index.js';

package/dist/experimental/public.d.ts

@@ -0,0 +1,2 @@
+export * from './index.js';
+//# sourceMappingURL=public.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../src/experimental/public.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/dist/experimental/public.js

@@ -0,0 +1 @@
+export * from './index.js';

package/dist/html/boundary.d.ts

@@ -105,6 +105,15 @@ export declare const deregisterBoundaryWrap: (registry: BoundaryRegistry, bounda
  *  avoids that race. Throws here (at resolve time, boundary alive) if a wrap is
  *  somehow already missing, surfacing a real corruption rather than misrouting. */
 export declare const resolveBoundaryDispatchThunk: (registry: BoundaryRegistry, outerDispatch: DispatchSync, boundaryId: BoundaryId, message: unknown) => (() => void);
+/** Collects the `toParentMessage` wrapping chain for `boundaryId`, innermost
+ *  ancestor first, against the wraps present right now. Folding the returned
+ *  functions left-to-right over a child message reproduces exactly what
+ *  {@link dispatchAcrossBoundary} dispatches, without dispatching. Returns an
+ *  empty array at the root boundary. Used by `OnMount` to snapshot a
+ *  Submodel-embedded mount's lift eagerly so the Scene test harness can replay
+ *  it when the mount is resolved. Throws when an ancestor wrap is missing
+ *  (boundary alive at call time), matching {@link dispatchAcrossBoundary}. */
+export declare const boundaryMappers: (registry: BoundaryRegistry, boundaryId: BoundaryId) => ReadonlyArray<(message: unknown) => unknown>;
 export declare const getOrCreateBoundaryDispatch: (registry: BoundaryRegistry, outerDispatch: DispatchSync, boundaryId: BoundaryId) => DispatchSync;
 /** Called at the start of each top-level render. Clears the
  *  per-render duplicate-slotId tracking map so siblings inside the

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

@@ -1 +1 @@
-{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../src/html/boundary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEzD,wDAAwD;AACxD,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,eAAe,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAA;CAC/C,CAAC,CAAA;AAEF;;;;eAIe;AACf,MAAM,MAAM,UAAU,GAAG,MAAM,CAAA;AAI/B,eAAO,MAAM,aAAa,EAAE,UAAe,CAAA;AAE3C,eAAO,MAAM,eAAe,GAC1B,QAAQ,UAAU,EAClB,SAAS,MAAM,KACd,UAUF,CAAA;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAwCa;AACb,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,UAAU,EAAE,cAAc,CAAC,CAAA;IAC/C,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAClC,YAAY,EACZ,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,CAC9B,CAAA;IACD,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAAA;IAChD,QAAQ,CAAC,iBAAiB,EAAE,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAA;IAI1D,QAAQ,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CACjC,CAAA;AAED,eAAO,MAAM,sBAAsB,QAAO,gBAMxC,CAAA;AAqBF,eAAO,MAAM,oBAAoB,GAC/B,UAAU,gBAAgB,EAC1B,YAAY,UAAU,EACtB,YAAY,cAAc,KACzB,IA6BF,CAAA;AAED;;;;wCAIwC;AACxC,eAAO,MAAM,iBAAiB,GAC5B,UAAU,gBAAgB,KACzB,GAAG,CAAC,UAAU,EAAE,MAAM,CAIxB,CAAA;AAED;;yCAEyC;AACzC,eAAO,MAAM,eAAe,GAAI,UAAU,gBAAgB,KAAG,IAQ5D,CAAA;AAED;;;;;;;4CAO4C;AAC5C,eAAO,MAAM,kBAAkB,GAC7B,UAAU,gBAAgB,EAC1B,YAAY,WAAW,CAAC,UAAU,EAAE,MAAM,CAAC,KAC1C,IAWF,CAAA;AAED;;;;;;;;;gBASgB;AAChB,eAAO,MAAM,sBAAsB,GACjC,UAAU,gBAAgB,EAC1B,YAAY,UAAU,KACrB,IAEF,CAAA;AA8CD;;;;;;;;;;;;mFAYmF;AACnF,eAAO,MAAM,4BAA4B,GACvC,UAAU,gBAAgB,EAC1B,eAAe,YAAY,EAC3B,YAAY,UAAU,EACtB,SAAS,OAAO,KACf,CAAC,MAAM,IAAI,CAqBb,CAAA;AAED,eAAO,MAAM,2BAA2B,GACtC,UAAU,gBAAgB,EAC1B,eAAe,YAAY,EAC3B,YAAY,UAAU,KACrB,YAkBF,CAAA;AAED;;;;;;;;;;iEAUiE;AACjE,eAAO,MAAM,WAAW,GAAI,UAAU,gBAAgB,KAAG,IAGxD,CAAA"}
+{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../src/html/boundary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEzD,wDAAwD;AACxD,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;IACpC,eAAe,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAA;CAC/C,CAAC,CAAA;AAEF;;;;eAIe;AACf,MAAM,MAAM,UAAU,GAAG,MAAM,CAAA;AAI/B,eAAO,MAAM,aAAa,EAAE,UAAe,CAAA;AAE3C,eAAO,MAAM,eAAe,GAC1B,QAAQ,UAAU,EAClB,SAAS,MAAM,KACd,UAUF,CAAA;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAwCa;AACb,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,UAAU,EAAE,cAAc,CAAC,CAAA;IAC/C,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAClC,YAAY,EACZ,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,CAC9B,CAAA;IACD,QAAQ,CAAC,cAAc,EAAE,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAAA;IAChD,QAAQ,CAAC,iBAAiB,EAAE,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAA;IAI1D,QAAQ,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CACjC,CAAA;AAED,eAAO,MAAM,sBAAsB,QAAO,gBAMxC,CAAA;AAqBF,eAAO,MAAM,oBAAoB,GAC/B,UAAU,gBAAgB,EAC1B,YAAY,UAAU,EACtB,YAAY,cAAc,KACzB,IA6BF,CAAA;AAED;;;;wCAIwC;AACxC,eAAO,MAAM,iBAAiB,GAC5B,UAAU,gBAAgB,KACzB,GAAG,CAAC,UAAU,EAAE,MAAM,CAIxB,CAAA;AAED;;yCAEyC;AACzC,eAAO,MAAM,eAAe,GAAI,UAAU,gBAAgB,KAAG,IAQ5D,CAAA;AAED;;;;;;;4CAO4C;AAC5C,eAAO,MAAM,kBAAkB,GAC7B,UAAU,gBAAgB,EAC1B,YAAY,WAAW,CAAC,UAAU,EAAE,MAAM,CAAC,KAC1C,IAWF,CAAA;AAED;;;;;;;;;gBASgB;AAChB,eAAO,MAAM,sBAAsB,GACjC,UAAU,gBAAgB,EAC1B,YAAY,UAAU,KACrB,IAEF,CAAA;AA8CD;;;;;;;;;;;;mFAYmF;AACnF,eAAO,MAAM,4BAA4B,GACvC,UAAU,gBAAgB,EAC1B,eAAe,YAAY,EAC3B,YAAY,UAAU,EACtB,SAAS,OAAO,KACf,CAAC,MAAM,IAAI,CAqBb,CAAA;AAED;;;;;;;8EAO8E;AAC9E,eAAO,MAAM,eAAe,GAC1B,UAAU,gBAAgB,EAC1B,YAAY,UAAU,KACrB,aAAa,CAAC,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAiB7C,CAAA;AAED,eAAO,MAAM,2BAA2B,GACtC,UAAU,gBAAgB,EAC1B,eAAe,YAAY,EAC3B,YAAY,UAAU,KACrB,YAkBF,CAAA;AAED;;;;;;;;;;iEAUiE;AACjE,eAAO,MAAM,WAAW,GAAI,UAAU,gBAAgB,KAAG,IAGxD,CAAA"}

package/dist/html/boundary.js

@@ -183,6 +183,30 @@ export const resolveBoundaryDispatchThunk = (registry, outerDispatch, boundaryId
     const rootMessage = wrapped;
     return () => outerDispatch(rootMessage);
 };
+/** Collects the `toParentMessage` wrapping chain for `boundaryId`, innermost
+ *  ancestor first, against the wraps present right now. Folding the returned
+ *  functions left-to-right over a child message reproduces exactly what
+ *  {@link dispatchAcrossBoundary} dispatches, without dispatching. Returns an
+ *  empty array at the root boundary. Used by `OnMount` to snapshot a
+ *  Submodel-embedded mount's lift eagerly so the Scene test harness can replay
+ *  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;
+};
 export const getOrCreateBoundaryDispatch = (registry, outerDispatch, boundaryId) => {
     if (boundaryId === ROOT_BOUNDARY) {
         return outerDispatch;

package/dist/html/childAttribute.d.ts

@@ -10,7 +10,9 @@ 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.
+ *  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.
  *
  *  Created via {@link childAttributes}. Element constructors accept
  *  `ChildAttribute` alongside `Attribute<Message>` in their attribute
@@ -20,6 +22,7 @@ export type ChildAttribute = Readonly<{
     readonly attribute: unknown;
     readonly dispatch: DispatchSync;
     readonly resolveUnmount: (message: unknown) => () => void;
+    readonly boundaryMappers: ReadonlyArray<(message: unknown) => unknown>;
 }>;
 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,EAGlB,MAAM,uBAAuB,CAAA;AAE9B,QAAA,MAAM,KAAK,qBAAqB,CAAA;AAEhC;;;;;;;;;;;;;;cAcc;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;CAC1D,CAAC,CAAA;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,cACI,CAAA;AAE/D;;;;;;;;;;;;;;;;;;;;;;oCAsBoC;AACpC,eAAO,MAAM,eAAe,GAAI,SAAS,EACvC,YAAY,aAAa,CAAC,SAAS,CAAC,KACnC,aAAa,CAAC,cAAc,CAS9B,CAAA"}
+{"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,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,cACI,CAAA;AAE/D;;;;;;;;;;;;;;;;;;;;;;oCAsBoC;AACpC,eAAO,MAAM,eAAe,GAAI,SAAS,EACvC,YAAY,aAAa,CAAC,SAAS,CAAC,KACnC,aAAa,CAAC,cAAc,CAW9B,CAAA"}

package/dist/html/childAttribute.js

@@ -1,4 +1,4 @@
-import { requireDispatch, requireUnmountResolver, } from './runtimeSingleton.js';
+import { requireBoundaryMappers, requireDispatch, requireUnmountResolver, } from './runtimeSingleton.js';
 const BRAND = '__childAttribute';
 export const isChildAttribute = (value) => typeof value === 'object' && value !== null && BRAND in value;
 /** Captures the current boundary's dispatcher and wraps each attribute
@@ -27,10 +27,12 @@ export const isChildAttribute = (value) => typeof value === 'object' && value !=
 export const childAttributes = (attributes) => {
     const dispatch = requireDispatch();
     const resolveUnmount = requireUnmountResolver();
+    const boundaryMappers = requireBoundaryMappers();
     return attributes.map(attribute => ({
         [BRAND]: true,
         attribute,
         dispatch,
         resolveUnmount,
+        boundaryMappers,
     }));
 };

package/dist/html/index.d.ts

@@ -93,11 +93,16 @@ export declare const __endReplayRender: () => void;
  *  observable by VNode walkers (Scene tests). */
 export declare const FOLDKIT_MOUNT_KEY: "foldkitMount";
 /** Marker stamped on `VNodeData[FOLDKIT_MOUNT_KEY]` for any element with an
- *  `OnMount` attribute. Carries the Mount Definition's name so test
- *  introspection can identify pending mounts. */
+ *  `OnMount` attribute. Carries the Mount Definition's name (and args) so test
+ *  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`. */
 export type FoldkitMountMarker = Readonly<{
     name: string;
     args?: Record<string, unknown>;
+    messageMappers?: ReadonlyArray<(message: unknown) => unknown>;
 }>;
 /** Union of all HTML, SVG, and MathML attributes a virtual DOM element can carry.
  *
@@ -206,6 +211,12 @@ export type Attribute<Message> = Data.TaggedEnum<{
     OnKeyDownPreventDefault: {
         readonly f: (key: string, modifiers: KeyboardModifiers) => Option.Option<Message>;
     };
+    OnKeyDownFocus: {
+        readonly f: (key: string, modifiers: KeyboardModifiers) => Option.Option<Readonly<{
+            focusSelector: string;
+            message: Message;
+        }>>;
+    };
     OnKeyUp: {
         readonly f: (key: string, modifiers: KeyboardModifiers) => Message;
     };
@@ -1063,6 +1074,7 @@ declare const buildHtmlFactory: <Message>() => {
         readonly attribute: unknown;
         readonly dispatch: DispatchSync;
         readonly resolveUnmount: (message: unknown) => () => void;
+        readonly boundaryMappers: ReadonlyArray<(message: unknown) => unknown>;
         readonly __childAttribute: true;
     }> | {
         readonly _tag: "Type";
@@ -1189,6 +1201,17 @@ declare const buildHtmlFactory: <Message>() => {
             altKey: boolean;
             metaKey: boolean;
         }>) => Option.Option<Message>;
+    } | {
+        readonly _tag: "OnKeyDownFocus";
+        readonly f: (key: string, modifiers: Readonly<{
+            shiftKey: boolean;
+            ctrlKey: boolean;
+            altKey: boolean;
+            metaKey: boolean;
+        }>) => Option.Option<Readonly<{
+            focusSelector: string;
+            message: Message;
+        }>>;
     } | {
         readonly _tag: "OnKeyUp";
         readonly f: (key: string, modifiers: Readonly<{
@@ -2161,6 +2184,26 @@ declare const buildHtmlFactory: <Message>() => {
             metaKey: boolean;
         }>) => Message;
     };
+    OnKeyDownFocus: (f: (key: string, modifiers: Readonly<{
+        shiftKey: boolean;
+        ctrlKey: boolean;
+        altKey: boolean;
+        metaKey: boolean;
+    }>) => Option.Option<Readonly<{
+        focusSelector: string;
+        message: Message;
+    }>>) => {
+        readonly _tag: "OnKeyDownFocus";
+        readonly f: (key: string, modifiers: Readonly<{
+            shiftKey: boolean;
+            ctrlKey: boolean;
+            altKey: boolean;
+            metaKey: boolean;
+        }>) => Option.Option<Readonly<{
+            focusSelector: string;
+            message: Message;
+        }>>;
+    };
     OnKeyDownPreventDefault: (f: (key: string, modifiers: Readonly<{
         shiftKey: boolean;
         ctrlKey: boolean;