@zenithbuild/runtime 0.7.5 → 0.7.7

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/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;