@meekojs/meeko 0.0.0-stage → 0.0.1

package/dist/dom.js

@@ -0,0 +1,315 @@
+import { createRoot, effect, signal } from "./reactivity.js";
+import { attributeValue, serializeJson } from "./server.js";
+/** Añade una lectura de estado a la limpieza de un componente compilado. */
+export function withStateSnapshot(release, snapshot) {
+    return Object.assign(release, { snapshot });
+}
+const componentStart = /^meeko:component:\d+(?::.*)?$/;
+function componentEnd(start) {
+    let depth = 0;
+    for (let node = start; node; node = node.nextSibling) {
+        if (node.nodeType !== 8)
+            continue;
+        const data = node.data;
+        if (componentStart.test(data))
+            depth++;
+        else if (/^\/meeko:component:\d+$/.test(data) && --depth === 0)
+            return node;
+    }
+    throw new Error(`Missing end marker for ${start.data}`);
+}
+function visit(scope, callback) {
+    function siblings(first, stop = null) {
+        for (let node = first; node && node !== stop;) {
+            if (callback(node))
+                return node;
+            if (node.nodeType === 8 && componentStart.test(node.data)) {
+                const end = componentEnd(node);
+                if (callback(end))
+                    return end;
+                node = end.nextSibling;
+                continue;
+            }
+            const found = siblings(node.firstChild);
+            if (found)
+                return found;
+            node = node.nextSibling;
+        }
+        return undefined;
+    }
+    return siblings(scope.start?.nextSibling ?? scope.root.firstChild, scope.end ?? null);
+}
+function findComment(scope, data) {
+    const node = visit(scope, (candidate) => candidate.nodeType === 8 && candidate.data === data);
+    if (!node)
+        throw new Error(`Missing Meeko marker ${data}`);
+    return node;
+}
+function findElement(scope, name) {
+    const node = visit(scope, (candidate) => candidate.nodeType === 1 && candidate.hasAttribute(name));
+    if (!node)
+        throw new Error(`Missing Meeko target ${name}`);
+    return node;
+}
+function region(scope, kind, id) {
+    const start = findComment(scope, `meeko:${kind}:${id}`);
+    const end = findComment(scope, `/meeko:${kind}:${id}`);
+    if (start.parentNode !== end.parentNode)
+        throw new Error(`Invalid Meeko region ${kind}:${id}`);
+    return { root: scope.root, start, end };
+}
+function clearRegion(scope) {
+    if (!scope.start || !scope.end)
+        throw new Error("Expected a bounded Meeko region");
+    for (let node = scope.start.nextSibling; node && node !== scope.end;) {
+        const next = node.nextSibling;
+        node.parentNode?.removeChild(node);
+        node = next;
+    }
+}
+function insertHtml(end, html) {
+    const parent = end.parentNode;
+    if (!parent)
+        throw new Error("Detached Meeko region");
+    const range = end.ownerDocument.createRange();
+    range.selectNodeContents(parent);
+    parent.insertBefore(range.createContextualFragment(html), end);
+}
+function sameProps(first, second) {
+    const firstKeys = Object.keys(first);
+    const secondKeys = Object.keys(second);
+    return firstKeys.length === secondKeys.length && firstKeys.every((key) => Object.hasOwn(second, key) && Object.is(first[key], second[key]));
+}
+/** Renderiza un hijo entre comentarios de ámbito sin añadir un elemento visual. */
+export function renderComponent(id, component, props, transferState = false) {
+    if (transferState) {
+        if (!component.renderWithState)
+            throw new TypeError(`Component ${id} cannot transfer SSR state`);
+        const rendered = component.renderWithState(props);
+        return `<!--meeko:component:${id}:${encodeURIComponent(serializeJson(rendered.state))}-->${rendered.html}<!--/meeko:component:${id}-->`;
+    }
+    return `<!--meeko:component:${id}-->${component.renderToString(props)}<!--/meeko:component:${id}-->`;
+}
+function componentRegion(scope, id) {
+    const prefix = `meeko:component:${id}`;
+    const start = visit(scope, (candidate) => candidate.nodeType === 8 && (candidate.data === prefix || candidate.data.startsWith(`${prefix}:`)));
+    if (!start)
+        throw new Error(`Missing Meeko marker ${prefix}`);
+    const end = findComment(scope, `/meeko:component:${id}`);
+    if (start.parentNode !== end.parentNode)
+        throw new Error(`Invalid Meeko region component:${id}`);
+    const encoded = start.data.slice(prefix.length);
+    if (!encoded)
+        return { inner: { root: scope.root, start, end } };
+    const parsed = JSON.parse(decodeURIComponent(encoded.slice(1)));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+        throw new TypeError(`Invalid Meeko state for component:${id}`);
+    return { inner: { root: scope.root, start, end }, state: parsed };
+}
+/** Hidrata un hijo dentro de su rango y actualiza props reactivas con limpieza previa. */
+export function bindComponent(scope, id, component, read, location) {
+    let inner;
+    let state;
+    try {
+        ({ inner, state } = componentRegion(scope, id));
+    }
+    catch (error) {
+        throw new Error(`Hydration mismatch in ${location}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    let props = read();
+    let release = component.hydrateScope(inner, props, state);
+    const stop = effect(() => {
+        const next = read();
+        if (sameProps(props, next))
+            return;
+        const state = release.snapshot?.();
+        const html = component.renderToString(next, state);
+        release();
+        clearRegion(inner);
+        insertHtml(inner.end, html);
+        release = component.hydrateScope(inner, next, state);
+        props = next;
+    });
+    return () => { stop(); release(); };
+}
+/** Conecta un texto reactivo al marcador SSR y comprueba su valor inicial. */
+export function bindText(scope, id, read, location) {
+    const marker = findComment(scope, `meeko:text:${id}`);
+    const text = marker.nextSibling;
+    if (!text || text.nodeType !== 3)
+        throw new Error(`Missing text node in ${location}`);
+    if (text.textContent !== String(read()))
+        throw new Error(`Hydration mismatch in ${location}`);
+    return effect(() => { text.textContent = String(read()); });
+}
+/** Conecta un atributo dinámico al elemento SSR y comprueba su valor inicial. */
+export function bindAttribute(scope, id, name, read, location) {
+    const target = findElement(scope, `data-meeko-a-${id}`);
+    if (target.getAttribute(name) !== attributeValue(name, read()))
+        throw new Error(`Hydration mismatch in ${location}`);
+    return effect(() => {
+        const next = attributeValue(name, read());
+        if (next === null)
+            target.removeAttribute(name);
+        else
+            target.setAttribute(name, next);
+    });
+}
+/** Conecta un evento al elemento SSR y entrega su función de limpieza. */
+export function bindEvent(scope, id, name, handler) {
+    const target = findElement(scope, `data-meeko-e-${id}`);
+    target.addEventListener(name, handler);
+    return () => target.removeEventListener(name, handler);
+}
+/** Genera los límites estables de una condición en SSR. */
+export function renderIf(id, condition, render) {
+    return `<!--meeko:if:${id}-->${condition ? render() : ""}<!--/meeko:if:${id}-->`;
+}
+/** Hidrata una condición y conserva los nodos mientras sigue siendo verdadera. */
+export function bindIf(scope, id, read, render, hydrate) {
+    const inner = region(scope, "if", id);
+    let active = Boolean(read());
+    if (!active && inner.start?.nextSibling !== inner.end)
+        throw new Error(`Hydration mismatch in condition ${id}`);
+    let release = active ? hydrate(inner) : undefined;
+    const stop = effect(() => {
+        const next = Boolean(read());
+        if (next === active)
+            return;
+        release?.();
+        release = undefined;
+        clearRegion(inner);
+        if (next) {
+            insertHtml(inner.end, render());
+            release = hydrate(inner);
+        }
+        active = next;
+    });
+    return () => { stop(); release?.(); };
+}
+/** Convierte una clave de lista en un token seguro para comentarios HTML. */
+export function keyToken(key) {
+    if (typeof key === "number" && Number.isFinite(key))
+        return `n${encodeURIComponent(String(key)).replaceAll("-", "%2D")}`;
+    if (typeof key === "string")
+        return `s${encodeURIComponent(key).replaceAll("-", "%2D")}`;
+    throw new TypeError("Meeko list keys must be strings or finite numbers");
+}
+/** Renderiza una lista con límites identificados por claves únicas. */
+export function renderFor(id, items, keyOf, render) {
+    const seen = new Set();
+    let html = `<!--meeko:for:${id}-->`;
+    let index = 0;
+    for (const item of items) {
+        const key = keyToken(keyOf(item, index));
+        if (seen.has(key))
+            throw new Error(`Duplicate Meeko list key ${key}`);
+        seen.add(key);
+        html += `<!--meeko:item:${id}:${key}-->${render(item, index)}<!--/meeko:item:${id}:${key}-->`;
+        index++;
+    }
+    return `${html}<!--/meeko:for:${id}-->`;
+}
+function moveRange(start, end, before) {
+    const parent = before.parentNode;
+    if (!parent)
+        throw new Error("Detached Meeko list");
+    const document = before.ownerDocument;
+    if (!document)
+        throw new Error("Missing document for Meeko list");
+    const fragment = document.createDocumentFragment();
+    for (let node = start; node;) {
+        const next = node.nextSibling;
+        fragment.appendChild(node);
+        if (node === end)
+            break;
+        node = next;
+    }
+    parent.insertBefore(fragment, before);
+}
+/** Hidrata una lista y reordena regiones por clave sin reemplazar nodos conservados. */
+export function bindFor(scope, id, read, keyOf, render, hydrate) {
+    const outer = region(scope, "for", id);
+    const entries = new Map();
+    const initial = [...read()];
+    let cursor = outer.start.nextSibling;
+    for (let index = 0; index < initial.length; index++) {
+        const item = initial[index];
+        const key = keyToken(keyOf(item, index));
+        if (entries.has(key))
+            throw new Error(`Duplicate Meeko list key ${key}`);
+        const startData = `meeko:item:${id}:${key}`;
+        const endData = `/meeko:item:${id}:${key}`;
+        if (!cursor || cursor.nodeType !== 8 || cursor.data !== startData)
+            throw new Error(`Hydration mismatch in list ${id} at key ${key}`);
+        const start = cursor;
+        let end = start.nextSibling;
+        while (end && (end.nodeType !== 8 || end.data !== endData))
+            end = end.nextSibling;
+        if (!end)
+            throw new Error(`Missing end marker for list key ${key}`);
+        const value = signal(item);
+        const position = signal(index);
+        const release = createRoot((dispose) => {
+            const cleanup = hydrate(value, position, { root: scope.root, start, end: end });
+            return () => { cleanup(); dispose(); };
+        });
+        entries.set(key, { key, start, end: end, value, index: position, release });
+        cursor = end.nextSibling;
+    }
+    if (cursor !== outer.end)
+        throw new Error(`Hydration mismatch in list ${id}: extra nodes`);
+    const stop = effect(() => {
+        const items = [...read()];
+        const nextKeys = items.map((item, index) => keyToken(keyOf(item, index)));
+        if (new Set(nextKeys).size !== nextKeys.length)
+            throw new Error(`Duplicate Meeko list key in region ${id}`);
+        for (const [key, entry] of entries) {
+            if (nextKeys.includes(key))
+                continue;
+            entry.release();
+            let node = entry.start;
+            while (node) {
+                const next = node.nextSibling;
+                node.parentNode?.removeChild(node);
+                if (node === entry.end)
+                    break;
+                node = next;
+            }
+            entries.delete(key);
+        }
+        let before = outer.end;
+        for (let index = items.length - 1; index >= 0; index--) {
+            const item = items[index];
+            const key = nextKeys[index];
+            let entry = entries.get(key);
+            if (!entry) {
+                const html = `<!--meeko:item:${id}:${key}-->${render(item, index)}<!--/meeko:item:${id}:${key}-->`;
+                insertHtml(before, html);
+                const end = before.previousSibling;
+                let start = end.previousSibling;
+                while (start && (start.nodeType !== 8 || start.data !== `meeko:item:${id}:${key}`))
+                    start = start.previousSibling;
+                if (!start)
+                    throw new Error(`Missing new list marker for ${key}`);
+                const value = signal(item);
+                const position = signal(index);
+                const release = createRoot((dispose) => {
+                    const cleanup = hydrate(value, position, { root: scope.root, start: start, end });
+                    return () => { cleanup(); dispose(); };
+                });
+                entry = { key, start: start, end, value, index: position, release };
+                entries.set(key, entry);
+            }
+            else {
+                entry.value.value = item;
+                entry.index.value = index;
+            }
+            if (entry.end.nextSibling !== before)
+                moveRange(entry.start, entry.end, before);
+            before = entry.start;
+        }
+    });
+    return () => { stop(); for (const entry of entries.values())
+        entry.release(); entries.clear(); };
+}

package/dist/hmr.d.ts

@@ -0,0 +1,24 @@
+import type { DomScope } from "./dom.js";
+/** Valores de señales transferidos en memoria entre versiones de un componente. */
+export type HotState = Record<string, unknown>;
+/** Contrato mínimo de un módulo Meeko reemplazable en desarrollo. */
+export interface HotComponent<Props = unknown> {
+    renderToString(props: Props, state?: HotState): string;
+    hydrate(root: Element, props: Props, state?: HotState): () => void;
+    hydrateScope?(scope: DomScope, props: Props, state?: HotState): () => void;
+    css?: string;
+}
+/** Copia solo las señales editables de un setup, sin serializarlas. */
+export declare function snapshotSignals(bindings: Record<string, unknown>): HotState;
+/** Restaura señales compatibles antes de renderizar o hidratar la nueva versión. */
+export declare function restoreSignals(bindings: Record<string, unknown>, state?: HotState): void;
+/** Activa el seguimiento de instancias solo para módulos servidos por Vite. */
+export declare function enableHotModule(id: string): void;
+/** Registra una raíz hidratada y elimina el registro al liberarla. */
+export declare function registerHotInstance<Props>(id: string, root: Element, props: Props, component: HotComponent<Props>, snapshot: () => HotState, dispose: () => void): () => void;
+/** Registra un componente hijo delimitado por comentarios para actualizarlo sin tocar al padre. */
+export declare function registerHotScope<Props>(id: string, scope: DomScope, props: Props, component: HotComponent<Props>, snapshot: () => HotState, dispose: () => void): () => void;
+/** Aplica CSS nuevo después de la hoja virtual cargada por Vite. */
+export declare function replaceHotStyle(id: string, css: string): void;
+/** Sustituye las instancias activas sin recargar la página y conserva señales editables. */
+export declare function replaceHotModule(id: string, next: unknown): void;

package/dist/hmr.js

@@ -0,0 +1,137 @@
+import { isWritableSignal } from "./reactivity.js";
+const enabled = new Set();
+const instances = new Map();
+/** Copia solo las señales editables de un setup, sin serializarlas. */
+export function snapshotSignals(bindings) {
+    const state = {};
+    for (const [name, value] of Object.entries(bindings)) {
+        if (isWritableSignal(value))
+            state[name] = value.value;
+    }
+    return state;
+}
+/** Restaura señales compatibles antes de renderizar o hidratar la nueva versión. */
+export function restoreSignals(bindings, state) {
+    if (!state)
+        return;
+    for (const [name, value] of Object.entries(state)) {
+        const target = bindings[name];
+        if (isWritableSignal(target))
+            target.value = value;
+    }
+}
+/** Activa el seguimiento de instancias solo para módulos servidos por Vite. */
+export function enableHotModule(id) {
+    enabled.add(id);
+}
+function registerHotTarget(id, key, target, props, component, snapshot, dispose) {
+    if (!enabled.has(id))
+        return dispose;
+    const entry = { target, props, component: component, snapshot, dispose };
+    let group = instances.get(id);
+    if (!group) {
+        group = new Map();
+        instances.set(id, group);
+    }
+    const existing = group.get(key);
+    if (existing) {
+        existing.current = entry;
+        return existing.stop;
+    }
+    const slot = {
+        current: entry,
+        stop: () => {
+            if (group.get(key) !== slot)
+                return;
+            group.delete(key);
+            if (group.size === 0)
+                instances.delete(id);
+            slot.current.dispose();
+        },
+    };
+    group.set(key, slot);
+    return slot.stop;
+}
+/** Registra una raíz hidratada y elimina el registro al liberarla. */
+export function registerHotInstance(id, root, props, component, snapshot, dispose) {
+    return registerHotTarget(id, root, { kind: "root", root }, props, component, snapshot, dispose);
+}
+/** Registra un componente hijo delimitado por comentarios para actualizarlo sin tocar al padre. */
+export function registerHotScope(id, scope, props, component, snapshot, dispose) {
+    if (!scope.start || !scope.end)
+        throw new Error("Hot child component requires a bounded scope");
+    return registerHotTarget(id, scope.start, { kind: "scope", scope }, props, component, snapshot, dispose);
+}
+function scopeRange(scope) {
+    if (!scope.start || !scope.end)
+        throw new Error("Hot child component lost its markers");
+    const range = scope.start.ownerDocument.createRange();
+    range.setStartAfter(scope.start);
+    range.setEndBefore(scope.end);
+    return range;
+}
+function replaceScope(scope, html) {
+    const range = scopeRange(scope);
+    const content = range.createContextualFragment(html);
+    range.deleteContents();
+    range.insertNode(content);
+}
+/** Aplica CSS nuevo después de la hoja virtual cargada por Vite. */
+export function replaceHotStyle(id, css) {
+    if (typeof document === "undefined")
+        return;
+    let style = document.querySelector(`style[data-meeko-hot="${id}"]`);
+    if (!style) {
+        style = document.createElement("style");
+        style.dataset.meekoHot = id;
+        document.head.appendChild(style);
+    }
+    style.textContent = css;
+}
+/** Sustituye las instancias activas sin recargar la página y conserva señales editables. */
+export function replaceHotModule(id, next) {
+    if (typeof next !== "object" || next === null || !("renderToString" in next) || !("hydrate" in next)
+        || typeof next.renderToString !== "function" || typeof next.hydrate !== "function") {
+        throw new TypeError("Invalid Meeko hot module");
+    }
+    const component = next;
+    const prepared = [...(instances.get(id)?.values() ?? [])].map((slot) => {
+        const entry = slot.current;
+        const state = entry.snapshot();
+        const previous = entry.target.kind === "root" ? entry.target.root.innerHTML : scopeRange(entry.target.scope).cloneContents();
+        return { slot, entry, state, html: component.renderToString(entry.props, state), previous };
+    });
+    for (const { slot, entry, state, html, previous } of prepared) {
+        entry.dispose();
+        if (entry.target.kind === "root")
+            entry.target.root.innerHTML = html;
+        else
+            replaceScope(entry.target.scope, html);
+        try {
+            if (entry.target.kind === "root")
+                component.hydrate(entry.target.root, entry.props, state);
+            else {
+                if (!component.hydrateScope)
+                    throw new Error("Updated Meeko child component has no hydrateScope export");
+                component.hydrateScope(entry.target.scope, entry.props, state);
+            }
+            if (slot.current === entry)
+                throw new Error("Updated Meeko component did not register its hydrated instance");
+        }
+        catch (error) {
+            if (entry.target.kind === "root")
+                entry.target.root.innerHTML = previous;
+            else {
+                const range = scopeRange(entry.target.scope);
+                range.deleteContents();
+                range.insertNode(previous);
+            }
+            if (entry.target.kind === "root")
+                entry.component.hydrate(entry.target.root, entry.props, state);
+            else
+                entry.component.hydrateScope?.(entry.target.scope, entry.props, state);
+            throw error;
+        }
+    }
+    replaceHotStyle(id, component.css ?? "");
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { batch, computed, createRoot, effect, signal, untrack } from "./reactivity.js";
+export type { ReadonlySignal, Signal } from "./reactivity.js";
+export { attributeValue, escapeHtml, renderAttribute, serializeJson } from "./server.js";
+export { bindAttribute, bindComponent, bindEvent, bindFor, bindIf, bindText, keyToken, renderComponent, renderFor, renderIf, withStateSnapshot } from "./dom.js";
+export type { ComponentModule, ComponentRelease, DomScope } from "./dom.js";
+export { enableHotModule, registerHotInstance, registerHotScope, replaceHotModule, replaceHotStyle, restoreSignals, snapshotSignals } from "./hmr.js";
+export type { HotComponent, HotState } from "./hmr.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { batch, computed, createRoot, effect, signal, untrack } from "./reactivity.js";
+export { attributeValue, escapeHtml, renderAttribute, serializeJson } from "./server.js";
+export { bindAttribute, bindComponent, bindEvent, bindFor, bindIf, bindText, keyToken, renderComponent, renderFor, renderIf, withStateSnapshot } from "./dom.js";
+export { enableHotModule, registerHotInstance, registerHotScope, replaceHotModule, replaceHotStyle, restoreSignals, snapshotSignals } from "./hmr.js";

package/dist/reactivity.d.ts

@@ -0,0 +1,22 @@
+/** Señal de solo lectura que registra dependencias al consultar su valor. */
+export interface ReadonlySignal<T> {
+    readonly value: T;
+}
+/** Señal cuyo valor puede actualizarse de forma reactiva. */
+export interface Signal<T> extends ReadonlySignal<T> {
+    value: T;
+}
+/** Identifica señales editables creadas por Meeko para conservarlas durante HMR. */
+export declare function isWritableSignal(value: unknown): value is Signal<unknown>;
+/** Crea un valor observable. Las escrituras iguales no notifican cambios. */
+export declare function signal<T>(initial: T): Signal<T>;
+/** Ejecuta una función cuando cambian las señales leídas por ella. */
+export declare function effect(fn: () => void): () => void;
+/** Deriva un valor de otras señales y lo actualiza cuando cambian. */
+export declare function computed<T>(fn: () => T): ReadonlySignal<T>;
+/** Agrupa varias escrituras en una sola ronda de notificaciones. */
+export declare function batch<T>(fn: () => T): T;
+/** Lee señales sin registrar dependencias en el observador activo. */
+export declare function untrack<T>(fn: () => T): T;
+/** Asocia efectos a una instancia y entrega una función para liberarlos. */
+export declare function createRoot<T>(fn: (dispose: () => void) => T): T;

package/dist/reactivity.js

@@ -0,0 +1,151 @@
+const writableSignals = new WeakSet();
+const derivedSignals = new WeakSet();
+/** Identifica señales editables creadas por Meeko para conservarlas durante HMR. */
+export function isWritableSignal(value) {
+    return typeof value === "object" && value !== null && writableSignals.has(value) && !derivedSignals.has(value);
+}
+let activeObserver;
+let activeOwner;
+let batchDepth = 0;
+let flushing = false;
+const pending = new Set();
+function detach(observer) {
+    for (const dependency of observer.dependencies)
+        dependency.subscribers.delete(observer);
+    observer.dependencies.clear();
+}
+function flush() {
+    if (flushing || batchDepth > 0)
+        return;
+    flushing = true;
+    try {
+        let iterations = 0;
+        while (pending.size > 0) {
+            if (++iterations > 1000)
+                throw new Error("Reactive update cycle exceeded 1000 iterations");
+            const observers = [...pending];
+            pending.clear();
+            for (const observer of observers)
+                if (!observer.disposed)
+                    observer.run();
+        }
+    }
+    finally {
+        flushing = false;
+    }
+}
+/** Crea un valor observable. Las escrituras iguales no notifican cambios. */
+export function signal(initial) {
+    let current = initial;
+    const subscribers = new Set();
+    const result = {
+        subscribers,
+        get value() {
+            if (activeObserver) {
+                subscribers.add(activeObserver);
+                activeObserver.dependencies.add(result);
+            }
+            return current;
+        },
+        set value(next) {
+            if (Object.is(current, next))
+                return;
+            current = next;
+            for (const observer of subscribers)
+                pending.add(observer);
+            flush();
+        },
+    };
+    writableSignals.add(result);
+    return result;
+}
+/** Ejecuta una función cuando cambian las señales leídas por ella. */
+export function effect(fn) {
+    const owner = activeOwner;
+    const observer = {
+        dependencies: new Set(),
+        disposed: false,
+        run() {
+            detach(observer);
+            const previous = activeObserver;
+            const previousOwner = activeOwner;
+            activeObserver = observer;
+            activeOwner = owner;
+            try {
+                fn();
+            }
+            finally {
+                activeObserver = previous;
+                activeOwner = previousOwner;
+            }
+        },
+    };
+    owner?.observers.add(observer);
+    observer.run();
+    return () => {
+        observer.disposed = true;
+        pending.delete(observer);
+        detach(observer);
+        owner?.observers.delete(observer);
+    };
+}
+/** Deriva un valor de otras señales y lo actualiza cuando cambian. */
+export function computed(fn) {
+    const result = signal(undefined);
+    derivedSignals.add(result);
+    effect(() => {
+        result.value = fn();
+    });
+    return result;
+}
+/** Agrupa varias escrituras en una sola ronda de notificaciones. */
+export function batch(fn) {
+    batchDepth++;
+    try {
+        return fn();
+    }
+    finally {
+        batchDepth--;
+        flush();
+    }
+}
+/** Lee señales sin registrar dependencias en el observador activo. */
+export function untrack(fn) {
+    const previous = activeObserver;
+    activeObserver = undefined;
+    try {
+        return fn();
+    }
+    finally {
+        activeObserver = previous;
+    }
+}
+/** Asocia efectos a una instancia y entrega una función para liberarlos. */
+export function createRoot(fn) {
+    const owner = { observers: new Set(), children: new Set(), parent: activeOwner };
+    const previous = activeOwner;
+    activeOwner = owner;
+    const dispose = () => {
+        for (const child of [...owner.children])
+            child();
+        owner.children.clear();
+        for (const observer of owner.observers) {
+            observer.disposed = true;
+            pending.delete(observer);
+            detach(observer);
+        }
+        owner.observers.clear();
+        owner.parent?.children.delete(dispose);
+    };
+    owner.parent?.children.add(dispose);
+    try {
+        return fn(dispose);
+    }
+    catch (error) {
+        dispose();
+        throw error;
+    }
+    finally {
+        activeOwner = previous;
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+/** Escapa texto dinámico antes de insertarlo en HTML generado por SSR. */
+export declare function escapeHtml(value: unknown): string;
+/** Convierte un valor de atributo dinámico en su forma DOM; null lo elimina. */
+export declare function attributeValue(name: string, value: unknown): string | null;
+/** Genera un atributo HTML dinámico con escape seguro para SSR. */
+export declare function renderAttribute(name: string, value: unknown): string;
+/** Serializa estado y props transferibles al navegador, rechazando valores ambiguos. */
+export declare function serializeJson(value: unknown): string;