@zenithbuild/runtime 0.7.5 → 0.7.7

package/dist/render.js

@@ -12,20 +12,21 @@ export function _applyMarkerValue(nodes, marker, value) {
         try {
             const node = nodes[i];
             if (marker.kind === 'text') {
+                const textPath = `${markerPath}.text`;
                 if (node && node.nodeType === 8) {
-                    _applyCommentMarkerValue(node, value, `${markerPath}.text`);
+                    _applyCommentMarkerValue(node, value, textPath);
                     continue;
                 }
                 if (_isStructuralFragment(value)) {
-                    _mountStructuralFragment(node, value, `${markerPath}.text`);
+                    _mountStructuralFragment(node, value, textPath);
                     continue;
                 }
-                const html = _renderFragmentValue(value, `${markerPath}.text`);
+                const html = _renderFragmentValue(value, textPath);
                 if (html !== null) {
                     node.innerHTML = html;
                 }
                 else {
-                    node.textContent = _coerceText(value, `${markerPath}.text`);
+                    node.textContent = _coerceText(value, textPath);
                 }
                 continue;
             }
@@ -45,7 +46,7 @@ export function _applyMarkerValue(nodes, marker, value) {
                 path: marker.kind === 'attr'
                     ? `${markerPath}.attr.${marker.attr}`
                     : `${markerPath}.${marker.kind}`,
-                hint: 'Check the binding value type and marker mapping.',
+                hint: 'Check binding value and marker mapping.',
                 docsLink: DOCS_LINKS.markerTable,
                 source: marker.source
             });
@@ -105,16 +106,7 @@ function _ensureCommentPlaceholderEnd(anchor) {
     return end;
 }
 function _clearCommentPlaceholderContent(anchor) {
-    if (anchor.__z_unmounts) {
-        for (let i = 0; i < anchor.__z_unmounts.length; i++) {
-            try {
-                anchor.__z_unmounts[i]();
-            }
-            catch {
-            }
-        }
-    }
-    anchor.__z_unmounts = [];
+    _runUnmounts(anchor);
     const end = _ensureCommentPlaceholderEnd(anchor);
     if (!end) {
         return anchor;
@@ -130,21 +122,7 @@ function _clearCommentPlaceholderContent(anchor) {
     return end;
 }
 function _mountStructuralFragmentIntoCommentRange(anchor, value, rootPath = 'renderable') {
-    let region = anchor.__z_fragment_region;
-    if (region && anchor.__z_fragment_region_active) {
-        try {
-            region.update(value, { parent: anchor.parentNode, insertBefore: anchor.__z_range_end, rootPath });
-        }
-        catch (error) {
-            rethrowZenithRuntimeError(error, {
-                phase: 'render',
-                code: 'FRAGMENT_MOUNT_FAILED',
-                message: 'Fragment update failed',
-                path: rootPath,
-                hint: 'Verify fragment values and nested renderable arrays.',
-                docsLink: DOCS_LINKS.markerTable
-            });
-        }
+    if (_tryUpdateFragmentTarget(anchor, value, anchor.parentNode, anchor.__z_range_end, rootPath)) {
         return;
     }
     const end = _clearCommentPlaceholderContent(anchor);
@@ -152,75 +130,15 @@ function _mountStructuralFragmentIntoCommentRange(anchor, value, rootPath = 'ren
     if (!parent) {
         return;
     }
-    region = createFragmentRegion();
-    anchor.__z_fragment_region = region;
-    anchor.__z_fragment_region_active = true;
-    try {
-        region.mount(value, { parent, insertBefore: end, rootPath });
-    }
-    catch (error) {
-        rethrowZenithRuntimeError(error, {
-            phase: 'render',
-            code: 'FRAGMENT_MOUNT_FAILED',
-            message: 'Fragment mount failed',
-            path: rootPath,
-            hint: 'Verify fragment values and nested renderable arrays.',
-            docsLink: DOCS_LINKS.markerTable
-        });
-    }
-    anchor.__z_unmounts = [() => {
-            anchor.__z_fragment_region_active = false;
-            region.destroy();
-        }];
+    _mountFragmentRegion(anchor, value, parent, end, rootPath);
 }
 function _mountStructuralFragment(container, value, rootPath = 'renderable') {
-    let region = container.__z_fragment_region;
-    if (region && container.__z_fragment_region_active) {
-        try {
-            region.update(value, { parent: container, insertBefore: null, rootPath });
-        }
-        catch (error) {
-            rethrowZenithRuntimeError(error, {
-                phase: 'render',
-                code: 'FRAGMENT_MOUNT_FAILED',
-                message: 'Fragment update failed',
-                path: rootPath,
-                hint: 'Verify fragment values and nested renderable arrays.',
-                docsLink: DOCS_LINKS.markerTable
-            });
-        }
+    if (_tryUpdateFragmentTarget(container, value, container, null, rootPath)) {
         return;
     }
-    if (container.__z_unmounts) {
-        for (let i = 0; i < container.__z_unmounts.length; i++) {
-            try {
-                container.__z_unmounts[i]();
-            }
-            catch {
-            }
-        }
-    }
+    _runUnmounts(container);
     container.innerHTML = '';
-    region = createFragmentRegion();
-    container.__z_fragment_region = region;
-    container.__z_fragment_region_active = true;
-    try {
-        region.mount(value, { parent: container, insertBefore: null, rootPath });
-    }
-    catch (error) {
-        rethrowZenithRuntimeError(error, {
-            phase: 'render',
-            code: 'FRAGMENT_MOUNT_FAILED',
-            message: 'Fragment mount failed',
-            path: rootPath,
-            hint: 'Verify fragment values and nested renderable arrays.',
-            docsLink: DOCS_LINKS.markerTable
-        });
-    }
-    container.__z_unmounts = [() => {
-            container.__z_fragment_region_active = false;
-            region.destroy();
-        }];
+    _mountFragmentRegion(container, value, container, null, rootPath);
 }
 export function _coerceText(value, path = 'renderable') {
     if (value === null || value === undefined || value === false || value === true) {
@@ -232,7 +150,7 @@ export function _coerceText(value, path = 'renderable') {
             code: 'NON_RENDERABLE_VALUE',
             message: `Zenith Render Error: non-renderable function at ${path}. Use map() to render fields.`,
             path,
-            hint: 'Convert functions into explicit event handlers or renderable text.',
+            hint: 'Convert functions to handlers or text.',
             docsLink: DOCS_LINKS.expressionScope
         });
     }
@@ -242,7 +160,7 @@ export function _coerceText(value, path = 'renderable') {
             code: 'NON_RENDERABLE_VALUE',
             message: `Zenith Render Error: non-renderable object at ${path}. Use map() to render fields.`,
             path,
-            hint: 'Use map() to render object fields into nodes.',
+            hint: 'Use map() to render object fields.',
             docsLink: DOCS_LINKS.expressionScope
         });
     }
@@ -279,21 +197,22 @@ function _escapeHtml(input) {
         .replace(/'/g, '&#39;');
 }
 function _applyAttribute(node, attrName, value) {
-    if (typeof attrName === 'string' && attrName.toLowerCase() === 'innerhtml') {
+    const normalizedAttrName = typeof attrName === 'string' ? attrName.toLowerCase() : '';
+    if (normalizedAttrName === 'innerhtml') {
         throwZenithRuntimeError({
             phase: 'bind',
             code: 'UNSAFE_HTML_REQUIRES_EXPLICIT_BOUNDARY',
             message: 'innerHTML bindings are forbidden in Zenith',
             path: `attr:${attrName}`,
-            hint: 'Use unsafeHTML={value} for explicit raw HTML insertion, or embedded markup expressions for compiler-owned fragments.'
+            hint: 'Use unsafeHTML={value} or compiler-owned markup fragments.'
         });
     }
-    if (typeof attrName === 'string' && attrName.toLowerCase() === 'unsafehtml') {
+    if (normalizedAttrName === 'unsafehtml') {
         node.innerHTML = value === null || value === undefined || value === false ? '' : String(value);
         return;
     }
     if (attrName === 'class' || attrName === 'className') {
-        const classValue = value === null || value === undefined || value === false ? '' : String(value);
+        const classValue = _isEmptyAttrValue(value) ? '' : String(value);
         if (node && node.namespaceURI === SVG_NAMESPACE && typeof node.setAttribute === 'function') {
             node.setAttribute('class', classValue);
             return;
@@ -302,25 +221,13 @@ function _applyAttribute(node, attrName, value) {
         return;
     }
     if (attrName === 'style') {
-        if (value === null || value === undefined || value === false) {
+        const styleValue = _resolveStyleAttributeValue(value);
+        if (styleValue === null) {
             node.removeAttribute('style');
-            return;
         }
-        if (typeof value === 'string') {
-            node.setAttribute('style', value);
-            return;
-        }
-        if (typeof value === 'object') {
-            const entries = Object.entries(value);
-            let styleText = '';
-            for (let i = 0; i < entries.length; i++) {
-                const [key, rawValue] = entries[i];
-                styleText += `${key}: ${rawValue};`;
-            }
-            node.setAttribute('style', styleText);
-            return;
+        else {
+            node.setAttribute('style', styleValue);
         }
-        node.setAttribute('style', String(value));
         return;
     }
     if (BOOLEAN_ATTRIBUTES.has(attrName)) {
@@ -332,9 +239,84 @@ function _applyAttribute(node, attrName, value) {
         }
         return;
     }
-    if (value === null || value === undefined || value === false) {
+    if (_isEmptyAttrValue(value)) {
         node.removeAttribute(attrName);
         return;
     }
     node.setAttribute(attrName, String(value));
 }
+function _runUnmounts(target) {
+    if (!target.__z_unmounts) {
+        return;
+    }
+    for (let i = 0; i < target.__z_unmounts.length; i++) {
+        try {
+            target.__z_unmounts[i]();
+        }
+        catch {
+        }
+    }
+    target.__z_unmounts = [];
+}
+function _updateFragmentRegion(region, value, parent, insertBefore, rootPath) {
+    try {
+        region.update(value, { parent, insertBefore, rootPath });
+    }
+    catch (error) {
+        _throwFragmentMountFailure(error, rootPath, 'Fragment update failed');
+    }
+}
+function _mountFragmentRegion(target, value, parent, insertBefore, rootPath) {
+    const region = createFragmentRegion();
+    target.__z_fragment_region = region;
+    target.__z_fragment_region_active = true;
+    try {
+        region.mount(value, { parent, insertBefore, rootPath });
+    }
+    catch (error) {
+        _throwFragmentMountFailure(error, rootPath, 'Fragment mount failed');
+    }
+    target.__z_unmounts = [() => {
+            target.__z_fragment_region_active = false;
+            region.destroy();
+        }];
+}
+function _tryUpdateFragmentTarget(target, value, parent, insertBefore, rootPath) {
+    const region = target.__z_fragment_region;
+    if (!region || !target.__z_fragment_region_active) {
+        return false;
+    }
+    _updateFragmentRegion(region, value, parent, insertBefore, rootPath);
+    return true;
+}
+function _throwFragmentMountFailure(error, path, message) {
+    rethrowZenithRuntimeError(error, {
+        phase: 'render',
+        code: 'FRAGMENT_MOUNT_FAILED',
+        message,
+        path,
+        hint: 'Verify fragment values and nested arrays.',
+        docsLink: DOCS_LINKS.markerTable
+    });
+}
+function _resolveStyleAttributeValue(value) {
+    if (_isEmptyAttrValue(value)) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value);
+        let styleText = '';
+        for (let i = 0; i < entries.length; i++) {
+            const [key, rawValue] = entries[i];
+            styleText += `${key}: ${rawValue};`;
+        }
+        return styleText;
+    }
+    return String(value);
+}
+function _isEmptyAttrValue(value) {
+    return value === null || value === undefined || value === false;
+}

package/dist/runtime-template-profile.d.ts

@@ -0,0 +1,20 @@
+export function normalizeRuntimeTemplateProfile(profile: any): "default" | "production-emitted" | "production-emitted-with-presence";
+export function buildRuntimeTemplateProfile({ profile, normalizeNewlines, readRuntimeSourceFile }: {
+    profile: any;
+    normalizeNewlines: any;
+    readRuntimeSourceFile: any;
+}): {
+    profile: "default" | "production-emitted" | "production-emitted-with-presence";
+    source: any;
+    contributors: {
+        id: string;
+        sourceFile: string;
+        bytes: number;
+    }[];
+    coverageBytes: number;
+};
+export const RUNTIME_TEMPLATE_PROFILES: Readonly<{
+    DEFAULT: "default";
+    PRODUCTION_EMITTED: "production-emitted";
+    PRODUCTION_EMITTED_WITH_PRESENCE: "production-emitted-with-presence";
+}>;

package/dist/runtime-template-profile.js

@@ -0,0 +1,141 @@
+const DEFAULT_RUNTIME_MODULES = Object.freeze([
+    { sourceFile: 'reactivity-core.js', contributorId: 'reactivity-core.js' },
+    { sourceFile: 'side-effect-scope.js', contributorId: 'side-effect-scope.js' },
+    { sourceFile: 'effect-utils.js', contributorId: 'effect-utils.js' },
+    { sourceFile: 'effect-scheduler.js', contributorId: 'effect-scheduler.js' },
+    { sourceFile: 'effect-runtime.js', contributorId: 'effect-runtime.js' },
+    { sourceFile: 'mount-runtime.js', contributorId: 'mount-runtime.js' },
+    { sourceFile: 'zeneffect.js', contributorId: 'zeneffect.js' },
+    { sourceFile: 'ref.js', contributorId: 'ref.js' },
+    { sourceFile: 'env.js', contributorId: 'env.js' },
+    { sourceFile: 'platform.js', contributorId: 'platform.js' },
+    { sourceFile: 'presence.js', contributorId: 'presence.js' },
+    { sourceFile: 'signal.js', contributorId: 'signal.js' },
+    { sourceFile: 'state.js', contributorId: 'state.js' },
+    { sourceFile: 'diagnostics.js', contributorId: 'diagnostics.js' },
+    { sourceFile: 'cleanup.js', contributorId: 'cleanup.js' },
+    { sourceFile: 'template-parser.js', contributorId: 'template-parser.js' },
+    { sourceFile: 'markup.js', contributorId: 'markup.js' },
+    { sourceFile: 'payload.js', contributorId: 'payload.js' },
+    { sourceFile: 'expressions.js', contributorId: 'expressions.js' },
+    { sourceFile: 'render.js', contributorId: 'render.js' },
+    { sourceFile: 'fragment-patch.js', contributorId: 'fragment-patch.js' },
+    { sourceFile: 'scanner.js', contributorId: 'scanner.js' },
+    { sourceFile: 'events.js', contributorId: 'events.js' },
+    { sourceFile: 'hydrate.js', contributorId: 'hydrate.js' }
+]);
+const PRODUCTION_EMITTED_RUNTIME_MODULES = Object.freeze([
+    { sourceFile: 'reactivity-core.js', contributorId: 'reactivity-core.js' },
+    { sourceFile: 'side-effect-scope.js', contributorId: 'side-effect-scope.js' },
+    { sourceFile: 'effect-utils.js', contributorId: 'effect-utils.js' },
+    { sourceFile: 'effect-scheduler.js', contributorId: 'effect-scheduler.js' },
+    { sourceFile: 'effect-runtime.js', contributorId: 'effect-runtime.js' },
+    { sourceFile: 'mount-runtime.js', contributorId: 'mount-runtime.js' },
+    { sourceFile: 'zeneffect.js', contributorId: 'zeneffect.js' },
+    { sourceFile: 'ref.js', contributorId: 'ref.js' },
+    { sourceFile: 'env.js', contributorId: 'env.js' },
+    { sourceFile: 'platform.js', contributorId: 'platform.js' },
+    { sourceFile: 'signal.js', contributorId: 'signal.js' },
+    { sourceFile: 'state.js', contributorId: 'state.js' },
+    { sourceFile: 'diagnostics-production.js', contributorId: 'diagnostics.js' },
+    { sourceFile: 'cleanup.js', contributorId: 'cleanup.js' },
+    { sourceFile: 'template-parser.js', contributorId: 'template-parser.js' },
+    { sourceFile: 'markup.js', contributorId: 'markup.js' },
+    { sourceFile: 'payload.js', contributorId: 'payload.js' },
+    { sourceFile: 'expressions.js', contributorId: 'expressions.js' },
+    { sourceFile: 'render.js', contributorId: 'render.js' },
+    { sourceFile: 'fragment-patch.js', contributorId: 'fragment-patch.js' },
+    { sourceFile: 'scanner.js', contributorId: 'scanner.js' },
+    { sourceFile: 'events.js', contributorId: 'events.js' },
+    { sourceFile: 'hydrate.js', contributorId: 'hydrate.js' }
+]);
+const PRODUCTION_EMITTED_WITH_PRESENCE_RUNTIME_MODULES = Object.freeze([
+    { sourceFile: 'reactivity-core.js', contributorId: 'reactivity-core.js' },
+    { sourceFile: 'side-effect-scope.js', contributorId: 'side-effect-scope.js' },
+    { sourceFile: 'effect-utils.js', contributorId: 'effect-utils.js' },
+    { sourceFile: 'effect-scheduler.js', contributorId: 'effect-scheduler.js' },
+    { sourceFile: 'effect-runtime.js', contributorId: 'effect-runtime.js' },
+    { sourceFile: 'mount-runtime.js', contributorId: 'mount-runtime.js' },
+    { sourceFile: 'zeneffect.js', contributorId: 'zeneffect.js' },
+    { sourceFile: 'ref.js', contributorId: 'ref.js' },
+    { sourceFile: 'env.js', contributorId: 'env.js' },
+    { sourceFile: 'platform.js', contributorId: 'platform.js' },
+    { sourceFile: 'presence.js', contributorId: 'presence.js' },
+    { sourceFile: 'signal.js', contributorId: 'signal.js' },
+    { sourceFile: 'state.js', contributorId: 'state.js' },
+    { sourceFile: 'diagnostics-production.js', contributorId: 'diagnostics.js' },
+    { sourceFile: 'cleanup.js', contributorId: 'cleanup.js' },
+    { sourceFile: 'template-parser.js', contributorId: 'template-parser.js' },
+    { sourceFile: 'markup.js', contributorId: 'markup.js' },
+    { sourceFile: 'payload.js', contributorId: 'payload.js' },
+    { sourceFile: 'expressions.js', contributorId: 'expressions.js' },
+    { sourceFile: 'render.js', contributorId: 'render.js' },
+    { sourceFile: 'fragment-patch.js', contributorId: 'fragment-patch.js' },
+    { sourceFile: 'scanner.js', contributorId: 'scanner.js' },
+    { sourceFile: 'events.js', contributorId: 'events.js' },
+    { sourceFile: 'hydrate.js', contributorId: 'hydrate.js' }
+]);
+export const RUNTIME_TEMPLATE_PROFILES = Object.freeze({
+    DEFAULT: 'default',
+    PRODUCTION_EMITTED: 'production-emitted',
+    PRODUCTION_EMITTED_WITH_PRESENCE: 'production-emitted-with-presence'
+});
+function stripImports(source) {
+    return source
+        .replace(/^\s*import\s+[^;]+;\s*$/gm, '')
+        .replace(/^\s*export\s+\{[^}]+\}\s+from\s+['"]\.[^'"]+['"];\s*$/gm, '')
+        .trim();
+}
+export function normalizeRuntimeTemplateProfile(profile) {
+    if (profile === RUNTIME_TEMPLATE_PROFILES.PRODUCTION_EMITTED) {
+        return RUNTIME_TEMPLATE_PROFILES.PRODUCTION_EMITTED;
+    }
+    if (profile === RUNTIME_TEMPLATE_PROFILES.PRODUCTION_EMITTED_WITH_PRESENCE) {
+        return RUNTIME_TEMPLATE_PROFILES.PRODUCTION_EMITTED_WITH_PRESENCE;
+    }
+    return RUNTIME_TEMPLATE_PROFILES.DEFAULT;
+}
+function runtimeModulesForProfile(profile) {
+    switch (normalizeRuntimeTemplateProfile(profile)) {
+        case RUNTIME_TEMPLATE_PROFILES.PRODUCTION_EMITTED:
+            return PRODUCTION_EMITTED_RUNTIME_MODULES;
+        case RUNTIME_TEMPLATE_PROFILES.PRODUCTION_EMITTED_WITH_PRESENCE:
+            return PRODUCTION_EMITTED_WITH_PRESENCE_RUNTIME_MODULES;
+        default:
+            return DEFAULT_RUNTIME_MODULES;
+    }
+}
+export function buildRuntimeTemplateProfile({ profile, normalizeNewlines, readRuntimeSourceFile }) {
+    const resolvedProfile = normalizeRuntimeTemplateProfile(profile);
+    const modules = runtimeModulesForProfile(resolvedProfile);
+    const segments = [];
+    const contributors = [];
+    let coverageBytes = 0;
+    for (let i = 0; i < modules.length; i += 1) {
+        const entry = modules[i];
+        const source = stripImports(readRuntimeSourceFile(entry.sourceFile));
+        if (!source)
+            continue;
+        segments.push(source);
+        const bytes = Buffer.byteLength(source, 'utf8');
+        coverageBytes += bytes;
+        contributors.push({
+            id: entry.contributorId,
+            sourceFile: entry.sourceFile,
+            bytes
+        });
+    }
+    contributors.sort((left, right) => {
+        if (right.bytes !== left.bytes)
+            return right.bytes - left.bytes;
+        if (left.id !== right.id)
+            return left.id.localeCompare(right.id);
+        return left.sourceFile.localeCompare(right.sourceFile);
+    });
+    return {
+        profile: resolvedProfile,
+        source: normalizeNewlines(segments.join('\n\n')),
+        contributors,
+        coverageBytes
+    };
+}

package/dist/scanner.js

@@ -15,8 +15,8 @@ export function createNodeResolver(root) {
                 marker: { type: kind, id: index },
                 path: `selector:${selector}`,
                 hint: isRef
-                    ? 'Use ref + zenMount and ensure the ref is bound in markup before mount.'
-                    : 'Confirm SSR marker attributes and runtime selector tables match.',
+                    ? 'Use ref + zenMount and bind the ref in markup before mount.'
+                    : 'Confirm SSR marker attributes and selector tables match.',
                 docsLink: isRef ? DOCS_LINKS.refs : DOCS_LINKS.markerTable,
                 source
             });

package/dist/template.d.ts

@@ -1,2 +1,8 @@
-export function runtimeModuleSource(): string;
+export function runtimeModuleSource(): any;
+export function runtimeModuleProfileSnapshot(profile?: "default"): {
+    profile: any;
+    source: any;
+    contributors: any;
+    coverageBytes: any;
+};
 export function runtimeDevClientSource(): string;

package/dist/template.js

@@ -1,35 +1,37 @@
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { buildRuntimeTemplateProfile, RUNTIME_TEMPLATE_PROFILES, normalizeRuntimeTemplateProfile } from './runtime-template-profile.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-function normalizeNewlines(value) {
-    return String(value).replace(/\r\n/g, '\n').replace(/\r/g, '\n');
-}
-function readRuntimeSourceFile(fileName) {
-    const fullPath = join(__dirname, fileName);
-    return normalizeNewlines(readFileSync(fullPath, 'utf8'));
-}
-function stripImports(source) {
-    return source
-        .replace(/^\s*import\s+[^;]+;\s*$/gm, '')
-        .replace(/^\s*export\s+\{[^}]+\}\s+from\s+['"]\.[^'"]+['"];\s*$/gm, '')
-        .trim();
-}
-function buildRuntimeModuleSource() {
-    const segments = [
-        'reactivity-core.js', 'side-effect-scope.js', 'effect-utils.js', 'effect-scheduler.js',
-        'effect-runtime.js', 'mount-runtime.js', 'zeneffect.js', 'ref.js', 'env.js',
-        'platform.js', 'presence.js', 'signal.js', 'state.js',
-        'diagnostics.js', 'cleanup.js', 'template-parser.js', 'markup.js', 'payload.js',
-        'expressions.js', 'render.js', 'fragment-patch.js', 'scanner.js', 'events.js', 'hydrate.js'
-    ].map((fileName) => stripImports(readRuntimeSourceFile(fileName))).filter(Boolean);
-    return normalizeNewlines(segments.join('\n\n'));
+function normalizeNewlines(value) { return String(value).replace(/\r\n/g, '\n').replace(/\r/g, '\n'); }
+function readRuntimeSourceFile(fileName) { return normalizeNewlines(readFileSync(join(__dirname, fileName), 'utf8')); }
+const runtimeTemplateProfileCache = new Map();
+function resolveRuntimeTemplateProfile(profile) {
+    const resolvedProfile = normalizeRuntimeTemplateProfile(profile);
+    if (runtimeTemplateProfileCache.has(resolvedProfile))
+        return runtimeTemplateProfileCache.get(resolvedProfile);
+    const built = buildRuntimeTemplateProfile({
+        profile: resolvedProfile,
+        normalizeNewlines,
+        readRuntimeSourceFile
+    });
+    runtimeTemplateProfileCache.set(resolvedProfile, built);
+    return built;
 }
-const RUNTIME_MODULE_SOURCE = buildRuntimeModuleSource();
+const RUNTIME_MODULE_SOURCE = resolveRuntimeTemplateProfile(RUNTIME_TEMPLATE_PROFILES.DEFAULT).source;
 export function runtimeModuleSource() {
     return RUNTIME_MODULE_SOURCE;
 }
+export function runtimeModuleProfileSnapshot(profile = RUNTIME_TEMPLATE_PROFILES.DEFAULT) {
+    const resolved = resolveRuntimeTemplateProfile(profile);
+    return {
+        profile: resolved.profile,
+        source: resolved.source,
+        contributors: resolved.contributors.map((entry) => ({ ...entry })),
+        coverageBytes: resolved.coverageBytes
+    };
+}
 const RUNTIME_DEV_CLIENT_SOURCE = `(() => {
   if (typeof window === 'undefined' || typeof document === 'undefined') return;
   if (window.__zenithDevClientActive === true) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/runtime",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {