@zenithbuild/runtime 0.7.4 → 0.7.7

package/dist/expressions.js

@@ -1,6 +1,7 @@
 import { throwZenithRuntimeError, DOCS_LINKS } from './diagnostics.js';
 import { _fragment } from './markup.js';
 export const UNRESOLVED_LITERAL = Symbol('unresolved_literal');
+const OWN = Object.prototype.hasOwnProperty;
 export const STRICT_MEMBER_CHAIN_LITERAL_RE = /^(?:true|false|null|undefined|[A-Za-z_$][A-Za-z0-9_$]*(\.[A-Za-z_$][A-Za-z0-9_$]*)*)$/;
 export const CANONICAL_MEMBER_CHAIN_BASES = new Set(['props', 'params', 'data', 'ssr']);
 export const UNSAFE_MEMBER_KEYS = new Set(['__proto__', 'prototype', 'constructor']);
@@ -17,109 +18,60 @@ export function _resolveExpressionSignalIndices(binding) {
     return [];
 }
 export function _evaluateExpression(binding, stateValues, stateKeys, signalMap, componentBindings, params, ssrData, mode, props, exprFns, markerBinding = null, eventBinding = null) {
-    if (binding.fn_index != null && binding.fn_index !== undefined) {
-        const fns = Array.isArray(exprFns) ? exprFns : [];
-        const fn = fns[binding.fn_index];
+    const runtimeProps = props || {};
+    if (binding.fn_index != null) {
+        const fn = Array.isArray(exprFns) ? exprFns[binding.fn_index] : undefined;
         if (typeof fn === 'function') {
-            try {
-                return fn({
-                    signalMap,
-                    params,
-                    ssrData,
-                    props: props || {},
-                    componentBindings,
-                    fragment: _fragment
-                });
-            }
-            catch (fnErr) {
-                throw fnErr;
-            }
+            return fn({
+                signalMap,
+                params,
+                ssrData,
+                props: runtimeProps,
+                componentBindings,
+                fragment: _fragment
+            });
         }
     }
-    if (binding.signal_index !== null && binding.signal_index !== undefined) {
+    if (binding.signal_index != null) {
         const signalValue = signalMap.get(binding.signal_index);
         if (!signalValue || typeof signalValue.get !== 'function') {
             throw new Error('[Zenith Runtime] expression.signal_index did not resolve to a signal');
         }
-        return mode === 'event' ? signalValue : signalValue.get();
+        return _rvm(signalValue, mode);
     }
-    if (binding.state_index !== null && binding.state_index !== undefined) {
-        const resolved = stateValues[binding.state_index];
-        if (mode !== 'event' &&
-            resolved &&
-            typeof resolved === 'object' &&
-            typeof resolved.get === 'function') {
-            return resolved.get();
-        }
-        if (mode !== 'event' && typeof resolved === 'function') {
-            return resolved();
-        }
-        return resolved;
+    if (binding.state_index != null) {
+        return _rvm(stateValues[binding.state_index], mode);
     }
     if (typeof binding.component_instance === 'string' && typeof binding.component_binding === 'string') {
-        const instanceBindings = componentBindings[binding.component_instance];
-        const resolved = instanceBindings && Object.prototype.hasOwnProperty.call(instanceBindings, binding.component_binding)
-            ? instanceBindings[binding.component_binding]
-            : undefined;
-        if (mode !== 'event' &&
-            resolved &&
-            typeof resolved === 'object' &&
-            typeof resolved.get === 'function') {
-            return resolved.get();
-        }
-        if (mode !== 'event' && typeof resolved === 'function') {
-            return resolved();
-        }
-        return resolved;
+        return _rvm(_rcb(binding, componentBindings), mode);
     }
-    if (binding.literal !== null && binding.literal !== undefined) {
-        if (typeof binding.literal === 'string') {
-            const trimmedLiteral = binding.literal.trim();
-            // 1. Static primitives (true, false, null, undefined, numbers, quoted strings)
-            const primitiveValue = _resolvePrimitiveLiteral(trimmedLiteral);
-            if (primitiveValue !== UNRESOLVED_LITERAL) {
-                return primitiveValue;
-            }
-            // 2. Canonical payload roots
-            if (trimmedLiteral === 'data' || trimmedLiteral === 'ssr') {
-                return ssrData;
-            }
-            if (trimmedLiteral === 'params') {
-                return params;
-            }
-            if (trimmedLiteral === 'props') {
-                return props || {};
-            }
-            // 3. Bounded canonical member chains (props.*, params.*, data.*, ssr.*, exact stateKeys)
-            const strictMemberValue = _resolveStrictMemberChainLiteral(trimmedLiteral, stateValues, stateKeys, params, ssrData, mode, props, binding.marker_index, _resolveBindingSource(binding, markerBinding, eventBinding));
-            if (strictMemberValue !== UNRESOLVED_LITERAL) {
-                return strictMemberValue;
-            }
-            // 4. Anything else is a literal that was not lowered by the compiler.
-            //    No heuristic guessing, no identifier extraction, no alias recovery.
-            throwZenithRuntimeError({
-                phase: 'bind',
-                code: 'EXPRESSION_NOT_LOWERED',
-                message: `Expression literal was not lowered by the compiler: ${_truncateLiteralForError(trimmedLiteral)}`,
-                marker: {
-                    type: _markerTypeForError(mode),
-                    id: binding.marker_index
-                },
-                path: `expression[${binding.marker_index}]`,
-                hint: 'This expression must be lowered to fn_index, signal_index, or state_index by the compiler. Literal string interpretation is restricted to static primitives and canonical member chains (props.*, params.*, data.*, ssr.*).',
-                docsLink: DOCS_LINKS.expressionScope,
-                source: _resolveBindingSource(binding, markerBinding, eventBinding)
-            });
-        }
+    if (binding.literal == null) {
+        return '';
+    }
+    if (typeof binding.literal !== 'string') {
         return binding.literal;
     }
-    return '';
+    const trimmedLiteral = binding.literal.trim();
+    const primitiveValue = _resolvePrimitiveLiteral(trimmedLiteral);
+    if (primitiveValue !== UNRESOLVED_LITERAL) {
+        return primitiveValue;
+    }
+    const canonicalRootValue = _rcr(trimmedLiteral, params, ssrData, runtimeProps);
+    if (canonicalRootValue !== UNRESOLVED_LITERAL) {
+        return canonicalRootValue;
+    }
+    const source = _resolveBindingSource(binding, markerBinding, eventBinding);
+    const strictMemberValue = _resolveStrictMemberChainLiteral(trimmedLiteral, stateValues, stateKeys, params, ssrData, mode, runtimeProps, binding.marker_index, source);
+    if (strictMemberValue !== UNRESOLVED_LITERAL) {
+        return strictMemberValue;
+    }
+    _tenl(trimmedLiteral, binding.marker_index, mode, source);
 }
 export function _throwUnresolvedMemberChainError(literal, markerIndex, mode, pathSuffix, hint, source) {
     throwZenithRuntimeError({
         phase: 'bind',
         code: 'UNRESOLVED_EXPRESSION',
-        message: `Failed to resolve expression literal: ${_truncateLiteralForError(literal)}`,
+        message: `Failed to resolve literal: ${_truncateLiteralForError(literal)}`,
         marker: {
             type: _markerTypeForError(mode),
             id: markerIndex
@@ -134,53 +86,53 @@ export function _resolveStrictMemberChainLiteral(literal, stateValues, stateKeys
     if (typeof literal !== 'string' || !STRICT_MEMBER_CHAIN_LITERAL_RE.test(literal)) {
         return UNRESOLVED_LITERAL;
     }
-    // Primitives are handled by _resolvePrimitiveLiteral before this function
     if (literal === 'true' || literal === 'false' || literal === 'null' || literal === 'undefined') {
         return UNRESOLVED_LITERAL;
     }
     const segments = literal.split('.');
     const baseIdentifier = segments[0];
-    // Bounded resolution: only canonical payload prefixes and exact state keys
-    const isCanonicalBase = CANONICAL_MEMBER_CHAIN_BASES.has(baseIdentifier);
-    const isExactStateKey = !isCanonicalBase && Array.isArray(stateKeys) && stateKeys.includes(baseIdentifier);
-    if (!isCanonicalBase && !isExactStateKey) {
-        // Not a canonical base and not an exact state key — this literal was not lowered
+    const baseValue = _resolveStrictBase(baseIdentifier, stateValues, stateKeys, params, ssrData, props);
+    if (baseValue === UNRESOLVED_LITERAL) {
         return UNRESOLVED_LITERAL;
     }
-    const scope = _buildLiteralScope(stateValues, stateKeys, params, ssrData, mode, props);
-    if (!Object.prototype.hasOwnProperty.call(scope, baseIdentifier)) {
-        _throwUnresolvedMemberChainError(literal, markerIndex, mode, `expression.${baseIdentifier}`, `Base identifier "${baseIdentifier}" is not bound. Check props/data/params and declared state keys.`, source);
-    }
-    let cursor = scope[baseIdentifier];
+    const failResolve = (suffix, hint) => _throwUnresolvedMemberChainError(literal, markerIndex, mode, `expression.${suffix}`, hint, source);
+    let cursor = baseValue;
     let traversedPath = baseIdentifier;
     for (let i = 1; i < segments.length; i++) {
         const segment = segments[i];
         if (UNSAFE_MEMBER_KEYS.has(segment)) {
-            throwZenithRuntimeError({
-                phase: 'bind',
-                code: 'UNSAFE_MEMBER_ACCESS',
-                message: `Blocked unsafe member access: ${segment} in path "${literal}"`,
-                path: `marker[${markerIndex}].expression.${literal}`,
-                hint: 'Property access to __proto__, prototype, and constructor is forbidden.',
-                docsLink: DOCS_LINKS.expressionScope,
-                source
-            });
+            _tuma(literal, markerIndex, segment, source);
         }
         if (cursor === null || cursor === undefined) {
-            _throwUnresolvedMemberChainError(literal, markerIndex, mode, `expression.${traversedPath}.${segment}`, `Cannot read "${segment}" from ${traversedPath} because it is null or undefined.`, source);
+            failResolve(`${traversedPath}.${segment}`, `Cannot read "${segment}" from ${traversedPath}; value is null/undefined.`);
         }
         const cursorType = typeof cursor;
         if (cursorType !== 'object' && cursorType !== 'function') {
-            _throwUnresolvedMemberChainError(literal, markerIndex, mode, `expression.${traversedPath}.${segment}`, `Cannot read "${segment}" from ${traversedPath} because it resolved to a ${cursorType}.`, source);
+            failResolve(`${traversedPath}.${segment}`, `Cannot read "${segment}" from ${traversedPath}; value is ${cursorType}.`);
         }
-        if (!Object.prototype.hasOwnProperty.call(cursor, segment)) {
-            _throwUnresolvedMemberChainError(literal, markerIndex, mode, `expression.${traversedPath}.${segment}`, `Missing member "${segment}" on ${traversedPath}. Check your bindings.`, source);
+        if (!OWN.call(cursor, segment)) {
+            failResolve(`${traversedPath}.${segment}`, `Missing member "${segment}" on ${traversedPath}.`);
         }
         cursor = cursor[segment];
         traversedPath = `${traversedPath}.${segment}`;
     }
     return cursor;
 }
+function _resolveStrictBase(baseIdentifier, stateValues, stateKeys, params, ssrData, props) {
+    if (baseIdentifier === '__zenith_fragment')
+        return _fragment;
+    if (CANONICAL_MEMBER_CHAIN_BASES.has(baseIdentifier)) {
+        if (baseIdentifier === 'props')
+            return props || {};
+        if (baseIdentifier === 'params')
+            return params;
+        return ssrData;
+    }
+    if (!Array.isArray(stateKeys))
+        return UNRESOLVED_LITERAL;
+    const stateIndex = stateKeys.indexOf(baseIdentifier);
+    return stateIndex === -1 ? UNRESOLVED_LITERAL : stateValues[stateIndex];
+}
 export function _resolvePrimitiveLiteral(literal) {
     if (typeof literal !== 'string') {
         return UNRESOLVED_LITERAL;
@@ -215,45 +167,21 @@ export function _resolvePrimitiveLiteral(literal) {
     }
     return UNRESOLVED_LITERAL;
 }
-export function _buildLiteralScope(stateValues, stateKeys, params, ssrData, mode, props) {
-    const scope = Object.create(null);
-    scope.params = params;
-    scope.data = ssrData;
-    scope.ssr = ssrData;
-    scope.props = props || {};
-    scope.__zenith_fragment = _fragment;
-    // Exact state keys only — no alias derivation, no mangled-name recovery
-    if (Array.isArray(stateKeys)) {
-        for (let i = 0; i < stateKeys.length; i++) {
-            const key = stateKeys[i];
-            if (typeof key !== 'string' || key.length === 0) {
-                continue;
-            }
-            if (Object.prototype.hasOwnProperty.call(scope, key)) {
-                continue;
-            }
-            scope[key] = stateValues[i];
-        }
-    }
-    return scope;
-}
-// _isLikelyExpressionLiteral and _extractMissingIdentifier removed:
-// Runtime no longer performs heuristic identifier extraction or expression
-// shape guessing. Unresolved literals throw EXPRESSION_NOT_LOWERED directly.
 export function _resolveBindingSource(binding, markerBinding, eventBinding) {
-    const candidates = [
-        binding?.source,
-        eventBinding?.source,
-        markerBinding?.source
-    ];
-    for (let i = 0; i < candidates.length; i++) {
-        const candidate = candidates[i];
-        if (candidate && typeof candidate === 'object' && typeof candidate.file === 'string') {
-            return candidate;
-        }
-    }
+    const source = binding?.source;
+    if (_isSourceSpan(source))
+        return source;
+    const eventSource = eventBinding?.source;
+    if (_isSourceSpan(eventSource))
+        return eventSource;
+    const markerSource = markerBinding?.source;
+    if (_isSourceSpan(markerSource))
+        return markerSource;
     return undefined;
 }
+function _isSourceSpan(value) {
+    return Boolean(value) && typeof value === 'object' && typeof value.file === 'string';
+}
 export function _describeBindingExpression(binding) {
     if (!binding || typeof binding !== 'object') {
         return '<unknown>';
@@ -286,10 +214,60 @@ export function _truncateLiteralForError(str) {
         return String(str);
     const sanitized = str
         .replace(/[A-Za-z]:\\[^\s"'`]+/g, '<path>')
-        .replace(/\/Users\/[^\s"'`]+/g, '<path>')
-        .replace(/\/home\/[^\s"'`]+/g, '<path>')
-        .replace(/\/private\/[^\s"'`]+/g, '<path>')
-        .replace(/\/tmp\/[^\s"'`]+/g, '<path>')
-        .replace(/\/var\/folders\/[^\s"'`]+/g, '<path>');
+        .replace(/\/(?:Users|home|private|tmp|var\/folders)\/[^\s"'`]+/g, '<path>');
     return sanitized.length > 100 ? `${sanitized.substring(0, 97)}...` : sanitized;
 }
+function _rvm(value, mode) {
+    if (mode === 'event') {
+        return value;
+    }
+    if (value && typeof value === 'object' && typeof value.get === 'function') {
+        return value.get();
+    }
+    if (typeof value === 'function') {
+        return value();
+    }
+    return value;
+}
+function _rcb(binding, componentBindings) {
+    const instanceBindings = componentBindings[binding.component_instance];
+    if (!instanceBindings || !OWN.call(instanceBindings, binding.component_binding)) {
+        return undefined;
+    }
+    return instanceBindings[binding.component_binding];
+}
+function _rcr(literal, params, ssrData, props) {
+    if (literal === 'data' || literal === 'ssr')
+        return ssrData;
+    if (literal === 'params')
+        return params;
+    if (literal === 'props')
+        return props;
+    return UNRESOLVED_LITERAL;
+}
+function _tenl(literal, markerIndex, mode, source) {
+    throwZenithRuntimeError({
+        phase: 'bind',
+        code: 'EXPRESSION_NOT_LOWERED',
+        message: `Expression literal was not lowered by the compiler: ${_truncateLiteralForError(literal)}`,
+        marker: {
+            type: _markerTypeForError(mode),
+            id: markerIndex
+        },
+        path: `expression[${markerIndex}]`,
+        hint: 'Lower expression to fn_index/signal_index/state_index.',
+        docsLink: DOCS_LINKS.expressionScope,
+        source
+    });
+}
+function _tuma(literal, markerIndex, member, source) {
+    throwZenithRuntimeError({
+        phase: 'bind',
+        code: 'UNSAFE_MEMBER_ACCESS',
+        message: `Blocked unsafe member access: ${member} in path "${literal}"`,
+        path: `marker[${markerIndex}].expression.${literal}`,
+        hint: 'Property access to __proto__/prototype/constructor is forbidden.',
+        docsLink: DOCS_LINKS.expressionScope,
+        source
+    });
+}

package/dist/hydrate.js

@@ -10,7 +10,7 @@ import { createNodeResolver } from './scanner.js';
 import { bindEventMarkers } from './events.js';
 import { _applyMarkerValue } from './render.js';
 export { _createContextualFragment, _coerceText } from './render.js';
-// Raw HTML boundary enforcement lives in render.js:
+// Raw HTML boundary lock lives in render.js:
 // attrName.toLowerCase() === 'innerhtml'
 // innerHTML bindings are forbidden in Zenith
 // attrName.toLowerCase() === 'unsafehtml'
@@ -19,7 +19,7 @@ export function hydrate(payload) {
     try {
         const normalized = _validatePayload(payload);
         _deepFreezePayload(payload);
-        const { root, expressions, markers, events, refs, stateValues, stateKeys, signals, components, route, params, ssrData, props, exprFns } = normalized;
+        const { root, expressions, markers, events, refs, stateValues, stateKeys, signals, components, params, ssrData, props, exprFns } = normalized;
         const componentBindings = Object.create(null);
         const resolveNodes = createNodeResolver(root);
         const signalMap = _createSignalMap(signals, stateValues);
@@ -28,12 +28,10 @@ export function hydrate(payload) {
             components,
             signalMap,
             componentBindings,
-            route,
             resolveNodes
         });
-        const markerState = _hydrateMarkers({
+        const runtimeContext = {
             expressions,
-            markers,
             stateValues,
             stateKeys,
             signalMap,
@@ -43,22 +41,16 @@ export function hydrate(payload) {
             props,
             exprFns,
             resolveNodes
+        };
+        const markerState = _hydrateMarkers({
+            ...runtimeContext,
+            markers
         });
-        const renderMarkerByIndex = (index) => _renderMarker({
-            index,
-            root,
-            expressions,
-            stateValues,
-            stateKeys,
-            signalMap,
-            componentBindings,
-            params,
-            ssrData,
-            props,
-            exprFns,
-            resolveNodes,
+        const renderContext = {
+            ...runtimeContext,
             ...markerState
-        });
+        };
+        const renderMarkerByIndex = (index) => _renderMarker(renderContext, index);
         _bindSignalSubscriptions(expressions, signalMap, stateValues, renderMarkerByIndex);
         _bindComponentSignalSubscriptions(expressions, componentBindings, renderMarkerByIndex);
         bindEventMarkers({
@@ -82,7 +74,7 @@ export function hydrate(payload) {
         rethrowZenithRuntimeError(error, {
             phase: 'hydrate',
             code: 'BINDING_APPLY_FAILED',
-            hint: 'Inspect marker tables, expression bindings, and the runtime overlay diagnostics.',
+            hint: 'Inspect marker tables, expression bindings, and runtime diagnostics.',
             docsLink: DOCS_LINKS.markerTable
         });
     }
@@ -121,13 +113,10 @@ function _hydrateRefs(refs, stateValues, resolveNodes) {
     });
 }
 function _mountComponents(context) {
-    const { components, signalMap, componentBindings, route, resolveNodes } = context;
+    const { components, signalMap, componentBindings, resolveNodes } = context;
     for (let i = 0; i < components.length; i++) {
         const component = components[i];
-        const resolvedProps = Object.freeze(_resolveComponentProps(component.props || [], signalMap, {
-            component: component.instance,
-            route
-        }));
+        const resolvedProps = Object.freeze(_resolveComponentProps(component.props || [], signalMap));
         const hosts = resolveNodes(component.selector, i, 'component', component.source);
         for (let j = 0; j < hosts.length; j++) {
             try {
@@ -176,7 +165,7 @@ function _mountComponents(context) {
                         code: 'COMPONENT_BOOTSTRAP_FAILED',
                         message: `Component bootstrap failed for "${component.instance}"`,
                         path: `component[${component.instance}]`,
-                        hint: 'Fix the failing component and refresh; other components continue mounting.',
+                        hint: 'Fix the failing component and refresh.',
                         docsLink: DOCS_LINKS.componentBootstrap,
                         source: component.source
                     });
@@ -188,49 +177,31 @@ function _mountComponents(context) {
     }
 }
 function _hydrateMarkers(context) {
-    const { expressions, markers, stateValues, stateKeys, signalMap, componentBindings, params, ssrData, props, exprFns, resolveNodes } = context;
+    const { expressions, markers, resolveNodes } = context;
     const markerByIndex = new Map();
     const markerNodesByIndex = new Map();
-    const markerIndices = new Set();
-    const expressionMarkerIndices = new Set();
-    for (let i = 0; i < expressions.length; i++) {
-        const expression = expressions[i];
-        if (expressionMarkerIndices.has(expression.marker_index)) {
-            throw new Error(`[Zenith Runtime] duplicate expression marker_index ${expression.marker_index}`);
-        }
-        expressionMarkerIndices.add(expression.marker_index);
-    }
     for (let i = 0; i < markers.length; i++) {
         const marker = markers[i];
-        if (markerIndices.has(marker.index)) {
-            throw new Error(`[Zenith Runtime] duplicate marker index ${marker.index}`);
-        }
-        markerIndices.add(marker.index);
         markerByIndex.set(marker.index, marker);
         if (marker.kind === 'event') {
             continue;
         }
         const nodes = resolveNodes(marker.selector, marker.index, marker.kind, marker.source);
         markerNodesByIndex.set(marker.index, nodes);
-        const value = _evaluateExpression(expressions[marker.index], stateValues, stateKeys, signalMap, componentBindings, params, ssrData, marker.kind, props, exprFns, marker, null);
+        const value = _evaluateMarkerBinding(context, expressions[marker.index], marker);
         _applyMarkerValue(nodes, marker, value);
     }
-    for (let i = 0; i < expressions.length; i++) {
-        if (!markerIndices.has(i)) {
-            throw new Error(`[Zenith Runtime] missing marker index ${i}`);
-        }
-    }
     return { markerByIndex, markerNodesByIndex };
 }
-function _renderMarker(context) {
-    const marker = context.markerByIndex.get(context.index);
+function _renderMarker(context, index) {
+    const marker = context.markerByIndex.get(index);
     if (!marker || marker.kind === 'event') {
         return;
     }
-    const nodes = context.markerNodesByIndex.get(context.index)
+    const nodes = context.markerNodesByIndex.get(index)
         || context.resolveNodes(marker.selector, marker.index, marker.kind, marker.source);
-    context.markerNodesByIndex.set(context.index, nodes);
-    const value = _evaluateExpression(context.expressions[context.index], context.stateValues, context.stateKeys, context.signalMap, context.componentBindings, context.params, context.ssrData, marker.kind, context.props, context.exprFns, marker, null);
+    context.markerNodesByIndex.set(index, nodes);
+    const value = _evaluateMarkerBinding(context, context.expressions[index], marker);
     _applyMarkerValue(nodes, marker, value);
 }
 function _isSignalLike(candidate) {
@@ -265,16 +236,7 @@ function _bindSignalSubscriptions(expressions, signalMap, stateValues, renderMar
             _recordSignalMarkerDependency(dependentMarkersBySignal, stateValues[expression.state_index], expression.marker_index);
         }
     }
-    for (const [targetSignal, markerIndexes] of dependentMarkersBySignal.entries()) {
-        const unsubscribe = targetSignal.subscribe(() => {
-            for (let i = 0; i < markerIndexes.length; i++) {
-                renderMarkerByIndex(markerIndexes[i]);
-            }
-        });
-        if (typeof unsubscribe === 'function') {
-            _registerDisposer(unsubscribe);
-        }
-    }
+    _subscribeMarkerDependencies(dependentMarkersBySignal, renderMarkerByIndex);
 }
 function _bindComponentSignalSubscriptions(expressions, componentBindings, renderMarkerByIndex) {
     const dependentMarkersByComponentSignal = new Map();
@@ -285,10 +247,7 @@ function _bindComponentSignalSubscriptions(expressions, componentBindings, rende
         }
         const instanceBindings = componentBindings[expression.component_instance];
         const candidate = instanceBindings?.[expression.component_binding];
-        if (!candidate || typeof candidate !== 'object') {
-            continue;
-        }
-        if (typeof candidate.get !== 'function' || typeof candidate.subscribe !== 'function') {
+        if (!_isSignalLike(candidate)) {
             continue;
         }
         if (!dependentMarkersByComponentSignal.has(candidate)) {
@@ -296,8 +255,14 @@ function _bindComponentSignalSubscriptions(expressions, componentBindings, rende
         }
         dependentMarkersByComponentSignal.get(candidate).push(expression.marker_index);
     }
-    for (const [componentSignal, markerIndexes] of dependentMarkersByComponentSignal.entries()) {
-        const unsubscribe = componentSignal.subscribe(() => {
+    _subscribeMarkerDependencies(dependentMarkersByComponentSignal, renderMarkerByIndex);
+}
+function _evaluateMarkerBinding(context, expression, marker) {
+    return _evaluateExpression(expression, context.stateValues, context.stateKeys, context.signalMap, context.componentBindings, context.params, context.ssrData, marker.kind, context.props, context.exprFns, marker, null);
+}
+function _subscribeMarkerDependencies(dependencies, renderMarkerByIndex) {
+    for (const [targetSignal, markerIndexes] of dependencies.entries()) {
+        const unsubscribe = targetSignal.subscribe(() => {
             for (let i = 0; i < markerIndexes.length; i++) {
                 renderMarkerByIndex(markerIndexes[i]);
             }

package/dist/index.d.ts

@@ -2,5 +2,6 @@ export { signal } from "./signal.js";
 export { state } from "./state.js";
 export { hydrate } from "./hydrate.js";
 export { effect, mount, zeneffect, zenEffect, zenMount } from "./zeneffect.js";
+export { zenPresence, presence } from "./presence.js";
 export { window, document, zenWindow, zenDocument } from "./env.js";
 export { zenOn, zenResize, collectRefs } from "./platform.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export { signal } from './signal.js';
 export { state } from './state.js';
 export { effect, mount, zeneffect, zenEffect, zenMount } from './zeneffect.js';
+export { zenPresence, presence } from './presence.js';
 export { hydrate } from './hydrate.js';
 export { window, document, zenWindow, zenDocument } from './env.js';
 export { zenOn, zenResize, collectRefs } from './platform.js';

package/dist/markup.js

@@ -30,7 +30,7 @@ export function _fragment(strings, ...values) {
             phase: 'render',
             code: 'NON_RENDERABLE_VALUE',
             message: '__zenith_fragment must be called as a tagged template literal',
-            hint: 'This helper only accepts tagged template syntax.'
+            hint: 'This helper only accepts tagged templates.'
         });
     }
     let result = '';
@@ -46,7 +46,7 @@ export function _fragment(strings, ...values) {
             phase: 'render',
             code: 'NON_RENDERABLE_VALUE',
             message: 'Embedded markup expression contains forbidden <script> tag',
-            hint: 'Script tags are not allowed in embedded markup expressions.'
+            hint: 'Script tags are not allowed in embedded markup.'
         });
     }
     if (_FRAGMENT_EVENT_ATTR_RE.test(result)) {
@@ -54,7 +54,7 @@ export function _fragment(strings, ...values) {
             phase: 'render',
             code: 'NON_RENDERABLE_VALUE',
             message: 'Embedded markup expression contains inline event handler (on*=)',
-            hint: 'Use on:event={handler} bindings instead of inline event attributes.'
+            hint: 'Use on:event={handler} instead of inline event attributes.'
         });
     }
     if (_FRAGMENT_JS_URL_RE.test(result)) {
@@ -62,7 +62,7 @@ export function _fragment(strings, ...values) {
             phase: 'render',
             code: 'NON_RENDERABLE_VALUE',
             message: 'Embedded markup expression contains javascript: URL',
-            hint: 'javascript: URLs are forbidden in embedded markup.'
+            hint: 'javascript: URLs are forbidden.'
         });
     }
     result = result.replace(_FRAGMENT_SCRIPT_CLOSE_RE, '<\\/script');
@@ -99,7 +99,7 @@ function _fragmentInterpolate(val, interpolationIndex) {
                     phase: 'render',
                     code: 'NON_RENDERABLE_VALUE',
                     message: `Embedded markup interpolation[${interpolationIndex}] contains forbidden key "${keys[k]}"`,
-                    hint: 'Prototype pollution keys are forbidden in embedded markup expressions.'
+                    hint: 'Prototype pollution keys are forbidden in embedded markup.'
                 });
             }
         }
@@ -107,14 +107,14 @@ function _fragmentInterpolate(val, interpolationIndex) {
             phase: 'render',
             code: 'NON_RENDERABLE_VALUE',
             message: `Embedded markup interpolation[${interpolationIndex}] resolved to a non-renderable object`,
-            hint: 'Only strings, numbers, booleans, null, undefined, arrays, and compiler-owned fragments are allowed.'
+            hint: 'Only primitives, arrays, and compiler-owned fragments are allowed.'
         });
     }
     throwZenithRuntimeError({
         phase: 'render',
         code: 'NON_RENDERABLE_VALUE',
         message: `Embedded markup interpolation[${interpolationIndex}] resolved to type "${typeof val}"`,
-        hint: 'Only strings, numbers, booleans, null, undefined, arrays, and compiler-owned fragments are allowed.'
+        hint: 'Only primitives, arrays, and compiler-owned fragments are allowed.'
     });
 }
 function _escapeFragmentHtml(input) {

package/dist/payload.d.ts

@@ -1,20 +1,19 @@
-export function _validatePayload(payload: any): Readonly<{
+export function _validatePayload(payload: any): {
     root: any;
-    expressions: any[];
-    markers: any[];
-    events: any[];
+    expressions: any;
+    markers: any;
+    events: any;
     refs: any;
-    stateValues: any[];
-    stateKeys: any[];
-    signals: any[];
+    stateValues: any;
+    stateKeys: any;
+    signals: any;
     components: any;
-    route: any;
     params: any;
     ssrData: any;
     props: any;
     exprFns: any;
-}>;
-export function _resolveComponentProps(propTable: any, signalMap: any, context?: {}): any;
+};
+export function _resolveComponentProps(propTable: any, signalMap: any): any;
 export function _deepFreezePayload(obj: any): void;
 export function _isHydrationRefObject(obj: any): boolean;
 export function _isPlainObject(value: any): boolean;