@zenithbuild/runtime 0.7.2 → 0.7.4

package/dist/events.js

@@ -1,57 +1,119 @@
-// ---------------------------------------------------------------------------
-// events.js — Zenith Runtime V0
-// ---------------------------------------------------------------------------
-// Event binding system.
-//
-// For: <button data-zx-on-click="1">
-//
-// Algorithm:
-//   1. Extract event name from attribute suffix ("click")
-//   2. Resolve expression at index → must be a function
-//   3. addEventListener directly
-//
-// No synthetic events.
-// No delegation.
-// No wrapping.
-// ---------------------------------------------------------------------------
 import { _registerListener } from './cleanup.js';
-import { rethrowZenithRuntimeError, throwZenithRuntimeError } from './diagnostics.js';
-/**
- * Bind an event listener to a DOM element.
- *
- * @param {Element} element - The DOM element
- * @param {string} eventName - The event name (e.g. "click")
- * @param {() => any} exprFn - Pre-bound expression function that must resolve to a handler
- */
-export function bindEvent(element, eventName, exprFn) {
-    const resolved = exprFn();
-    if (typeof resolved !== 'function') {
-        throwZenithRuntimeError({
-            phase: 'bind',
-            code: 'BINDING_APPLY_FAILED',
-            message: `Event binding expected a function reference for "${eventName}"`,
-            marker: { type: `data-zx-on-${eventName}`, id: '<unknown>' },
-            path: `event:${eventName}`,
-            hint: 'Use on:*={handler} and ensure forwarded props are function-valued.',
-            docsLink: '/docs/documentation/contracts/runtime-contract.md#event-bindings'
-        });
-    }
-    const wrapped = function zenithBoundEvent(event) {
+import { rethrowZenithRuntimeError, throwZenithRuntimeError, DOCS_LINKS } from './diagnostics.js';
+import { _evaluateExpression, _describeBindingExpression, _resolveBindingSource } from './expressions.js';
+export function bindEventMarkers(context) {
+    const { root, events } = context;
+    const eventIndices = new Set();
+    const escDispatchEntries = [];
+    for (let i = 0; i < events.length; i++) {
+        const eventBinding = events[i];
+        if (eventIndices.has(eventBinding.index)) {
+            throw new Error(`[Zenith Runtime] duplicate event index ${eventBinding.index}`);
+        }
+        eventIndices.add(eventBinding.index);
+        const marker = context.markerByIndex.get(eventBinding.index) || null;
+        const nodes = context.resolveNodes(eventBinding.selector, eventBinding.index, 'event', eventBinding.source || marker?.source);
+        const expressionBinding = context.expressions[eventBinding.index];
+        const handler = _resolveEventHandler(context, expressionBinding, marker, eventBinding);
+        for (let j = 0; j < nodes.length; j++) {
+            const node = nodes[j];
+            const wrappedHandler = _createWrappedEventHandler(handler, expressionBinding, marker, eventBinding);
+            if (eventBinding.event === 'esc') {
+                escDispatchEntries.push({ node, handler: wrappedHandler });
+                continue;
+            }
+            _bindDomEvent(node, eventBinding.event, wrappedHandler);
+        }
+    }
+    if (escDispatchEntries.length > 0) {
+        _registerEscDispatch(root, escDispatchEntries);
+    }
+}
+function _resolveEventHandler(context, expressionBinding, marker, eventBinding) {
+    const handler = _evaluateExpression(expressionBinding, context.stateValues, context.stateKeys, context.signalMap, context.componentBindings, context.params, context.ssrData, 'event', context.props, context.exprFns, marker, eventBinding);
+    if (typeof handler === 'function') {
+        return handler;
+    }
+    throwZenithRuntimeError({
+        phase: 'bind',
+        code: 'BINDING_APPLY_FAILED',
+        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.',
+        docsLink: DOCS_LINKS.eventBinding,
+        source: _resolveBindingSource(expressionBinding, marker, eventBinding)
+    });
+}
+function _createWrappedEventHandler(handler, expressionBinding, marker, eventBinding) {
+    return function zenithEventHandler(event) {
         try {
-            return resolved.call(this, event);
+            return handler.call(this, event);
         }
         catch (error) {
             rethrowZenithRuntimeError(error, {
                 phase: 'event',
                 code: 'EVENT_HANDLER_FAILED',
-                message: `Event handler failed for "${eventName}"`,
-                marker: { type: `data-zx-on-${eventName}`, id: '<unknown>' },
-                path: `event:${eventName}:${resolved.name || '<anonymous>'}`,
-                hint: 'Inspect handler logic and referenced state.',
-                docsLink: '/docs/documentation/contracts/runtime-contract.md#event-bindings'
+                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.',
+                docsLink: DOCS_LINKS.eventBinding,
+                source: _resolveBindingSource(expressionBinding, marker, eventBinding)
             });
         }
     };
-    element.addEventListener(eventName, wrapped);
-    _registerListener(element, eventName, wrapped);
+}
+function _registerEscDispatch(root, escDispatchEntries) {
+    const doc = _resolveOwnerDocument(root);
+    if (!doc || typeof doc.addEventListener !== 'function') {
+        return;
+    }
+    const escDispatchListener = function zenithEscDispatch(event) {
+        if (!event || event.key !== 'Escape') {
+            return;
+        }
+        const targetEntry = _resolveEscTarget(doc, escDispatchEntries);
+        if (!targetEntry) {
+            return;
+        }
+        return targetEntry.handler.call(targetEntry.node, event);
+    };
+    _bindDomEvent(doc, 'keydown', escDispatchListener);
+}
+function _resolveEscTarget(doc, escDispatchEntries) {
+    const activeElement = doc.activeElement || null;
+    if (activeElement && activeElement !== doc.body && activeElement !== doc.documentElement) {
+        for (let i = escDispatchEntries.length - 1; i >= 0; i--) {
+            const entry = escDispatchEntries[i];
+            if (!entry?.node || !entry.node.isConnected) {
+                continue;
+            }
+            if (typeof entry.node.contains === 'function' && entry.node.contains(activeElement)) {
+                return entry;
+            }
+        }
+    }
+    if (activeElement === null || activeElement === doc.body || activeElement === doc.documentElement) {
+        for (let i = escDispatchEntries.length - 1; i >= 0; i--) {
+            const entry = escDispatchEntries[i];
+            if (entry?.node?.isConnected) {
+                return entry;
+            }
+        }
+    }
+    return null;
+}
+function _bindDomEvent(target, eventName, handler) {
+    target.addEventListener(eventName, handler);
+    _registerListener(target, eventName, handler);
+}
+function _resolveOwnerDocument(root) {
+    if (root?.ownerDocument) {
+        return root.ownerDocument;
+    }
+    if (root?.nodeType === 9) {
+        return root;
+    }
+    return typeof document !== 'undefined' ? document : null;
 }

package/dist/expressions.d.ts

@@ -0,0 +1,14 @@
+export function _resolveExpressionSignalIndices(binding: any): any[];
+export function _evaluateExpression(binding: any, stateValues: any, stateKeys: any, signalMap: any, componentBindings: any, params: any, ssrData: any, mode: any, props: any, exprFns: any, markerBinding?: null, eventBinding?: null): any;
+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;
+export function _truncateLiteralForError(str: any): string;
+export const UNRESOLVED_LITERAL: unique symbol;
+export const STRICT_MEMBER_CHAIN_LITERAL_RE: RegExp;
+export const CANONICAL_MEMBER_CHAIN_BASES: Set<string>;
+export const UNSAFE_MEMBER_KEYS: Set<string>;

package/dist/expressions.js

@@ -0,0 +1,295 @@
+import { throwZenithRuntimeError, DOCS_LINKS } from './diagnostics.js';
+import { _fragment } from './markup.js';
+export const UNRESOLVED_LITERAL = Symbol('unresolved_literal');
+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']);
+export function _resolveExpressionSignalIndices(binding) {
+    if (!binding || typeof binding !== 'object') {
+        return [];
+    }
+    if (Array.isArray(binding.signal_indices) && binding.signal_indices.length > 0) {
+        return [...new Set(binding.signal_indices.filter((value) => Number.isInteger(value) && value >= 0))];
+    }
+    if (Number.isInteger(binding.signal_index) && binding.signal_index >= 0) {
+        return [binding.signal_index];
+    }
+    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];
+        if (typeof fn === 'function') {
+            try {
+                return fn({
+                    signalMap,
+                    params,
+                    ssrData,
+                    props: props || {},
+                    componentBindings,
+                    fragment: _fragment
+                });
+            }
+            catch (fnErr) {
+                throw fnErr;
+            }
+        }
+    }
+    if (binding.signal_index !== null && binding.signal_index !== undefined) {
+        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();
+    }
+    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 (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;
+    }
+    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)
+            });
+        }
+        return binding.literal;
+    }
+    return '';
+}
+export function _throwUnresolvedMemberChainError(literal, markerIndex, mode, pathSuffix, hint, source) {
+    throwZenithRuntimeError({
+        phase: 'bind',
+        code: 'UNRESOLVED_EXPRESSION',
+        message: `Failed to resolve expression literal: ${_truncateLiteralForError(literal)}`,
+        marker: {
+            type: _markerTypeForError(mode),
+            id: markerIndex
+        },
+        path: `marker[${markerIndex}].${pathSuffix}`,
+        hint,
+        docsLink: DOCS_LINKS.expressionScope,
+        source
+    });
+}
+export function _resolveStrictMemberChainLiteral(literal, stateValues, stateKeys, params, ssrData, mode, props, markerIndex, source) {
+    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
+        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];
+    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
+            });
+        }
+        if (cursor === null || cursor === undefined) {
+            _throwUnresolvedMemberChainError(literal, markerIndex, mode, `expression.${traversedPath}.${segment}`, `Cannot read "${segment}" from ${traversedPath} because it is null or undefined.`, source);
+        }
+        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);
+        }
+        if (!Object.prototype.hasOwnProperty.call(cursor, segment)) {
+            _throwUnresolvedMemberChainError(literal, markerIndex, mode, `expression.${traversedPath}.${segment}`, `Missing member "${segment}" on ${traversedPath}. Check your bindings.`, source);
+        }
+        cursor = cursor[segment];
+        traversedPath = `${traversedPath}.${segment}`;
+    }
+    return cursor;
+}
+export function _resolvePrimitiveLiteral(literal) {
+    if (typeof literal !== 'string') {
+        return UNRESOLVED_LITERAL;
+    }
+    if (literal === 'true')
+        return true;
+    if (literal === 'false')
+        return false;
+    if (literal === 'null')
+        return null;
+    if (literal === 'undefined')
+        return undefined;
+    if (/^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?$/.test(literal)) {
+        return Number(literal);
+    }
+    if (literal.length >= 2 && literal.startsWith('"') && literal.endsWith('"')) {
+        try {
+            return JSON.parse(literal);
+        }
+        catch {
+            return UNRESOLVED_LITERAL;
+        }
+    }
+    if (literal.length >= 2 && literal.startsWith('\'') && literal.endsWith('\'')) {
+        return literal
+            .slice(1, -1)
+            .replace(/\\\\/g, '\\')
+            .replace(/\\'/g, '\'');
+    }
+    if (literal.length >= 2 && literal.startsWith('`') && literal.endsWith('`')) {
+        return literal.slice(1, -1);
+    }
+    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;
+        }
+    }
+    return undefined;
+}
+export function _describeBindingExpression(binding) {
+    if (!binding || typeof binding !== 'object') {
+        return '<unknown>';
+    }
+    if (typeof binding.literal === 'string' && binding.literal.trim().length > 0) {
+        return _truncateLiteralForError(binding.literal.trim());
+    }
+    if (Number.isInteger(binding.state_index)) {
+        return `state[${binding.state_index}]`;
+    }
+    if (Number.isInteger(binding.signal_index)) {
+        return `signal[${binding.signal_index}]`;
+    }
+    if (typeof binding.component_instance === 'string' && typeof binding.component_binding === 'string') {
+        return `${binding.component_instance}.${binding.component_binding}`;
+    }
+    return '<unknown expression>';
+}
+export function _markerTypeForError(kind) {
+    if (kind === 'text')
+        return 'data-zx-e';
+    if (kind === 'attr')
+        return 'data-zx-attr';
+    if (kind === 'event')
+        return 'data-zx-on';
+    return kind;
+}
+export function _truncateLiteralForError(str) {
+    if (typeof str !== 'string')
+        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>');
+    return sanitized.length > 100 ? `${sanitized.substring(0, 97)}...` : sanitized;
+}

package/dist/fragment-patch.d.ts

@@ -0,0 +1,12 @@
+export function createFragmentRegion(): {
+    mount(items: any, ctx: any): void;
+    update(newItemsRaw: any, ctx: any): void;
+    destroy(): void;
+};
+export function unmountRegion(region: any): void;
+export function mountItemIntoRegion(item: any, ctx: any): {
+    nodes: never[];
+    unmounts: never[];
+};
+export const coerceText: typeof _coerceText;
+import { _coerceText } from './render.js';

package/dist/fragment-patch.js

@@ -0,0 +1,118 @@
+import { _createContextualFragment, _coerceText } from './render.js';
+import { _isHtmlFragment } from './markup.js';
+export function createFragmentRegion() {
+    let oldItems = [];
+    let regions = [];
+    return {
+        mount(items, ctx) {
+            oldItems = _flattenFragment(items);
+            for (let i = 0; i < oldItems.length; i++) {
+                regions.push(mountItemIntoRegion(oldItems[i], ctx));
+            }
+        },
+        update(newItemsRaw, ctx) {
+            const newItems = _flattenFragment(newItemsRaw);
+            for (let i = 0; i < newItems.length; i++) {
+                if (i < oldItems.length) {
+                    if (oldItems[i] === newItems[i]) {
+                        continue;
+                    }
+                    unmountRegion(regions[i]);
+                    let insertBefore = ctx.insertBefore;
+                    for (let j = i + 1; j < regions.length; j++) {
+                        if (regions[j] && regions[j].nodes.length > 0) {
+                            insertBefore = regions[j].nodes[0];
+                            break;
+                        }
+                    }
+                    const patchCtx = { parent: ctx.parent, insertBefore };
+                    regions[i] = mountItemIntoRegion(newItems[i], patchCtx);
+                    oldItems[i] = newItems[i];
+                }
+                else {
+                    regions.push(mountItemIntoRegion(newItems[i], ctx));
+                    oldItems.push(newItems[i]);
+                }
+            }
+            while (oldItems.length > newItems.length) {
+                const idx = oldItems.length - 1;
+                unmountRegion(regions[idx]);
+                regions.pop();
+                oldItems.pop();
+            }
+        },
+        destroy() {
+            for (let i = 0; i < regions.length; i++) {
+                unmountRegion(regions[i]);
+            }
+            regions = [];
+            oldItems = [];
+        }
+    };
+}
+export function unmountRegion(region) {
+    if (!region)
+        return;
+    for (let i = 0; i < region.unmounts.length; i++) {
+        try {
+            region.unmounts[i]();
+        }
+        catch (e) { }
+    }
+    for (let i = 0; i < region.nodes.length; i++) {
+        const node = region.nodes[i];
+        if (node.parentNode) {
+            node.parentNode.removeChild(node);
+        }
+    }
+    region.nodes = [];
+    region.unmounts = [];
+}
+export function mountItemIntoRegion(item, ctx) {
+    const parent = ctx.parent;
+    const insertBefore = ctx.insertBefore || null;
+    const doc = parent.ownerDocument || document;
+    const region = { nodes: [], unmounts: [] };
+    if (item && item.__zenith_fragment === true && typeof item.mount === 'function') {
+        const fragment = doc.createDocumentFragment();
+        item.mount(fragment);
+        const childNodes = Array.from(fragment.childNodes);
+        parent.insertBefore(fragment, insertBefore);
+        region.nodes = childNodes;
+        if (typeof item.unmount === 'function') {
+            region.unmounts.push(item.unmount.bind(item));
+        }
+        return region;
+    }
+    if (_isHtmlFragment(item)) {
+        const fragment = _createContextualFragment(parent, item.html);
+        const childNodes = Array.from(fragment.childNodes);
+        parent.insertBefore(fragment, insertBefore);
+        region.nodes = childNodes;
+        return region;
+    }
+    const text = _coerceText(item, ctx.rootPath || 'renderable');
+    if (text || text === '') {
+        const textNode = doc.createTextNode(text);
+        parent.insertBefore(textNode, insertBefore);
+        region.nodes = [textNode];
+    }
+    return region;
+}
+function _flattenFragment(value) {
+    if (!Array.isArray(value))
+        return [value];
+    const res = [];
+    function walk(item) {
+        if (Array.isArray(item)) {
+            for (let i = 0; i < item.length; i++)
+                walk(item[i]);
+        }
+        else {
+            res.push(item);
+        }
+    }
+    walk(value);
+    return res;
+}
+export const coerceText = _coerceText;