@zenithbuild/runtime 0.7.3 → 0.7.4

package/HYDRATION_CONTRACT.md

@@ -1,6 +1,6 @@
 # Zenith Runtime V0 Hydration Contract
 
-Canonical public docs: `../zenith-docs/documentation/contracts/hydration-contract.md`
+Canonical public docs: `../../docs/documentation/contracts/hydration-contract.md`
 
 
 Status: FROZEN (V0)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zenith Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,30 +1,28 @@
-# @zenith/runtime
+# @zenithbuild/runtime
 
 > **⚠️ Internal API:** This package is an internal implementation detail of the Zenith framework. It is not intended for public use and its API may break without warning. Please use `@zenithbuild/core` instead.
 
-
-The core runtime library for the Zenith framework.
+Internal runtime package for Zenith hydration, bindings, and reactive primitives consumed by compiled output.
 
 ## Canonical Docs
 
-- Runtime contract: `../zenith-docs/documentation/contracts/runtime-contract.md`
-- Hydration contract: `../zenith-docs/documentation/contracts/hydration-contract.md`
-- Reactive binding model: `../zenith-docs/documentation/reference/reactive-binding-model.md`
+- Runtime contract: `../../docs/documentation/contracts/runtime-contract.md`
+- Hydration contract: `../../docs/documentation/contracts/hydration-contract.md`
+- Reactive binding model: `../../docs/documentation/reference/reactive-binding-model.md`
 
 ## Overview
-This package provides the reactivity system, hydration logic, and Virtual DOM primitives used by Zenith applications. It is designed to be lightweight, fast, and tree-shakeable.
+This package provides the minimal runtime surfaces needed after compile:
+
+- signal/state/effect/mount primitives
+- DOM binding and hydration helpers
+- template/runtime bridges consumed by compiler and bundler output
+
+It does not define a public virtual-DOM framework API.
 
 ## Features
-- **Fine-Grained Reactivity**: Signals, Effects, Derived State (Memos).
-- **Hydration**: Efficient client-side hydration of server-rendered HTML.
-- **VDOM primitives**: `h` and `fragment` for lightweight view rendering.
-- **Lifecycle Hooks**: `onMount`, `onUnmount`.
+- **Fine-Grained Reactivity**: signal/state/effect primitives used by emitted code.
+- **Hydration**: deterministic client-side hydration for server-rendered HTML.
+- **Lifecycle Cleanup**: explicit mount/effect cleanup semantics.
 
 ## Usage
-This package is typically installed automatically by the Zenith CLI.
-```typescript
-import { signal, effect } from "@zenith/runtime";
-
-const count = signal(0);
-effect(() => console.log(count()));
-```
+This package is installed as an internal framework dependency. App code should normally use the public Zenith surface instead of importing `@zenithbuild/runtime` directly.

package/RUNTIME_CONTRACT.md

@@ -1,6 +1,6 @@
 # RUNTIME_CONTRACT.md — Sealed Runtime Interface
 
-Canonical public docs: `../zenith-docs/documentation/contracts/runtime-contract.md`
+Canonical public docs: `../../docs/documentation/contracts/runtime-contract.md`
 
 
 > **This document is a legal boundary.**
@@ -117,15 +117,16 @@ effect(() => {
 Internals:
 - On execution, sets itself as the "current tracking context"
 - Any signal read during execution adds this effect to its subscriber set
-- When a dependency signal changes, the effect re-runs
+- When a dependency signal changes, the effect is scheduled to re-run
 
-### Constraints
+### Scheduling & Execution Constraints
 
-- No batching
-- No scheduler / microtask queue
-- No async effects
+- By default, effects are scheduled on the microtask queue (`flush: 'post'`) to prevent render thrashing
+- Synchronous execution is supported via `flush: 'sync'`
+- Advanced debouncing, throttling, and RAF deferral schedulers are internally implemented for complex interactions
 - No suspense / lazy loading
-- No lifecycle hooks beyond `cleanup()`
+- `mount()` exists as the sole component bootstrap hook, deferring initialization until the DOM attachment scope is complete
+- Beyond `mount()` and `cleanup()`, the runtime offers no lifecycle hooks
 
 ---
 
@@ -166,13 +167,24 @@ Cleanup is deterministic — calling it twice is a no-op.
 Total exports (exhaustive):
 
 ```js
-export { signal }    // Create reactive signal
-export { effect }    // Create reactive effect
-export { mount }     // Mount page module into container
-export { cleanup }   // Tear down all bindings
+export { signal }      // Create reactive signal
+export { state }       // Create deep reactive state proxy
+export { zeneffect }   // Canonical reactive effect subscription
+export { zenMount }    // Canonical component bootstrap lifecycle hook
+export { zenWindow }   // Canonical SSR-safe global window access
+export { zenDocument } // Canonical SSR-safe global document access
+export { hydrate }     // Mount page module into container
+export { cleanup }     // Deterministic teardown of effects/listeners
 ```
 
-Four functions. No more.
+### Optional Secondary Aliases
+For developer convenience, the runtime also exports optional, standard-named aliases. These exist purely as synonyms mapped to the canonical primitives:
+```js
+export { effect }      // Alias for zeneffect
+export { mount }       // Alias for zenMount
+export { window }      // Alias for zenWindow
+export { document }    // Alias for zenDocument
+```
 
 ---
 

package/dist/cleanup.js

@@ -10,7 +10,7 @@
 // cleanup() removes everything.
 // Calling cleanup() twice is a no-op.
 // ---------------------------------------------------------------------------
-import { resetGlobalSideEffects } from './zeneffect.js';
+import { resetGlobalSideEffects } from './side-effect-scope.js';
 /** @type {function[]} */
 const _disposers = [];
 /** @type {{ element: Element, event: string, handler: function }[]} */
@@ -46,8 +46,9 @@ export function _registerListener(element, event, handler) {
  */
 export function cleanup() {
     // Global zenMount/zenEffect registrations can be created outside hydrate's
-    // disposer table (e.g. page-level component bootstraps). Even when cleanup
-    // has already run once, we still need to reset that scope deterministically.
+    // disposer table (e.g. page-level component bootstraps). cleanup() is the
+    // full runtime teardown boundary, so that scope must be reset on every pass,
+    // including the first real cleanup.
     if (_cleaned) {
         resetGlobalSideEffects();
         return;
@@ -63,6 +64,8 @@ export function cleanup() {
         element.removeEventListener(event, handler);
     }
     _listeners.length = 0;
+    // 3. Dispose any top-level reactive work registered outside hydrate.
+    resetGlobalSideEffects();
     _cleaned = true;
 }
 /**

package/dist/diagnostics.d.ts

@@ -2,3 +2,10 @@ 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.js

@@ -405,3 +405,10 @@ export function rethrowZenithRuntimeError(error, fallback = {}) {
     _reportRuntimeError(wrapped);
     throw wrapped;
 }
+export const DOCS_LINKS = Object.freeze({
+    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/effect-runtime.d.ts

@@ -0,0 +1,2 @@
+export declare function createAutoTrackedEffect(effect: any, options: any, scope: any): () => void;
+export declare function createExplicitDependencyEffect(effect: any, dependencies: any, scope: any): () => void;

package/dist/effect-runtime.js

@@ -0,0 +1,139 @@
+// @ts-nocheck
+import { runWithDependencyCollector } from './reactivity-core.js';
+import { registerScopeDisposer, queueWhenScopeReady } from './side-effect-scope.js';
+import { drainCleanupStack, applyCleanupResult, createEffectContext } from './effect-utils.js';
+import { createScheduler } from './effect-scheduler.js';
+let _effectIdCounter = 0;
+export function createAutoTrackedEffect(effect, options, scope) {
+    let disposed = false;
+    const activeSubscriptions = new Map();
+    const runCleanups = [];
+    _effectIdCounter += 1;
+    const effectId = _effectIdCounter;
+    function registerCleanup(cleanup) {
+        if (typeof cleanup !== 'function') {
+            throw new Error('[Zenith Runtime] cleanup(fn) requires a function');
+        }
+        runCleanups.push(cleanup);
+    }
+    function runEffectNow() {
+        if (disposed || !scope || scope.disposed) {
+            return;
+        }
+        drainCleanupStack(runCleanups);
+        const nextDependenciesById = new Map();
+        runWithDependencyCollector((source) => {
+            if (!source || typeof source.subscribe !== 'function') {
+                return;
+            }
+            const reactiveId = Number.isInteger(source.__zenith_id) ? source.__zenith_id : 0;
+            if (!nextDependenciesById.has(reactiveId)) {
+                nextDependenciesById.set(reactiveId, source);
+            }
+        }, () => {
+            const result = effect(createEffectContext(registerCleanup));
+            applyCleanupResult(result, registerCleanup);
+        });
+        const nextDependencies = Array.from(nextDependenciesById.values()).sort((left, right) => {
+            const leftId = Number.isInteger(left.__zenith_id) ? left.__zenith_id : 0;
+            const rightId = Number.isInteger(right.__zenith_id) ? right.__zenith_id : 0;
+            return leftId - rightId;
+        });
+        const nextSet = new Set(nextDependencies);
+        for (const [dependency, unsubscribe] of activeSubscriptions.entries()) {
+            if (nextSet.has(dependency)) {
+                continue;
+            }
+            if (typeof unsubscribe === 'function') {
+                unsubscribe();
+            }
+            activeSubscriptions.delete(dependency);
+        }
+        for (let i = 0; i < nextDependencies.length; i++) {
+            const dependency = nextDependencies[i];
+            if (activeSubscriptions.has(dependency)) {
+                continue;
+            }
+            const unsubscribe = dependency.subscribe(() => {
+                scheduler.schedule();
+            });
+            activeSubscriptions.set(dependency, typeof unsubscribe === 'function' ? unsubscribe : () => { });
+        }
+        void effectId;
+    }
+    const scheduler = createScheduler(runEffectNow, options);
+    function disposeEffect() {
+        if (disposed) {
+            return;
+        }
+        disposed = true;
+        scheduler.cancel();
+        for (const unsubscribe of activeSubscriptions.values()) {
+            if (typeof unsubscribe === 'function') {
+                unsubscribe();
+            }
+        }
+        activeSubscriptions.clear();
+        drainCleanupStack(runCleanups);
+    }
+    registerScopeDisposer(scope, disposeEffect);
+    queueWhenScopeReady(scope, () => scheduler.schedule());
+    return disposeEffect;
+}
+export function createExplicitDependencyEffect(effect, dependencies, scope) {
+    if (!Array.isArray(dependencies)) {
+        throw new Error('[Zenith Runtime] zeneffect(deps, fn) requires an array of dependencies');
+    }
+    if (dependencies.length === 0) {
+        throw new Error('[Zenith Runtime] zeneffect(deps, fn) requires at least one dependency');
+    }
+    if (typeof effect !== 'function') {
+        throw new Error('[Zenith Runtime] zeneffect(deps, fn) requires a function');
+    }
+    let disposed = false;
+    const runCleanups = [];
+    function registerCleanup(cleanup) {
+        if (typeof cleanup !== 'function') {
+            throw new Error('[Zenith Runtime] cleanup(fn) requires a function');
+        }
+        runCleanups.push(cleanup);
+    }
+    function runEffectNow() {
+        if (disposed || !scope || scope.disposed) {
+            return;
+        }
+        drainCleanupStack(runCleanups);
+        const result = effect(createEffectContext(registerCleanup));
+        applyCleanupResult(result, registerCleanup);
+    }
+    const unsubscribers = dependencies.map((dep, index) => {
+        if (!dep || typeof dep.subscribe !== 'function') {
+            throw new Error(`[Zenith Runtime] zeneffect dependency at index ${index} must expose subscribe(fn)`);
+        }
+        return dep.subscribe(() => {
+            if (scope?.mountReady === true) {
+                runEffectNow();
+                return;
+            }
+            queueWhenScopeReady(scope, runEffectNow);
+        });
+    });
+    if (scope?.mountReady === true) {
+        runEffectNow();
+    }
+    else {
+        queueWhenScopeReady(scope, runEffectNow);
+    }
+    const dispose = () => {
+        if (disposed) {
+            return;
+        }
+        disposed = true;
+        for (let i = 0; i < unsubscribers.length; i++) {
+            unsubscribers[i]();
+        }
+        drainCleanupStack(runCleanups);
+    };
+    registerScopeDisposer(scope, dispose);
+    return dispose;
+}

package/dist/effect-scheduler.d.ts

@@ -0,0 +1,4 @@
+export declare function createScheduler(runNow: any, options: any): {
+    schedule: () => void;
+    cancel: () => void;
+};

package/dist/effect-scheduler.js

@@ -0,0 +1,88 @@
+// @ts-nocheck
+export function createScheduler(runNow, options) {
+    let microtaskQueued = false;
+    let debounceTimer = null;
+    let throttleTimer = null;
+    let rafHandle = null;
+    let lastRunAt = 0;
+    function clearScheduledWork() {
+        if (debounceTimer !== null) {
+            clearTimeout(debounceTimer);
+            debounceTimer = null;
+        }
+        if (throttleTimer !== null) {
+            clearTimeout(throttleTimer);
+            throttleTimer = null;
+        }
+        if (rafHandle !== null) {
+            if (typeof cancelAnimationFrame === 'function') {
+                cancelAnimationFrame(rafHandle);
+            }
+            else {
+                clearTimeout(rafHandle);
+            }
+            rafHandle = null;
+        }
+        microtaskQueued = false;
+    }
+    function invokeNow() {
+        microtaskQueued = false;
+        debounceTimer = null;
+        throttleTimer = null;
+        rafHandle = null;
+        lastRunAt = Date.now();
+        runNow();
+    }
+    function schedule() {
+        if (options.debounceMs > 0) {
+            if (debounceTimer !== null) {
+                clearTimeout(debounceTimer);
+            }
+            debounceTimer = setTimeout(invokeNow, options.debounceMs);
+            return;
+        }
+        if (options.throttleMs > 0) {
+            const now = Date.now();
+            const elapsed = now - lastRunAt;
+            if (lastRunAt === 0 || elapsed >= options.throttleMs) {
+                invokeNow();
+                return;
+            }
+            if (throttleTimer !== null) {
+                return;
+            }
+            throttleTimer = setTimeout(invokeNow, options.throttleMs - elapsed);
+            return;
+        }
+        if (options.raf) {
+            if (rafHandle !== null) {
+                if (typeof cancelAnimationFrame === 'function') {
+                    cancelAnimationFrame(rafHandle);
+                }
+                else {
+                    clearTimeout(rafHandle);
+                }
+            }
+            if (typeof requestAnimationFrame === 'function') {
+                rafHandle = requestAnimationFrame(invokeNow);
+            }
+            else {
+                rafHandle = setTimeout(invokeNow, 16);
+            }
+            return;
+        }
+        if (options.flush === 'sync') {
+            invokeNow();
+            return;
+        }
+        if (microtaskQueued) {
+            return;
+        }
+        microtaskQueued = true;
+        queueMicrotask(invokeNow);
+    }
+    return {
+        schedule,
+        cancel: clearScheduledWork
+    };
+}

package/dist/effect-utils.d.ts

@@ -0,0 +1,19 @@
+export declare function normalizeDelay(value: any, fieldName: any): number;
+export declare function normalizeEffectOptions(options: any): {
+    debounceMs: number;
+    throttleMs: number;
+    raf: boolean;
+    flush: string;
+};
+export declare function drainCleanupStack(cleanups: any): void;
+export declare function applyCleanupResult(result: any, registerCleanup: any): void;
+export declare function createMountContext(registerCleanup: any): {
+    cleanup: any;
+};
+export declare function createEffectContext(registerCleanup: any): {
+    cleanup: any;
+    timeout(callback: any, delayMs?: number): NodeJS.Timeout;
+    raf(callback: any): number | NodeJS.Timeout;
+    debounce(callback: any, delayMs: any): (...args: any[]) => void;
+    throttle(callback: any, delayMs: any): (...args: any[]) => void;
+};

package/dist/effect-utils.js

@@ -0,0 +1,160 @@
+// @ts-nocheck
+const DEFAULT_EFFECT_OPTIONS = {
+    debounceMs: 0,
+    throttleMs: 0,
+    raf: false,
+    flush: 'post'
+};
+export function normalizeDelay(value, fieldName) {
+    if (value === undefined || value === null) {
+        return 0;
+    }
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`[Zenith Runtime] zenEffect options.${fieldName} must be a non-negative number`);
+    }
+    return Math.floor(value);
+}
+export function normalizeEffectOptions(options) {
+    if (options === undefined || options === null) {
+        return DEFAULT_EFFECT_OPTIONS;
+    }
+    if (!options || typeof options !== 'object' || Array.isArray(options)) {
+        throw new Error('[Zenith Runtime] zenEffect(effect, options) requires options object when provided');
+    }
+    const normalized = {
+        debounceMs: normalizeDelay(options.debounceMs, 'debounceMs'),
+        throttleMs: normalizeDelay(options.throttleMs, 'throttleMs'),
+        raf: options.raf === true,
+        flush: options.flush === 'sync' ? 'sync' : 'post'
+    };
+    if (options.flush !== undefined && options.flush !== 'sync' && options.flush !== 'post') {
+        throw new Error('[Zenith Runtime] zenEffect options.flush must be "post" or "sync"');
+    }
+    const schedulingModes = (normalized.debounceMs > 0 ? 1 : 0) +
+        (normalized.throttleMs > 0 ? 1 : 0) +
+        (normalized.raf ? 1 : 0);
+    if (schedulingModes > 1) {
+        throw new Error('[Zenith Runtime] zenEffect options may use only one scheduler: debounceMs, throttleMs, or raf');
+    }
+    return normalized;
+}
+export function drainCleanupStack(cleanups) {
+    for (let i = cleanups.length - 1; i >= 0; i--) {
+        const cleanup = cleanups[i];
+        if (typeof cleanup !== 'function') {
+            continue;
+        }
+        try {
+            cleanup();
+        }
+        catch {
+        }
+    }
+    cleanups.length = 0;
+}
+export function applyCleanupResult(result, registerCleanup) {
+    if (typeof result === 'function') {
+        registerCleanup(result);
+        return;
+    }
+    if (result && typeof result === 'object' && typeof result.cleanup === 'function') {
+        registerCleanup(result.cleanup);
+    }
+}
+function requireFunction(callback, label) {
+    if (typeof callback !== 'function') {
+        throw new Error(`[Zenith Runtime] ${label} requires callback function`);
+    }
+}
+export function createMountContext(registerCleanup) {
+    return {
+        cleanup: registerCleanup
+    };
+}
+export function createEffectContext(registerCleanup) {
+    return {
+        cleanup: registerCleanup,
+        timeout(callback, delayMs = 0) {
+            requireFunction(callback, 'zenEffect context.timeout(callback, delayMs)');
+            const timeoutId = setTimeout(callback, normalizeDelay(delayMs, 'timeout'));
+            registerCleanup(() => clearTimeout(timeoutId));
+            return timeoutId;
+        },
+        raf(callback) {
+            requireFunction(callback, 'zenEffect context.raf(callback)');
+            if (typeof requestAnimationFrame === 'function') {
+                const frameId = requestAnimationFrame(callback);
+                registerCleanup(() => cancelAnimationFrame(frameId));
+                return frameId;
+            }
+            const timeoutId = setTimeout(callback, 16);
+            registerCleanup(() => clearTimeout(timeoutId));
+            return timeoutId;
+        },
+        debounce(callback, delayMs) {
+            requireFunction(callback, 'zenEffect context.debounce(callback, delayMs)');
+            const waitMs = normalizeDelay(delayMs, 'debounce');
+            let timeoutId = null;
+            const wrapped = (...args) => {
+                if (timeoutId !== null) {
+                    clearTimeout(timeoutId);
+                }
+                timeoutId = setTimeout(() => {
+                    timeoutId = null;
+                    callback(...args);
+                }, waitMs);
+            };
+            registerCleanup(() => {
+                if (timeoutId !== null) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+            });
+            return wrapped;
+        },
+        throttle(callback, delayMs) {
+            requireFunction(callback, 'zenEffect context.throttle(callback, delayMs)');
+            const waitMs = normalizeDelay(delayMs, 'throttle');
+            let timeoutId = null;
+            let lastRun = 0;
+            let pendingArgs = null;
+            const invoke = (args) => {
+                lastRun = Date.now();
+                callback(...args);
+            };
+            const wrapped = (...args) => {
+                const now = Date.now();
+                const elapsed = now - lastRun;
+                if (lastRun === 0 || elapsed >= waitMs) {
+                    if (timeoutId !== null) {
+                        clearTimeout(timeoutId);
+                        timeoutId = null;
+                    }
+                    pendingArgs = null;
+                    invoke(args);
+                    return;
+                }
+                pendingArgs = args;
+                if (timeoutId !== null) {
+                    return;
+                }
+                timeoutId = setTimeout(() => {
+                    timeoutId = null;
+                    if (pendingArgs) {
+                        const next = pendingArgs;
+                        pendingArgs = null;
+                        invoke(next);
+                    }
+                }, waitMs - elapsed);
+            };
+            registerCleanup(() => {
+                if (timeoutId !== null) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                pendingArgs = null;
+            });
+            return wrapped;
+        }
+    };
+}

package/dist/env.d.ts

@@ -1,2 +1,14 @@
+/** Canonical public access to window */
 export declare function zenWindow(): Window | null;
+/** Canonical public access to document */
 export declare function zenDocument(): Document | null;
+/**
+ * @alias zenWindow
+ * @description Optional secondary alias for the canonical zenWindow primitive.
+ */
+export declare function window(): Window | null;
+/**
+ * @alias zenDocument
+ * @description Optional secondary alias for the canonical zenDocument primitive.
+ */
+export declare function document(): Document | null;

package/dist/env.js

@@ -4,9 +4,25 @@
 // SSR-safe access to window and document. Returns null when not in browser.
 // Use zenWindow() / zenDocument() instead of direct window/document access.
 // ---------------------------------------------------------------------------
+/** Canonical public access to window */
 export function zenWindow() {
-    return typeof window === 'undefined' ? null : window;
+    return typeof globalThis.window === 'undefined' ? null : globalThis.window;
 }
+/** Canonical public access to document */
 export function zenDocument() {
-    return typeof document === 'undefined' ? null : document;
+    return typeof globalThis.document === 'undefined' ? null : globalThis.document;
+}
+/**
+ * @alias zenWindow
+ * @description Optional secondary alias for the canonical zenWindow primitive.
+ */
+export function window() {
+    return zenWindow();
+}
+/**
+ * @alias zenDocument
+ * @description Optional secondary alias for the canonical zenDocument primitive.
+ */
+export function document() {
+    return zenDocument();
 }

package/dist/events.d.ts

@@ -1,8 +1 @@
-/**
- * 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: Element, eventName: string, exprFn: () => any): void;
+export function bindEventMarkers(context: any): void;