@zenithbuild/runtime 0.7.5 → 0.7.7

package/dist/diagnostics-production.d.ts

@@ -0,0 +1,11 @@
+export function isZenithRuntimeError(error: any): boolean;
+export function createZenithRuntimeError(details: any, cause: any): Error;
+export function throwZenithRuntimeError(details: any, cause: any): void;
+export function rethrowZenithRuntimeError(error: any, fallback?: {}): void;
+export const DOCS_LINKS: Readonly<{
+    eventBinding: "/docs/documentation/contracts/runtime-contract.md#event-bindings";
+    expressionScope: "/docs/documentation/reference/reactive-binding-model.md#expression-resolution";
+    markerTable: "/docs/documentation/reference/markers.md";
+    componentBootstrap: "/docs/documentation/contracts/runtime-contract.md#component-bootstrap";
+    refs: "/docs/documentation/reference/reactive-binding-model.md#refs-and-mount";
+}>;

package/dist/diagnostics-production.js

@@ -0,0 +1,279 @@
+const MAX_MESSAGE_LENGTH = 120;
+const MAX_HINT_LENGTH = 140;
+const MAX_PATH_LENGTH = 120;
+const MAX_DOCS_LINK_LENGTH = 180;
+const MAX_SNIPPET_LENGTH = 220;
+const MAX_STACK_LENGTH = 420;
+const VALID_PHASES = Object.freeze(Object.assign(Object.create(null), {
+    hydrate: 1,
+    bind: 1,
+    render: 1,
+    event: 1
+}));
+const VALID_CODES = Object.freeze(Object.assign(Object.create(null), {
+    UNRESOLVED_EXPRESSION: 1,
+    NON_RENDERABLE_VALUE: 1,
+    MARKER_MISSING: 1,
+    FRAGMENT_MOUNT_FAILED: 1,
+    BINDING_APPLY_FAILED: 1,
+    EVENT_HANDLER_FAILED: 1,
+    COMPONENT_BOOTSTRAP_FAILED: 1,
+    UNSAFE_MEMBER_ACCESS: 1
+}));
+const DOCS_EXPRESSION_SCOPE = '/docs/documentation/reference/reactive-binding-model.md#expression-resolution';
+const DOCS_RENDERABLE_VALUES = '/docs/documentation/reference/reactive-binding-model.md#renderable-values';
+const DOCS_MARKERS = '/docs/documentation/reference/markers.md';
+const DOCS_FRAGMENT_CONTRACT = '/docs/documentation/contracts/runtime-contract.md#fragment-contract';
+const DOCS_BINDING_APPLICATION = '/docs/documentation/contracts/runtime-contract.md#binding-application';
+const DOCS_EVENT_BINDINGS = '/docs/documentation/contracts/runtime-contract.md#event-bindings';
+const DOCS_COMPONENT_BOOTSTRAP = '/docs/documentation/contracts/runtime-contract.md#component-bootstrap';
+const DOCS_LINK_BY_CODE = Object.freeze({
+    UNRESOLVED_EXPRESSION: DOCS_EXPRESSION_SCOPE,
+    NON_RENDERABLE_VALUE: DOCS_RENDERABLE_VALUES,
+    MARKER_MISSING: DOCS_MARKERS,
+    FRAGMENT_MOUNT_FAILED: DOCS_FRAGMENT_CONTRACT,
+    BINDING_APPLY_FAILED: DOCS_BINDING_APPLICATION,
+    EVENT_HANDLER_FAILED: DOCS_EVENT_BINDINGS,
+    COMPONENT_BOOTSTRAP_FAILED: DOCS_COMPONENT_BOOTSTRAP,
+    UNSAFE_MEMBER_ACCESS: DOCS_EXPRESSION_SCOPE
+});
+const ABSOLUTE_PATH_RE = /(?:[A-Za-z]:\\[^\s"'`]+|\/(?:Users|home|private|tmp|var\/folders)\/[^\s"'`]+)/g;
+function _truncate(input, maxLength) {
+    const text = String(input ?? '');
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, maxLength - 3)}...`;
+}
+function _sanitizeAbsolutePaths(value) {
+    return String(value ?? '').replace(ABSOLUTE_PATH_RE, '<path>');
+}
+function _compact(value, sanitizePaths = true) {
+    const text = sanitizePaths ? _sanitizeAbsolutePaths(value) : String(value ?? '');
+    return text.replace(/\s+/g, ' ').trim();
+}
+function _sanitizeOptionalText(value, maxLength, sanitizePaths = true) {
+    if (value === null || value === undefined || value === false) {
+        return undefined;
+    }
+    const compact = _compact(value, sanitizePaths);
+    if (!compact)
+        return undefined;
+    return _truncate(compact, maxLength);
+}
+function _sanitizeMessage(value) {
+    return _sanitizeOptionalText(value, MAX_MESSAGE_LENGTH) || 'Runtime failure';
+}
+const _sanitizeHint = (value) => _sanitizeOptionalText(value, MAX_HINT_LENGTH);
+const _sanitizePath = (value) => _sanitizeOptionalText(value, MAX_PATH_LENGTH);
+const _sanitizeDocsLink = (value) => _sanitizeOptionalText(value, MAX_DOCS_LINK_LENGTH, false);
+function _sanitizeSourceLocation(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const line = Number(value.line);
+    const column = Number(value.column);
+    if (!Number.isInteger(line) || !Number.isInteger(column)) {
+        return undefined;
+    }
+    if (line < 1 || column < 1) {
+        return undefined;
+    }
+    return { line, column };
+}
+function _sanitizeSource(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const file = typeof value.file === 'string' ? _truncate(value.file.trim(), 240) : '';
+    if (!file) {
+        return undefined;
+    }
+    const start = _sanitizeSourceLocation(value.start);
+    const end = _sanitizeSourceLocation(value.end);
+    const snippet = typeof value.snippet === 'string'
+        ? _truncate(_compact(value.snippet, false), MAX_SNIPPET_LENGTH)
+        : undefined;
+    return {
+        file,
+        ...(start ? { start } : null),
+        ...(end ? { end } : null),
+        ...(snippet ? { snippet } : null)
+    };
+}
+function _normalizeMarker(marker) {
+    if (!marker || typeof marker !== 'object')
+        return undefined;
+    const markerType = _truncate(_compact(marker.type || 'data-zx'), 48);
+    const markerId = marker.id;
+    if (markerId === null || markerId === undefined || markerId === '')
+        return undefined;
+    if (typeof markerId === 'number') {
+        return { type: markerType, id: markerId };
+    }
+    return { type: markerType, id: _truncate(_sanitizeAbsolutePaths(markerId), 48) };
+}
+function _extractErrorMessage(error) {
+    if (!error)
+        return '';
+    if (typeof error === 'string')
+        return error;
+    if (error instanceof Error && typeof error.message === 'string')
+        return error.message;
+    if (typeof error.message === 'string')
+        return error.message;
+    return String(error);
+}
+function _readProcessEnv(name) {
+    const runtimeProcess = typeof process !== 'undefined' ? process : globalThis?.process;
+    const value = runtimeProcess?.env?.[name];
+    return typeof value === 'string' ? value : undefined;
+}
+function _shouldLogRuntimeError() {
+    if (_readProcessEnv('ZENITH_LOG_RUNTIME_ERRORS') === '1') {
+        return true;
+    }
+    const isTestMode = _readProcessEnv('NODE_ENV') === 'test'
+        || _readProcessEnv('ZENITH_TEST_MODE') === '1';
+    return !isTestMode;
+}
+const _renderOverlay = () => { };
+function _mapLegacyError(error, fallback) {
+    const rawMessage = _extractErrorMessage(error);
+    const safeMessage = _sanitizeMessage(rawMessage);
+    const details = {
+        phase: VALID_PHASES[fallback.phase] ? fallback.phase : 'hydrate',
+        code: VALID_CODES[fallback.code] ? fallback.code : 'BINDING_APPLY_FAILED',
+        message: _sanitizeMessage(fallback.message || safeMessage),
+        marker: _normalizeMarker(fallback.marker),
+        path: _sanitizePath(fallback.path),
+        hint: _sanitizeHint(fallback.hint),
+        source: _sanitizeSource(fallback.source),
+        docsLink: _sanitizeDocsLink(fallback.docsLink)
+    };
+    if (/failed to resolve expression literal/i.test(rawMessage)) {
+        details.phase = 'bind';
+        details.code = 'UNRESOLVED_EXPRESSION';
+        details.hint = details.hint || 'Verify expression scope keys and signal aliases.';
+    }
+    else if (/non-renderable (object|function)/i.test(rawMessage)) {
+        details.phase = 'render';
+        details.code = 'NON_RENDERABLE_VALUE';
+        const match = rawMessage.match(/at\s+([A-Za-z0-9_\[\].-]+)/);
+        if (match && !details.path) {
+            details.path = _sanitizePath(match[1]);
+        }
+        details.hint = details.hint || 'Use map() to render object fields into nodes.';
+    }
+    else if (/unresolved .* marker index/i.test(rawMessage)) {
+        details.phase = 'bind';
+        details.code = 'MARKER_MISSING';
+        const markerMatch = rawMessage.match(/unresolved\s+(\w+)\s+marker index\s+(\d+)/i);
+        if (markerMatch && !details.marker) {
+            details.marker = {
+                type: `data-zx-${markerMatch[1]}`,
+                id: Number(markerMatch[2])
+            };
+        }
+        details.hint = details.hint || 'Confirm SSR markers and client selector tables match.';
+    }
+    if (!details.docsLink) {
+        details.docsLink = DOCS_LINK_BY_CODE[details.code];
+    }
+    return details;
+}
+export function isZenithRuntimeError(error) {
+    return !!(error &&
+        typeof error === 'object' &&
+        error.zenithRuntimeError &&
+        error.zenithRuntimeError.kind === 'ZENITH_RUNTIME_ERROR');
+}
+export function createZenithRuntimeError(details, cause) {
+    const phase = VALID_PHASES[details?.phase] ? details.phase : 'hydrate';
+    const code = VALID_CODES[details?.code] ? details.code : 'BINDING_APPLY_FAILED';
+    const message = _sanitizeMessage(details?.message || 'Runtime failure');
+    const docsLink = _sanitizeDocsLink(details?.docsLink || DOCS_LINK_BY_CODE[code]);
+    const payload = {
+        kind: 'ZENITH_RUNTIME_ERROR',
+        phase,
+        code,
+        message,
+        ...(docsLink ? { docsLink } : null)
+    };
+    const marker = _normalizeMarker(details?.marker);
+    if (marker)
+        payload.marker = marker;
+    const path = _sanitizePath(details?.path);
+    if (path)
+        payload.path = path;
+    const hint = _sanitizeHint(details?.hint);
+    if (hint)
+        payload.hint = hint;
+    const source = _sanitizeSource(details?.source);
+    if (source)
+        payload.source = source;
+    const stack = _sanitizeHint(details?.stack);
+    if (stack) {
+        payload.stack = _truncate(stack, MAX_STACK_LENGTH);
+    }
+    const error = new Error(`[Zenith Runtime] ${code}: ${message}`);
+    error.name = 'ZenithRuntimeError';
+    error.zenithRuntimeError = payload;
+    if (cause !== undefined) {
+        error.cause = cause;
+    }
+    error.toJSON = () => payload;
+    return error;
+}
+function _reportRuntimeError(error) {
+    if (!error || error.__zenithRuntimeErrorReported === true)
+        return;
+    error.__zenithRuntimeErrorReported = true;
+    const payload = error.zenithRuntimeError;
+    if (payload
+        && _shouldLogRuntimeError()
+        && typeof console !== 'undefined'
+        && typeof console.error === 'function') {
+        console.error('[Zenith Runtime]', payload);
+    }
+    _renderOverlay(payload);
+}
+export function throwZenithRuntimeError(details, cause) {
+    const error = createZenithRuntimeError(details, cause);
+    _reportRuntimeError(error);
+    throw error;
+}
+export function rethrowZenithRuntimeError(error, fallback = {}) {
+    if (isZenithRuntimeError(error)) {
+        const payload = error.zenithRuntimeError || {};
+        let updatedPayload = payload;
+        const marker = payload.marker || _normalizeMarker(fallback.marker);
+        const path = payload.path || _sanitizePath(fallback.path);
+        const hint = payload.hint || _sanitizeHint(fallback.hint);
+        const source = payload.source || _sanitizeSource(fallback.source);
+        const docsLink = payload.docsLink || _sanitizeDocsLink(fallback.docsLink || DOCS_LINK_BY_CODE[payload.code]);
+        if (marker || path || hint || source || docsLink) {
+            updatedPayload = {
+                ...payload,
+                ...(marker ? { marker } : null),
+                ...(path ? { path } : null),
+                ...(hint ? { hint } : null),
+                ...(source ? { source } : null),
+                ...(docsLink ? { docsLink } : null)
+            };
+            error.zenithRuntimeError = updatedPayload;
+            error.toJSON = () => updatedPayload;
+        }
+        _reportRuntimeError(error);
+        throw error;
+    }
+    const mapped = _mapLegacyError(error, fallback || {});
+    const wrapped = createZenithRuntimeError(mapped, error);
+    _reportRuntimeError(wrapped);
+    throw wrapped;
+}
+export const DOCS_LINKS = Object.freeze({
+    eventBinding: DOCS_EVENT_BINDINGS,
+    expressionScope: DOCS_EXPRESSION_SCOPE,
+    markerTable: DOCS_MARKERS,
+    componentBootstrap: DOCS_COMPONENT_BOOTSTRAP,
+    refs: '/docs/documentation/reference/reactive-binding-model.md#refs-and-mount'
+});

package/dist/events.js

@@ -40,7 +40,7 @@ function _resolveEventHandler(context, expressionBinding, marker, eventBinding)
         message: `Event binding at index ${eventBinding.index} expected a function reference. You passed: ${_describeBindingExpression(expressionBinding)}`,
         marker: { type: `data-zx-on-${eventBinding.event}`, id: eventBinding.index },
         path: `event[${eventBinding.index}].${eventBinding.event}`,
-        hint: 'Use on:*={handler} or ensure the forwarded prop is a function.',
+        hint: 'Use on:*={handler}; forwarded props must be functions.',
         docsLink: DOCS_LINKS.eventBinding,
         source: _resolveBindingSource(expressionBinding, marker, eventBinding)
     });
@@ -57,7 +57,7 @@ function _createWrappedEventHandler(handler, expressionBinding, marker, eventBin
                 message: `Event handler failed for "${eventBinding.event}"`,
                 marker: { type: `data-zx-on-${eventBinding.event}`, id: eventBinding.index },
                 path: `event[${eventBinding.index}].${eventBinding.event}`,
-                hint: 'Inspect the handler body and referenced state.',
+                hint: 'Inspect handler body and referenced state.',
                 docsLink: DOCS_LINKS.eventBinding,
                 source: _resolveBindingSource(expressionBinding, marker, eventBinding)
             });

package/dist/expressions.d.ts

@@ -3,7 +3,6 @@ export function _evaluateExpression(binding: any, stateValues: any, stateKeys: a
 export function _throwUnresolvedMemberChainError(literal: any, markerIndex: any, mode: any, pathSuffix: any, hint: any, source: any): void;
 export function _resolveStrictMemberChainLiteral(literal: any, stateValues: any, stateKeys: any, params: any, ssrData: any, mode: any, props: any, markerIndex: any, source: any): any;
 export function _resolvePrimitiveLiteral(literal: any): any;
-export function _buildLiteralScope(stateValues: any, stateKeys: any, params: any, ssrData: any, mode: any, props: any): any;
 export function _resolveBindingSource(binding: any, markerBinding: any, eventBinding: any): any;
 export function _describeBindingExpression(binding: any): string;
 export function _markerTypeForError(kind: any): any;

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
+    });
+}