elements-kit 0.18.2 → 0.20.0

package/dist/{lib-Dkc7cV5F.mjs → lib-DYypKhxk.mjs}

@@ -290,10 +290,10 @@ let activeSub;
 let activeOwner;
 /** Ring-buffer of effects waiting to be flushed. */
 const queued = [];
-const SIGNAL = Symbol("signal");
-const COMPUTED = Symbol("computed");
-const EFFECT = Symbol("effect");
-const EFFECT_SCOPE = Symbol("effectScope");
+const SIGNAL = Symbol.for("elements-kit.signal");
+const COMPUTED = Symbol.for("elements-kit.computed");
+const EFFECT = Symbol.for("elements-kit.effect");
+const EFFECT_SCOPE = Symbol.for("elements-kit.effectScope");
 const { link, unlink, propagate, checkDirty, shallowPropagate } = createReactiveSystem({
 	/**
 	* Called by the graph engine when a Mutable+Dirty node needs to recompute.
@@ -509,7 +509,65 @@ function computed(getter) {
 * stop();            // final cleanup: abort the last fetch
 * ```
 */
+/**
+* @internal Method key for settling a reactive async wrapper from a
+* serialized server snapshot (hydration seeding). Lives here so
+* `utilities/promise`, `utilities/async` and `hydrate` can share it without
+* a utility-to-utility dependency.
+*/
+const SEED = Symbol.for("elements-kit.seed");
+/**
+* @internal Method key for the hydrate claim protocol: the claim walk hands
+* each async wrapper its ek-data record (or undefined). The wrapper decides —
+* seed and discard any deferred run, or execute the deferred run now.
+*/
+const CLAIM = Symbol.for("elements-kit.claim");
+/**
+* @internal Brand stamped on dynamic-region getters that rendered as async
+* insertion points on the server (Await boundaries). The value carries
+* the number of ek-data ids the server consumed for the region and a
+* pending-probe — the hydrate walk advances its counter and keeps the
+* server content while the region is pending instead of flashing the
+* fallback.
+*/
+const ASYNC_REGION = Symbol.for("elements-kit.async-region");
+const MODE_STATE = Symbol.for("elements-kit.mode-state");
+const modeState = globalThis[MODE_STATE] ??= {
+	deferAsyncRuns: false,
+	inertEffects: false
+};
+/**
+* @internal While true (hydrate evaluation phase), `Async.run()` records
+* intent instead of executing — the claim walk or the post-walk flush decides
+* whether the fetcher actually runs. Returns the previous flag.
+*/
+function setDeferAsyncRuns(value) {
+	const prev = modeState.deferAsyncRuns;
+	modeState.deferAsyncRuns = value;
+	return prev;
+}
+/** @internal */
+function shouldDeferAsyncRuns() {
+	return modeState.deferAsyncRuns;
+}
+/** @internal True during server rendering (see {@link setInertEffects}). */
+function effectsInert() {
+	return modeState.inertEffects;
+}
+/**
+* Toggle inert-effect mode. While inert, `effect()` neither executes its body
+* nor tracks dependencies — it returns a no-op stop function. Used by the
+* server renderer: a server render is a one-shot snapshot, effects are
+* client-only. Returns the previous flag so callers can restore it.
+*/
+function setInertEffects(value) {
+	const prev = modeState.inertEffects;
+	modeState.inertEffects = value;
+	return prev;
+}
+const inertStop = () => {};
 function effect(fn) {
+	if (modeState.inertEffects) return inertStop;
 	const e = {
 		fn,
 		subs: void 0,
@@ -997,4 +1055,4 @@ function purgeDeps(sub) {
 	while (dep !== void 0) dep = unlink(dep, sub);
 }
 //#endregion
-export { batch as a, effectScope as c, isEffectScope as d, isSignal as f, untracked as g, trigger as h, SIGNAL as i, isComputed as l, signal as m, EFFECT as n, computed as o, onCleanup as p, EFFECT_SCOPE as r, effect as s, COMPUTED as t, isEffect as u };
+export { untracked as C, trigger as S, onCleanup as _, EFFECT_SCOPE as a, shouldDeferAsyncRuns as b, batch as c, effectScope as d, effectsInert as f, isSignal as g, isEffectScope as h, EFFECT as i, computed as l, isEffect as m, CLAIM as n, SEED as o, isComputed as p, COMPUTED as r, SIGNAL as s, ASYNC_REGION as t, effect as u, setDeferAsyncRuns as v, signal as x, setInertEffects as y };

package/dist/render.mjs

@@ -1,4 +1,4 @@
-import { t as scope } from "./scope-CnEvL9Nd.mjs";
+import { t as scope } from "./scope-zbEG299F.mjs";
 //#region src/render.ts
 /**
 * Mount a node into `target` with a scoped lifetime.

package/dist/{scope-CnEvL9Nd.mjs → scope-zbEG299F.mjs}

@@ -1,4 +1,4 @@
-import { c as effectScope, g as untracked } from "./lib-Dkc7cV5F.mjs";
+import { C as untracked, d as effectScope } from "./lib-DYypKhxk.mjs";
 //#region src/signals/scope.ts
 /**
 * Run `setup` inside a fresh `effectScope`. Returns `[result, stop]`.

package/dist/server/index.d.mts

@@ -0,0 +1,43 @@
+//#region src/server/index.d.ts
+/**
+ * Render a component tree to a streaming HTML response in any JavaScript
+ * runtime — no DOM required.
+ *
+ * Pass a thunk, not evaluated JSX: JSX evaluates eagerly, so the server
+ * renderer must be installed before the first jsx call runs.
+ *
+ * Streaming is in-order: all HTML preceding an async insertion point
+ * (`promise`/`async` reactive values used as children) flushes immediately;
+ * the stream then awaits the value and continues. Resolved values are
+ * serialized into a `<script type="application/json" id="ek-data">` tag at
+ * the end of the stream so the client hydration pass reuses them instead of
+ * refetching.
+ *
+ * Server semantics: signal/computed reads are a one-shot snapshot (no
+ * subscriptions), effects do not run, `on:` handlers and `ref` are skipped —
+ * interactivity attaches on the client via `elements-kit/hydrate`.
+ *
+ * Errors — including rejected async values — propagate and abort the stream.
+ *
+ * @example
+ * ```tsx
+ * export default {
+ *   fetch: () => new Response(renderToStream(() => <App />), {
+ *     headers: { "content-type": "text/html" },
+ *   }),
+ * };
+ * ```
+ */
+declare function renderToStream(app: () => unknown): ReadableStream<Uint8Array>;
+/**
+ * Render a component tree to a complete HTML string. Convenience wrapper
+ * around {@link renderToStream} — same semantics, buffered to one string.
+ *
+ * @example
+ * ```tsx
+ * const html = await renderToString(() => <App />);
+ * ```
+ */
+declare function renderToString(app: () => unknown): Promise<string>;
+//#endregion
+export { renderToStream, renderToString };

package/dist/server/index.mjs

@@ -0,0 +1,2 @@
+import { n as renderToString, t as renderToStream } from "../server-iFSng50i.mjs";
+export { renderToStream, renderToString };

package/dist/server-iFSng50i.mjs

@@ -0,0 +1,385 @@
+import { C as untracked, y as setInertEffects } from "./lib-DYypKhxk.mjs";
+import { isReactive, resolveProps } from "./signals/index.mjs";
+import { isReactivePromiseLike } from "./utilities/promise.mjs";
+import { isAsyncLike } from "./utilities/async.mjs";
+import { c as BooleanAttributes, l as ChildProperties, r as setRenderer, s as AttrAliases, u as Properties } from "./element-D3om9yA6.mjs";
+import { isForComponent } from "./for.mjs";
+import { n as isFragmentComponent } from "./fragment-ROPRBJQd.mjs";
+//#region src/server/escape.ts
+function escapeDelim(s, delim, escDelim) {
+	let iDelim = s.indexOf(delim);
+	let iAmp = s.indexOf("&");
+	if (iDelim < 0 && iAmp < 0) return s;
+	let left = 0;
+	let out = "";
+	while (iDelim >= 0 && iAmp >= 0) if (iDelim < iAmp) {
+		if (left < iDelim) out += s.substring(left, iDelim);
+		out += escDelim;
+		left = iDelim + 1;
+		iDelim = s.indexOf(delim, left);
+	} else {
+		if (left < iAmp) out += s.substring(left, iAmp);
+		out += "&amp;";
+		left = iAmp + 1;
+		iAmp = s.indexOf("&", left);
+	}
+	if (iDelim >= 0) do {
+		if (left < iDelim) out += s.substring(left, iDelim);
+		out += escDelim;
+		left = iDelim + 1;
+		iDelim = s.indexOf(delim, left);
+	} while (iDelim >= 0);
+	else while (iAmp >= 0) {
+		if (left < iAmp) out += s.substring(left, iAmp);
+		out += "&amp;";
+		left = iAmp + 1;
+		iAmp = s.indexOf("&", left);
+	}
+	return left < s.length ? out + s.substring(left) : out;
+}
+/** Escape a text node. */
+function escapeHtml(value) {
+	return escapeDelim(value, "<", "&lt;");
+}
+/** Escape a double-quoted attribute value. */
+function escapeAttr(value) {
+	return escapeDelim(value, "\"", "&quot;");
+}
+/** Neutralize `<\/script>` sequences inside an inline JSON script payload. */
+function escapeScriptJson(json) {
+	return json.replace(/<\//g, "<\\/");
+}
+//#endregion
+//#region src/server/jsx.ts
+/**
+* Server output node. Nested jsx calls return `SNode`s so the children walk
+* can distinguish pre-rendered markup (spliced verbatim) from user strings
+* (escaped).
+*/
+var SNode = class {
+	chunks;
+	constructor(chunks) {
+		this.chunks = chunks;
+	}
+};
+/**
+* An async insertion point. The stream awaits it in document order and
+* assigns its serialization id at emit time — ids must follow document
+* order (not jsx-evaluation order, which is children-first) so the hydrate
+* walk, which runs in document order, aligns with them.
+*/
+var AsyncChunk = class {
+	instance;
+	constructor(instance) {
+		this.instance = instance;
+	}
+};
+/** Normalize an arbitrary resolved value into chunks (used by the stream). */
+function resolveChildChunks(value) {
+	return child(value);
+}
+const SLOT_OPEN = "<!--{-->";
+const SLOT_CLOSE = "<!--}-->";
+const FOR_OPEN = "<!--<For>-->";
+const FOR_CLOSE = "<!--</For>-->";
+const VoidElements = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+const PropertyAttrAliases = {
+	className: "class",
+	defaultValue: "value",
+	defaultChecked: "checked",
+	defaultSelected: "selected",
+	defaultMuted: "muted",
+	indeterminate: null
+};
+function serverJsx(type, props) {
+	if (typeof type === "string") return element(type, props);
+	if (isFragmentComponent(type)) {
+		if (props.html) {
+			const source = props.children;
+			const value = typeof source === "function" ? untracked(source) : source;
+			return new SNode([
+				SLOT_OPEN,
+				value == null ? "" : String(value),
+				SLOT_CLOSE
+			]);
+		}
+		return new SNode(childList(props.children));
+	}
+	if (isForComponent(type)) return forElement(props);
+	if (typeof type === "function" && !type.prototype?.render) return new SNode(child(type(resolveProps(props))));
+	const name = typeof type === "function" ? type.name ?? "anonymous" : String(type);
+	throw new Error(`Server rendering does not support class components ("${name}"); v1 supports intrinsic elements, function components, Fragment and For.`);
+}
+function element(tag, props) {
+	let attrs = "";
+	let classBase;
+	const classToggles = [];
+	let styleBase;
+	const styleEntries = [];
+	let childrenValue;
+	let textValue;
+	for (const [key, rawValue] of Object.entries(props)) {
+		if (key === "children") {
+			childrenValue = rawValue;
+			continue;
+		}
+		if (key === "ref") continue;
+		const colonIdx = key.indexOf(":");
+		const ns = colonIdx > 0 ? key.slice(0, colonIdx) : "";
+		if (ns === "on") continue;
+		const value = isReactive(rawValue) ? untracked(rawValue) : rawValue;
+		if (ns) {
+			const name = key.slice(colonIdx + 1);
+			if (ns === "prop") continue;
+			if (ns === "class") {
+				if (value) classToggles.push(name);
+				continue;
+			}
+			if (ns === "style") {
+				if (value != null && value !== false) styleEntries.push(`${name}:${String(value)}`);
+				continue;
+			}
+			if (ns === "xlink" || ns === "xml") {
+				attrs += attr(key, value);
+				continue;
+			}
+		}
+		if (key === "class") {
+			classBase = value == null ? void 0 : String(value);
+			continue;
+		}
+		if (key === "style") {
+			styleBase = styleToString(value);
+			continue;
+		}
+		if (ChildProperties.has(key)) {
+			if (key === "innerHTML") throw new Error("innerHTML is not supported in server rendering — there is no raw HTML sink.");
+			textValue = value;
+			continue;
+		}
+		if (Properties.has(key)) {
+			const alias = PropertyAttrAliases[key];
+			if (alias === null) continue;
+			if (alias === "class") {
+				classBase = value == null ? void 0 : String(value);
+				continue;
+			}
+			attrs += attr(alias ?? key.toLowerCase(), value);
+			continue;
+		}
+		attrs += attr(AttrAliases[key] ?? key, value);
+	}
+	const classes = [...classBase !== void 0 && classBase !== "" ? [classBase] : [], ...classToggles];
+	if (classBase !== void 0 || classToggles.length > 0) attrs += attr("class", classes.join(" "));
+	const styles = [...styleBase ? [styleBase] : [], ...styleEntries];
+	if (styles.length > 0) attrs += attr("style", styles.join(";"));
+	const open = `<${tag}${attrs}>`;
+	if (VoidElements.has(tag)) return new SNode([open]);
+	return new SNode([
+		open,
+		...textValue != null ? [escapeHtml(String(textValue))] : childList(childrenValue),
+		`</${tag}>`
+	]);
+}
+function attr(name, value) {
+	if (BooleanAttributes.has(name)) return value ? ` ${name}` : "";
+	if (value == null || value === false) return "";
+	if (value === true || value === "") return ` ${name}`;
+	return ` ${name}="${escapeAttr(String(value))}"`;
+}
+function styleToString(value) {
+	if (value == null || value === false) return void 0;
+	if (typeof value === "string") return value;
+	if (typeof value === "object") return Object.entries(value).filter(([, v]) => v != null && v !== false).map(([k, v]) => `${k.includes("-") ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)}:${String(v)}`).join(";");
+	return String(value);
+}
+function childList(raw) {
+	if (raw == null) return [];
+	if (Array.isArray(raw)) return raw.flat(Infinity).flatMap(child);
+	return child(raw);
+}
+function child(c) {
+	if (c == null || typeof c === "boolean") return [];
+	if (c instanceof SNode) return [c];
+	if (isReactivePromiseLike(c) || isAsyncLike(c)) return asyncChild(c);
+	if (typeof c === "function") return [
+		SLOT_OPEN,
+		...child(untracked(c)),
+		SLOT_CLOSE
+	];
+	if (typeof c === "string") return [escapeHtml(c)];
+	if (typeof c === "number" || typeof c === "bigint") return [String(c)];
+	if (Array.isArray(c)) return c.flat(Infinity).flatMap(child);
+	return [escapeHtml(String(c))];
+}
+function asyncChild(p) {
+	return [
+		SLOT_OPEN,
+		new AsyncChunk(p),
+		SLOT_CLOSE
+	];
+}
+function forElement(props) {
+	const each = props.each;
+	const items = untracked(() => typeof each === "function" ? each() : each);
+	const by = props.by ?? ((_item, index) => index);
+	const render = props.children;
+	const chunks = [FOR_OPEN];
+	(items ?? []).forEach((item, index) => {
+		const key = encodeURIComponent(String(by(item, index)));
+		chunks.push(`<!--[${key}]-->`, ...child(render(item, index)), `<!--[/${key}]-->`);
+	});
+	chunks.push(FOR_CLOSE);
+	return new SNode(chunks);
+}
+//#endregion
+//#region src/server/index.ts
+/**
+* Render a component tree to a streaming HTML response in any JavaScript
+* runtime — no DOM required.
+*
+* Pass a thunk, not evaluated JSX: JSX evaluates eagerly, so the server
+* renderer must be installed before the first jsx call runs.
+*
+* Streaming is in-order: all HTML preceding an async insertion point
+* (`promise`/`async` reactive values used as children) flushes immediately;
+* the stream then awaits the value and continues. Resolved values are
+* serialized into a `<script type="application/json" id="ek-data">` tag at
+* the end of the stream so the client hydration pass reuses them instead of
+* refetching.
+*
+* Server semantics: signal/computed reads are a one-shot snapshot (no
+* subscriptions), effects do not run, `on:` handlers and `ref` are skipped —
+* interactivity attaches on the client via `elements-kit/hydrate`.
+*
+* Errors — including rejected async values — propagate and abort the stream.
+*
+* @example
+* ```tsx
+* export default {
+*   fetch: () => new Response(renderToStream(() => <App />), {
+*     headers: { "content-type": "text/html" },
+*   }),
+* };
+* ```
+*/
+function renderToStream(app) {
+	const encoder = new TextEncoder();
+	return new ReadableStream({ async start(controller) {
+		try {
+			const ctx = {
+				records: [],
+				counter: 0
+			};
+			const root = evaluate(app);
+			let buffer = "";
+			const flush = () => {
+				if (buffer.length === 0) return;
+				controller.enqueue(encoder.encode(buffer));
+				buffer = "";
+			};
+			const emit = async (node) => {
+				if (node == null || typeof node === "boolean") return;
+				if (typeof node === "string") {
+					buffer += node;
+					return;
+				}
+				if (node instanceof SNode) {
+					for (const chunk of node.chunks) await emit(chunk);
+					return;
+				}
+				if (node instanceof AsyncChunk) {
+					flush();
+					const id = ctx.counter++;
+					const value = await node.instance;
+					ctx.records.push({
+						id,
+						value
+					});
+					const prevInert = setInertEffects(true);
+					setRenderer({ jsx: serverJsx });
+					let chunks;
+					try {
+						chunks = resolveChildChunks(value);
+					} finally {
+						setRenderer(null);
+						setInertEffects(prevInert);
+					}
+					for (const chunk of chunks) await emit(chunk);
+					return;
+				}
+				buffer += String(node);
+			};
+			await emit(root);
+			if (ctx.records.length > 0) buffer += serializeRecords(ctx.records);
+			flush();
+			controller.close();
+		} catch (error) {
+			controller.error(error);
+		}
+	} });
+}
+/**
+* Render a component tree to a complete HTML string. Convenience wrapper
+* around {@link renderToStream} — same semantics, buffered to one string.
+*
+* @example
+* ```tsx
+* const html = await renderToString(() => <App />);
+* ```
+*/
+async function renderToString(app) {
+	const reader = renderToStream(app).getReader();
+	const decoder = new TextDecoder();
+	let out = "";
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		out += decoder.decode(value, { stream: true });
+	}
+	return out;
+}
+/** Run `app` with the server renderer installed and effects inert. */
+function evaluate(app) {
+	const prevInert = setInertEffects(true);
+	setRenderer({ jsx: serverJsx });
+	try {
+		return app();
+	} finally {
+		setRenderer(null);
+		setInertEffects(prevInert);
+	}
+}
+function serializeRecords(records) {
+	const parts = [];
+	for (const record of records) {
+		if (typeof record.value === "function") continue;
+		let json;
+		try {
+			json = JSON.stringify({ value: record.value });
+		} catch {
+			continue;
+		}
+		if (json === void 0) continue;
+		parts.push(`"${record.id}":${json}`);
+	}
+	if (parts.length === 0) return "";
+	return `<script type="application/json" id="ek-data">${escapeScriptJson(`{${parts.join(",")}}`)}<\/script>`;
+}
+//#endregion
+export { serverJsx as i, renderToString as n, SNode as r, renderToStream as t };

package/dist/signals/index.d.mts

@@ -1,2 +1,2 @@
-import { A as SIGNAL, B as signal, C as isReactive, D as COMPUTED, E as resolveProps, F as isComputed, H as untracked, I as isEffect, L as isEffectScope, M as computed, N as effect, O as EFFECT, P as effectScope, R as isSignal, S as Updater, T as resolve, V as trigger, b as MaybeReactive, j as batch, k as EFFECT_SCOPE, w as reactive, x as Signal, y as Computed, z as onCleanup } from "../infer-B7T5hi_D.mjs";
-export { COMPUTED, Computed, EFFECT, EFFECT_SCOPE, MaybeReactive, SIGNAL, Signal, Updater, batch, computed, effect, effectScope, isComputed, isEffect, isEffectScope, isReactive, isSignal, onCleanup, reactive, resolve, resolveProps, signal, trigger, untracked };
+import { A as EFFECT_SCOPE, B as isSignal, C as isReactive, D as CLAIM, E as resolveProps, F as effect, H as signal, I as effectScope, L as isComputed, M as SIGNAL, N as batch, O as COMPUTED, P as computed, R as isEffect, S as Updater, T as resolve, U as trigger, V as onCleanup, W as untracked, b as MaybeReactive, j as SEED, k as EFFECT, w as reactive, x as Signal, y as Computed, z as isEffectScope } from "../types-ncUK9rki.mjs";
+export { CLAIM, COMPUTED, Computed, EFFECT, EFFECT_SCOPE, MaybeReactive, SEED, SIGNAL, Signal, Updater, batch, computed, effect, effectScope, isComputed, isEffect, isEffectScope, isReactive, isSignal, onCleanup, reactive, resolve, resolveProps, signal, trigger, untracked };

package/dist/signals/index.mjs

@@ -1,4 +1,4 @@
-import { a as batch, c as effectScope, d as isEffectScope, f as isSignal, g as untracked, h as trigger, i as SIGNAL, l as isComputed, m as signal, n as EFFECT, o as computed, p as onCleanup, r as EFFECT_SCOPE, s as effect, t as COMPUTED, u as isEffect } from "../lib-Dkc7cV5F.mjs";
+import { C as untracked, S as trigger, _ as onCleanup, a as EFFECT_SCOPE, c as batch, d as effectScope, g as isSignal, h as isEffectScope, i as EFFECT, l as computed, m as isEffect, n as CLAIM, o as SEED, p as isComputed, r as COMPUTED, s as SIGNAL, u as effect, x as signal } from "../lib-DYypKhxk.mjs";
 import "../polyfill-CdZVCxdo.mjs";
 //#region src/signals/index.ts
 /**
@@ -108,7 +108,9 @@ function resolve(value) {
 * props.label();   // "n"
 * ```
 */
+const RESOLVED_PROPS = Symbol.for("elements-kit.resolved-props");
 function resolveProps(raw) {
+	if (raw[RESOLVED_PROPS]) return raw;
 	const ownKeys = Reflect.ownKeys(raw);
 	const ownKeySet = new Set(ownKeys);
 	const cache = /* @__PURE__ */ new Map();
@@ -122,7 +124,7 @@ function resolveProps(raw) {
 		return getter;
 	};
 	return new Proxy(raw, {
-		get: (_target, key) => get(key),
+		get: (_target, key) => key === RESOLVED_PROPS ? true : get(key),
 		has: (_target, key) => ownKeySet.has(key),
 		ownKeys: () => ownKeys,
 		getOwnPropertyDescriptor: (_target, key) => ownKeySet.has(key) ? {
@@ -134,4 +136,4 @@ function resolveProps(raw) {
 	});
 }
 //#endregion
-export { COMPUTED, EFFECT, EFFECT_SCOPE, SIGNAL, batch, computed, effect, effectScope, isComputed, isEffect, isEffectScope, isReactive, isSignal, onCleanup, reactive, resolve, resolveProps, signal, trigger, untracked };
+export { CLAIM, COMPUTED, EFFECT, EFFECT_SCOPE, SEED, SIGNAL, batch, computed, effect, effectScope, isComputed, isEffect, isEffectScope, isReactive, isSignal, onCleanup, reactive, resolve, resolveProps, signal, trigger, untracked };

package/dist/{slot-B8y0aEoz.d.mts → slot-BFWXeFRl.d.mts}

@@ -18,6 +18,12 @@ declare global {
  */
 declare class Slot {
   #private;
+  /**
+   * Bind a slot to an existing marker pair (server-rendered comments) instead
+   * of creating new ones. Used by the hydrate claim pass: content between the
+   * markers is adopted as the slot's current content.
+   */
+  static claim(start: Comment, end: Comment): Slot;
   /**
    * Render the slot as a DocumentFragment.
    * If not yet mounted, inserts the comment markers and optional default content.

package/dist/{slot-Cne__au7.mjs → slot-Dvf30O0B.mjs}

@@ -18,11 +18,22 @@ function resolveNode(c) {
 * A lightweight slot that reserves a region in the DOM using comment markers.
 * Content between the markers can be replaced dynamically without wrapper elements.
 */
-var Slot = class {
+var Slot = class Slot {
 	#start;
 	#end;
 	#pending;
 	/**
+	* Bind a slot to an existing marker pair (server-rendered comments) instead
+	* of creating new ones. Used by the hydrate claim pass: content between the
+	* markers is adopted as the slot's current content.
+	*/
+	static claim(start, end) {
+		const slot = new Slot();
+		slot.#start = start;
+		slot.#end = end;
+		return slot;
+	}
+	/**
 	* Render the slot as a DocumentFragment.
 	* If not yet mounted, inserts the comment markers and optional default content.
 	* If already mounted, extracts and returns the current content WITHOUT disposing

package/dist/slot.d.mts

@@ -1,2 +1,2 @@
-import { n as Slot, t as SLOTS } from "./slot-B8y0aEoz.mjs";
+import { n as Slot, t as SLOTS } from "./slot-BFWXeFRl.mjs";
 export { SLOTS, Slot };

package/dist/slot.mjs

@@ -1,2 +1,2 @@
-import { n as Slot, t as SLOTS } from "./slot-Cne__au7.mjs";
+import { n as Slot, t as SLOTS } from "./slot-Dvf30O0B.mjs";
 export { SLOTS, Slot };