@meekojs/meeko 0.0.0-stage → 0.0.2

package/dist/dom.d.ts

@@ -0,0 +1,43 @@
+import type { Signal } from "./reactivity.js";
+/** Fragmento de DOM que pertenece a una instancia o a una región dinámica. */
+export interface DomScope {
+    root: Element;
+    start?: Comment;
+    end?: Comment;
+}
+/** Contrato de un módulo de componente compilado para composición sin wrapper. */
+export interface ComponentModule<Props extends object> {
+    renderToString(props: Props, state?: Record<string, unknown>): string;
+    renderWithState?(props: Props): {
+        html: string;
+        state: Record<string, unknown>;
+    };
+    hydrateScope(scope: DomScope, props: Props, state?: Record<string, unknown>): ComponentRelease;
+}
+/** Función de limpieza que puede exponer el estado editable de su instancia. */
+export interface ComponentRelease {
+    (): void;
+    snapshot?: () => Record<string, unknown>;
+}
+/** Añade una lectura de estado a la limpieza de un componente compilado. */
+export declare function withStateSnapshot(release: () => void, snapshot: () => Record<string, unknown>): ComponentRelease;
+/** Renderiza un hijo entre comentarios de ámbito sin añadir un elemento visual. */
+export declare function renderComponent<Props extends object>(id: number, component: ComponentModule<Props>, props: Props, transferState?: boolean): string;
+/** Hidrata un hijo dentro de su rango y actualiza props reactivas con limpieza previa. */
+export declare function bindComponent<Props extends object>(scope: DomScope, id: number, component: ComponentModule<Props>, read: () => Props, location: string): () => void;
+/** Conecta un texto reactivo al marcador SSR y comprueba su valor inicial. */
+export declare function bindText(scope: DomScope, id: number, read: () => unknown, location: string): () => void;
+/** Conecta un atributo dinámico al elemento SSR y comprueba su valor inicial. */
+export declare function bindAttribute(scope: DomScope, id: number, name: string, read: () => unknown, location: string): () => void;
+/** Conecta un evento al elemento SSR y entrega su función de limpieza. */
+export declare function bindEvent(scope: DomScope, id: number, name: string, handler: (event: Event) => void): () => void;
+/** Genera los límites estables de una condición en SSR. */
+export declare function renderIf(id: number, condition: unknown, render: () => string): string;
+/** Hidrata una condición y conserva los nodos mientras sigue siendo verdadera. */
+export declare function bindIf(scope: DomScope, id: number, read: () => unknown, render: () => string, hydrate: (inner: DomScope) => () => void): () => void;
+/** Convierte una clave de lista en un token seguro para comentarios HTML. */
+export declare function keyToken(key: unknown): string;
+/** Renderiza una lista con límites identificados por claves únicas. */
+export declare function renderFor<T>(id: number, items: Iterable<T>, keyOf: (item: T, index: number) => string | number, render: (item: T, index: number) => string): string;
+/** Hidrata una lista y reordena regiones por clave sin reemplazar nodos conservados. */
+export declare function bindFor<T>(scope: DomScope, id: number, read: () => Iterable<T>, keyOf: (item: T, index: number) => string | number, render: (item: T, index: number) => string, hydrate: (item: Signal<T>, index: Signal<number>, inner: DomScope) => () => void): () => void;

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,9 @@
+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";
+export { registerDevtoolsInstance } from "./devtools.js";
+export type { DevtoolsEvent, DevtoolsHook, DevtoolsInstance, DevtoolsRegistration, DevtoolsSnapshot, DevtoolsValue } from "./devtools.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+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";
+export { registerDevtoolsInstance } from "./devtools.js";

package/dist/internal.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Contrato del runtime generado por el compilador Meeko.
+ *
+ * Esta ruta es interna y puede cambiar junto con el compilador. Las aplicaciones
+ * deben importar las API documentadas desde la raíz del paquete.
+ */
+export { createRoot } 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";
+export { registerDevtoolsInstance } from "./devtools.js";

package/dist/internal.js

@@ -0,0 +1,11 @@
+/**
+ * Contrato del runtime generado por el compilador Meeko.
+ *
+ * Esta ruta es interna y puede cambiar junto con el compilador. Las aplicaciones
+ * deben importar las API documentadas desde la raíz del paquete.
+ */
+export { createRoot } 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";
+export { registerDevtoolsInstance } from "./devtools.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;