@farm.js/islx 0.0.3 → 0.0.5

package/dist/react/client.mjs

@@ -1,8 +1,9 @@
-import { a as emit, l as getValueStore, t as createServerReference, u as valueHeaders } from "../_chunks/actions-2sTj0A2T.mjs";
-import { i as decodeTagged, n as NOT_A_VALUE, r as decode, u as setOwn } from "../_chunks/codec-DqfVYKsx.mjs";
-import { N as getTag, S as SLOT_ELEMENT, f as FORM_STATE_SCRIPT_TYPE, h as ISLAND_ELEMENT, m as HYDRATED_ATTRIBUTE, y as PROPS_SCRIPT_TYPE } from "../_chunks/wire-CXOodE06.mjs";
-import { d as isolateIslands, h as withinClientRoot, i as createServerTreeLayout, n as PAYLOAD_ONLY_ATTRIBUTE, o as updateServerTrees, r as createServerTreeElement, u as getContexts } from "../_chunks/tree-BvYR6-PF.mjs";
-import { n as isIslandStrategy, r as scheduleHydration, t as ISLAND_STRATEGIES } from "../_chunks/schedule-BFoGKRrU.mjs";
+import { a as emit, l as getValueStore, t as createServerReference, u as valueHeaders } from "../_chunks/actions-8RQfrM-p.mjs";
+import { i as decodeTagged, n as NOT_A_VALUE, r as decode, u as setOwn } from "../_chunks/codec-C8to-RQW.mjs";
+import { F as getTag, f as FORM_STATE_SCRIPT_TYPE, h as ISLAND_ELEMENT, m as HYDRATED_ATTRIBUTE, w as SLOT_ELEMENT, x as PROPS_SCRIPT_TYPE, y as PROMISE_SCRIPT_TYPE } from "../_chunks/wire-QEQWBr5s.mjs";
+import { i as getContexts, o as isolateIslands, u as withinClientRoot } from "../_chunks/island-DVOr-OUw.mjs";
+import { i as createServerTreeLayout, n as PAYLOAD_ONLY_ATTRIBUTE, o as updateServerTrees, r as createServerTreeElement } from "../_chunks/tree-BUkGP4AR.mjs";
+import { n as isIslandStrategy, r as scheduleHydration, t as ISLAND_STRATEGIES } from "../_chunks/schedule-CjoybS3b.mjs";
 import * as React from "react";
 import { hydrateRoot } from "react-dom/client";
 // src/react/hydrate.ts
@@ -39,22 +40,22 @@ function readFormState(document) {
 const revivedValues = /* @__PURE__ */ new WeakMap();
 let slotsRevived = 0;
 /** Turns travelled props back into values: slots keep their server HTML, actions become callable. */
-function revive(value, container) {
+function revive(value, container, values) {
 	if (value && typeof value === "object") {
 		const cached = revivedValues.get(value);
 		if (cached !== void 0) return cached;
 		const slotsBefore = slotsRevived;
-		const revived = reviveUncached(value, container);
+		const revived = reviveUncached(value, container, values);
 		if (slotsRevived === slotsBefore) revivedValues.set(value, revived);
 		return revived;
 	}
 	return value;
 }
-function reviveUncached(value, container) {
+function reviveUncached(value, container, values) {
 	if (Array.isArray(value)) {
 		let changed = false;
 		const revived = value.map((entry) => {
-			const next = revive(entry, container);
+			const next = revive(entry, container, values);
 			if (next !== entry) changed = true;
 			return next;
 		});
@@ -82,25 +83,152 @@ function reviveUncached(value, container) {
 			dangerouslySetInnerHTML: { __html: html }
 		});
 	}
+	if (tag === "T" && typeof object["v"] === "string") return islandPromise(object["v"], container, values);
 	if (tag === "r") throw new Error(`islx value ${String(object["v"])} was not resolved`);
 	if (tag !== void 0) {
-		const decoded = decodeTagged(object, (child) => revive(child, container));
+		const decoded = decodeTagged(object, (child) => revive(child, container, values));
 		if (decoded !== NOT_A_VALUE) return decoded;
 	}
 	let changed = false;
 	const revived = {};
 	for (const [key, entry] of Object.entries(object)) {
-		const next = revive(entry, container);
+		const next = revive(entry, container, values);
 		setOwn(revived, key, next);
 		if (next !== entry) changed = true;
 	}
 	return changed ? revived : value;
 }
+const pendingPromises = /* @__PURE__ */ new Map();
+let promiseObserver = null;
+function findPromiseScript(container, name) {
+	const documents = new Set([container.ownerDocument, globalThis.document].filter(Boolean));
+	for (const document of documents) for (const script of document.querySelectorAll(`script[type="${PROMISE_SCRIPT_TYPE}"]`)) if (script.getAttribute("name") === name) return script;
+	return null;
+}
+function readOutcome(script, container, values) {
+	try {
+		const text = script.textContent || "{}";
+		let parsed = JSON.parse(text);
+		if (!parsed || typeof parsed !== "object" || !("v" in parsed)) return {
+			ok: false,
+			reason: /* @__PURE__ */ new Error("islx: the promise rejected on the server")
+		};
+		if (text.includes(`"\$":"r"`)) {
+			values.ingest(container.ownerDocument);
+			parsed = values.resolve(parsed);
+		}
+		return {
+			ok: true,
+			value: revive(parsed, container, values).v
+		};
+	} catch (reason) {
+		return {
+			ok: false,
+			reason
+		};
+	}
+}
+/**
+* The promise an island received, as a thenable React's `use` reads: settled already when its
+* outcome is on the page, so hydration does not suspend, and settled when the outcome streams in
+* otherwise.
+*/
+function islandPromise(name, container, values) {
+	const pending = pendingPromises.get(name);
+	if (pending) return pending.thenable;
+	const script = findPromiseScript(container, name);
+	if (script) {
+		const outcome = readOutcome(script, container, values);
+		const thenable = outcome.ok ? Promise.resolve(outcome.value) : Promise.reject(outcome.reason);
+		if (outcome.ok) Object.assign(thenable, {
+			status: "fulfilled",
+			value: outcome.value
+		});
+		else {
+			thenable.catch(() => {});
+			Object.assign(thenable, {
+				status: "rejected",
+				reason: outcome.reason
+			});
+		}
+		return thenable;
+	}
+	let resolve;
+	let reject;
+	const thenable = new Promise((done, fail) => {
+		resolve = done;
+		reject = fail;
+	});
+	thenable.catch(() => {});
+	thenable.status = "pending";
+	pendingPromises.set(name, {
+		thenable,
+		container,
+		values,
+		settle(found) {
+			pendingPromises.delete(name);
+			const outcome = readOutcome(found, container, values);
+			if (outcome.ok) {
+				Object.assign(thenable, {
+					status: "fulfilled",
+					value: outcome.value
+				});
+				resolve(outcome.value);
+			} else {
+				Object.assign(thenable, {
+					status: "rejected",
+					reason: outcome.reason
+				});
+				reject(outcome.reason);
+			}
+		}
+	});
+	if (!promiseObserver && typeof MutationObserver === "function") {
+		promiseObserver = new MutationObserver(() => {
+			for (const [pendingName, entry] of pendingPromises) {
+				const found = findPromiseScript(entry.container, pendingName);
+				if (found) entry.settle(found);
+			}
+			if (pendingPromises.size === 0) {
+				promiseObserver?.disconnect();
+				promiseObserver = null;
+			}
+		});
+		promiseObserver.observe(globalThis.document ?? container.ownerDocument, {
+			childList: true,
+			subtree: true
+		});
+	}
+	return thenable;
+}
 /**
 * React streams Suspense content that resolves late into a hidden `<div id="S:n">`, then moves it
 * into place. Its islands hydrate once moved, not while staged.
 */
 const STREAM_STAGING = "div[hidden][id^=\"S:\"]";
+const PENDING_BOUNDARY = "$?";
+/**
+* Whether React still streams Suspense content into `container`. React waits for such a boundary
+* only while the document loads; later (a navigation that streams) it would render it again in
+* the browser, so the island hydrates once React has revealed it.
+*/
+function awaitsStreamedContent(container) {
+	const document = container.ownerDocument;
+	if (document.readyState === "loading") return false;
+	const walker = document.createTreeWalker(container, NodeFilter.SHOW_COMMENT);
+	for (let node = walker.nextNode(); node; node = walker.nextNode()) if (node.data === PENDING_BOUNDARY) return true;
+	return false;
+}
+/**
+* Marks the Suspense boundaries under `root` that still wait once their stream has ended (the
+* connection dropped) as rendered in the browser, as React does when it finds one: the next
+* `hydrate()` pass starts their islands. Call it when a stream that filled `root` ends.
+*/
+function endStreamedContent(root) {
+	const node = root;
+	const walker = (node.nodeType === 9 ? node : node.ownerDocument).createTreeWalker(node, NodeFilter.SHOW_COMMENT);
+	for (let comment = walker.nextNode(); comment; comment = walker.nextNode()) if (comment.data === PENDING_BOUNDARY) comment.data = "$!";
+}
 /** The hydration runtime for one page. */
 function createHydrationRuntime(options) {
 	const roots = /* @__PURE__ */ new Map();
@@ -169,7 +297,7 @@ function createHydrationRuntime(options) {
 			values.ingest(container.ownerDocument);
 			parsed = values.resolve(parsed);
 		}
-		return revive(parsed, container);
+		return revive(parsed, container, values);
 	}
 	const topLevel = (scope) => Array.from(scope.querySelectorAll(ISLAND_SELECTOR)).filter((container) => !container.parentElement?.closest(ISLAND_SELECTOR));
 	const keyOf = (container) => `${container.getAttribute("src")}#${container.getAttribute("export") || "default"}`;
@@ -182,7 +310,7 @@ function createHydrationRuntime(options) {
 		if (scope instanceof Document) watchStream(scope);
 		const candidates = Array.from(scope.querySelectorAll(ISLAND_SELECTOR));
 		if (scope instanceof Element && scope.matches(ISLAND_SELECTOR)) candidates.unshift(scope);
-		const islands = candidates.filter((container) => !roots.has(container) && !pending.has(container) && !container.parentElement?.closest(ISLAND_SELECTOR) && !container.closest(STREAM_STAGING));
+		const islands = candidates.filter((container) => !roots.has(container) && !pending.has(container) && !container.parentElement?.closest(ISLAND_SELECTOR) && !container.closest(STREAM_STAGING) && !awaitsStreamedContent(container));
 		await Promise.all(islands.map(async (container) => {
 			const src = container.getAttribute("src");
 			const id = container.getAttribute("props");
@@ -350,6 +478,7 @@ function createHydrationRuntime(options) {
 			if (document.readyState !== "loading" && !document.querySelector(STREAM_STAGING)) {
 				observer.disconnect();
 				watching = false;
+				endStreamedContent(document);
 			}
 			hydrate(document).catch((error) => report("Hydrating streamed islands failed.", error));
 		};
@@ -366,6 +495,11 @@ function createHydrationRuntime(options) {
 		document.addEventListener("DOMContentLoaded", run, { once: true });
 	}
 	function dispose(scope) {
+		for (const [name, entry] of pendingPromises) if (scope.contains(entry.container)) pendingPromises.delete(name);
+		if (pendingPromises.size === 0) {
+			promiseObserver?.disconnect();
+			promiseObserver = null;
+		}
 		for (const [container, controller] of pending) if (container === scope || scope.contains(container)) {
 			controller.abort();
 			pending.delete(container);
@@ -453,4 +587,4 @@ async function swapDocument(runtime, next) {
 	document.body.replaceChildren(...Array.from(body.childNodes));
 	await runtime.hydrate(document);
 }
-export { HYDRATED_ATTRIBUTE, ISLAND_STRATEGIES, PAYLOAD_ONLY_ATTRIBUTE, createHydrationRuntime, createServerHtml, createServerTreeElement, createServerTreeLayout, isIslandStrategy, isolateIslands, refreshDocument, scheduleHydration, swapDocument, updateServerTrees, withinClientRoot };
+export { HYDRATED_ATTRIBUTE, ISLAND_STRATEGIES, PAYLOAD_ONLY_ATTRIBUTE, createHydrationRuntime, createServerHtml, createServerTreeElement, createServerTreeLayout, endStreamedContent, isIslandStrategy, isolateIslands, refreshDocument, scheduleHydration, swapDocument, updateServerTrees, withinClientRoot };

package/dist/react/server.mjs

@@ -1,19 +1,38 @@
-import { a as encode } from "../_chunks/codec-DqfVYKsx.mjs";
-import { f as FORM_STATE_SCRIPT_TYPE } from "../_chunks/wire-CXOodE06.mjs";
+import { a as encode } from "../_chunks/codec-C8to-RQW.mjs";
+import { f as FORM_STATE_SCRIPT_TYPE } from "../_chunks/wire-QEQWBr5s.mjs";
 import { r as PREHYDRATION_SCRIPT } from "../_chunks/prehydration-B1GLTLdk.mjs";
-import { g as escapeScriptJson, h as addressValues, i as encodeActionReference, v as parseHeldValues, y as selectValuesToSend } from "../_chunks/actions-B8dJ8f7L.mjs";
+import { i as encodeActionReference } from "../_chunks/actions-BuS5jDi0.mjs";
 import { t as getBuildDefaults } from "../_chunks/build-COIcs7wm.mjs";
-import { a as renderServerTree, c as createIsland, d as isolateIslands, f as runtimeTagged, h as withinClientRoot, l as getClientReference, m as setRenderStateResolver, n as PAYLOAD_ONLY_ATTRIBUTE, p as setIslandServerHook, s as IslandsProvider, t as Outlet, u as getContexts } from "../_chunks/tree-BvYR6-PF.mjs";
+import { a as parseHeldValues, n as addressValues, o as selectValuesToSend, r as escapeScriptJson } from "../_chunks/values-37UIzxM0.mjs";
+import { c as setIslandServerHook, i as getContexts, l as setRenderStateResolver, n as createIsland, o as isolateIslands, r as getClientReference, s as runtimeTagged, t as IslandsProvider, u as withinClientRoot } from "../_chunks/island-DVOr-OUw.mjs";
+import { a as renderServerTree, n as PAYLOAD_ONLY_ATTRIBUTE, t as Outlet } from "../_chunks/tree-BUkGP4AR.mjs";
 import * as React from "react";
 // src/react/server.ts
 /**
 * @farm.js/islx/react/server: rendering a React page with islands. Importing it gives islands the
 * server code they need (values, action references); `renderToStream` renders a page.
 */
+const PROMISE_PREFIX = `${Array.from(crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(2)), (part) => part.toString(36)).join("")}.`;
+let promiseCount = 0;
+function isThenable(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
 setIslandServerHook({
 	encode(props, held) {
+		const promises = [];
 		const addressed = addressValues(props, { encodeSpecial: (value) => {
 			if (value && typeof value === "object" && runtimeTagged.has(value)) return value;
+			if (isThenable(value)) {
+				const name = PROMISE_PREFIX + (promiseCount++).toString(36);
+				promises.push({
+					name,
+					promise: value
+				});
+				return {
+					["$"]: "T",
+					["v"]: name
+				};
+			}
 			if (typeof value === "function") {
 				const reference = encodeActionReference(value);
 				if (reference) return reference;
@@ -26,7 +45,8 @@ setIslandServerHook({
 			values: selectValuesToSend(addressed, held).map(({ key, json }) => ({
 				key,
 				json
-			}))
+			})),
+			promises
 		};
 	},
 	escape: escapeScriptJson,

package/dist/react.mjs

@@ -1 +1,3 @@
-export { s as IslandsProvider, t as Outlet, c as createIsland, d as isolateIslands, a as renderServerTree, h as withinClientRoot } from "./_chunks/tree-BvYR6-PF.mjs";
+import { n as createIsland, o as isolateIslands, t as IslandsProvider, u as withinClientRoot } from "./_chunks/island-DVOr-OUw.mjs";
+import { a as renderServerTree, t as Outlet } from "./_chunks/tree-BUkGP4AR.mjs";
+export { IslandsProvider, Outlet, createIsland, isolateIslands, renderServerTree, withinClientRoot };

package/dist/server.mjs

@@ -1,6 +1,7 @@
-import { _ as hashValue, a as getActionReference, c as resolveAction, d as generateActionKey, f as sealBound, g as escapeScriptJson, h as addressValues, i as encodeActionReference, l as SealError, m as VALUE_MIN_LENGTH, n as configureActionKeys, o as registerInlineAction, p as unsealBound, r as decodeActionReference, s as registerServerReference, t as bindInlineAction, u as createActionKeys, v as parseHeldValues, y as selectValuesToSend } from "./_chunks/actions-B8dJ8f7L.mjs";
-import { a as encode, r as decode } from "./_chunks/codec-DqfVYKsx.mjs";
-import { F as stripRuntimeFields, P as readPostedAction, j as attachmentField, n as ACTION_KEY_FIELD, o as BOUND_FIELD, r as ACTION_STALE_HEADER, s as CALL_FIELD, t as ACTION_HEADER } from "./_chunks/wire-CXOodE06.mjs";
+import { a as parseHeldValues, i as hashValue, n as addressValues, o as selectValuesToSend, r as escapeScriptJson, t as VALUE_MIN_LENGTH } from "./_chunks/values-37UIzxM0.mjs";
+import { a as getActionReference, c as resolveAction, d as generateActionKey, f as sealBound, i as encodeActionReference, l as SealError, n as configureActionKeys, o as registerInlineAction, p as unsealBound, r as decodeActionReference, s as registerServerReference, t as bindInlineAction, u as createActionKeys } from "./_chunks/actions-BuS5jDi0.mjs";
+import { a as encode, r as decode } from "./_chunks/codec-C8to-RQW.mjs";
+import { I as readPostedAction, L as stripRuntimeFields, N as attachmentField, n as ACTION_KEY_FIELD, o as BOUND_FIELD, r as ACTION_STALE_HEADER, s as CALL_FIELD, t as ACTION_HEADER } from "./_chunks/wire-QEQWBr5s.mjs";
 import { n as setBuildDefaults, t as getBuildDefaults } from "./_chunks/build-COIcs7wm.mjs";
 // src/server/hooks.ts
 const HOOKS_KEY = Symbol.for("islx.server.hooks");

package/dist/tanstack-start/server.d.mts

@@ -0,0 +1,11 @@
+import { HandlerCallback } from "@tanstack/react-router/ssr/server";
+import { AnyRouter } from "@tanstack/react-router";
+
+// src/tanstack-start/server.d.ts
+
+/**
+ * Renders the page with its islands: values the browser holds stay out, and a navigation (an
+ * `F-Render` request) gets the whole page in one piece, as islx's browser runtime swaps it in.
+ */
+declare const islandsHandler: HandlerCallback<AnyRouter>;
+export { islandsHandler };

package/dist/tanstack-start/server.mjs

@@ -0,0 +1,54 @@
+import { t as IslandsProvider } from "../_chunks/island-DVOr-OUw.mjs";
+import { A as VALUES_HEADER, C as RENDER_HEADER } from "../_chunks/wire-QEQWBr5s.mjs";
+import { a as parseHeldValues } from "../_chunks/values-37UIzxM0.mjs";
+import * as React from "react";
+import { StartServer } from "@tanstack/react-start/server";
+import { createSsrStreamResponse, defineHandlerCallback, getSsrStatus, renderRouterToStream, transformReadableStreamWithRouter } from "@tanstack/react-router/ssr/server";
+// src/tanstack-start/server.ts
+/**
+* @farm.js/islx/tanstack-start/server: the render handler of a TanStack Start app as islands.
+* `islxTanstackStart()` uses it for Start's default server entry; an app with its own
+* `src/server.ts` passes it to `createStartHandler`:
+*
+*   import { createServerEntry, createStartHandler } from "@tanstack/react-start/server";
+*   import { islandsHandler } from "@farm.js/islx/tanstack-start/server";
+*   export default createServerEntry({ fetch: createStartHandler(islandsHandler) });
+*/
+/**
+* Renders the page with its islands: values the browser holds stay out, and a navigation (an
+* `F-Render` request) gets the whole page in one piece, as islx's browser runtime swaps it in.
+*/
+const islandsHandler = defineHandlerCallback(({ request, router, responseHeaders }) => {
+	const held = parseHeldValues(request);
+	responseHeaders.append("Vary", `${VALUES_HEADER}, ${RENDER_HEADER}`);
+	if (held.size > 0) responseHeaders.set("Cache-Control", "private, no-store");
+	const children = React.createElement(IslandsProvider, { held }, React.createElement(StartServer, { router }));
+	if (!request.headers.has("F-Render")) return renderRouterToStream({
+		request,
+		router,
+		responseHeaders,
+		children
+	});
+	return renderWhole(request, router, responseHeaders, children);
+});
+/** Waits for every Suspense boundary, so React writes the page with no streaming scripts. */
+async function renderWhole(request, router, responseHeaders, children) {
+	const { renderToReadableStream } = await import("react-dom/server");
+	const stream = await renderToReadableStream(children, {
+		signal: request.signal,
+		nonce: router.options.ssr?.nonce,
+		onError(error) {
+			if (!request.signal.aborted) console.error("Error in renderToReadableStream:", error);
+		}
+	});
+	await stream.allReady;
+	const body = transformReadableStreamWithRouter(router, stream, {
+		rendererSafePoint: "script-close",
+		signal: request.signal
+	});
+	return createSsrStreamResponse(router, new Response(body, {
+		status: getSsrStatus(router),
+		headers: responseHeaders
+	}));
+}
+export { islandsHandler };

package/dist/tanstack-start.d.mts

@@ -0,0 +1,8 @@
+import { IslxOptions } from "./vite.mjs";
+import { Plugin } from "vite";
+
+// src/tanstack-start/index.d.ts
+
+type IslxTanstackStartOptions = IslxOptions;
+declare function islxTanstackStart(options?: IslxTanstackStartOptions): Plugin[];
+export { IslxTanstackStartOptions, islxTanstackStart as default, islxTanstackStart };

package/dist/tanstack-start.mjs

@@ -0,0 +1,88 @@
+import { n as islx, t as ENTRY_ID } from "./_chunks/vite-DG7hBn8A.mjs";
+import { normalizePath } from "vite";
+// src/tanstack-start/index.ts
+/**
+* @farm.js/islx/tanstack-start: a TanStack Start app as islands.
+*
+*   import { tanstackStart } from "@tanstack/react-start/plugin/vite";
+*   import { islxTanstackStart } from "@farm.js/islx/tanstack-start";
+*   export default defineConfig({ plugins: [tanstackStart(), react(), islxTanstackStart()] });
+*
+* Routes render on the server; the browser loads islx and the `"use client"` components a page
+* uses, not the router or the routes. TanStack Start's client entry becomes islx's browser entry,
+* so `<Scripts />` still loads it. Client components are the `"use client"` modules under `src/`
+* (`clientComponents.include`); a library's stay server HTML.
+*/
+const START_CLIENT_ENTRY = "virtual:tanstack-start-client-entry";
+const START_SERVER_ENTRY = "virtual:tanstack-start-server-entry";
+const START_ROUTER_ENTRY = "#tanstack-router-entry";
+const ROUTER_WRAPPER = "\0islx:tanstack-router";
+const SERVER_WRAPPER = "\0islx:tanstack-server-entry";
+const SERVER_ENTRY = `import { createServerEntry, createStartHandler } from "@tanstack/react-start/server";
+import { handleAction } from "@farm.js/islx/server";
+import { islandsHandler } from "@farm.js/islx/tanstack-start/server";
+const start = createStartHandler(islandsHandler);
+export default createServerEntry({
+  // islx's server actions first; any other request (and Start's server functions) goes to Start.
+  async fetch(request, ...rest) {
+    return (await handleAction(request)) ?? start(request, ...rest);
+  },
+});
+`;
+const routerWrapper = (routerPath) => `import * as app from ${JSON.stringify(routerPath)};
+export * from ${JSON.stringify(routerPath)};
+export async function getRouter(...args) {
+  const router = await app.getRouter(...args);
+  const lifecycle = (router.serverSsrLifecycle ??= {});
+  // Start dehydrates every request: here that turns hydration off instead.
+  (lifecycle.onServerSsrAttach ??= []).push((ssr) => {
+    ssr.dehydrate = async () => ssr.disableHydration();
+  });
+  return router;
+}
+`;
+function islxTanstackStart(options = {}) {
+	let clientEntry;
+	let serverEntry;
+	let routerEntry;
+	const pathOf = (id) => normalizePath(id.split("?", 1)[0]);
+	return [{
+		name: "islx:tanstack-start",
+		enforce: "pre",
+		configResolved(config) {
+			const aliasOf = (find) => {
+				const alias = config.resolve.alias.find((entry) => entry.find === find);
+				if (!alias) throw new Error("islx: add tanstackStart() from @tanstack/react-start/plugin/vite before islxTanstackStart()");
+				return normalizePath(alias.replacement);
+			};
+			clientEntry = aliasOf(START_CLIENT_ENTRY);
+			routerEntry = aliasOf(START_ROUTER_ENTRY);
+			const server = aliasOf(START_SERVER_ENTRY);
+			if (server.includes("/node_modules/") || server.includes("/@tanstack/")) serverEntry = server;
+		},
+		resolveId(id, importer) {
+			if (this.environment.name === "client" || !routerEntry) return void 0;
+			if (serverEntry && pathOf(id) === serverEntry) return SERVER_WRAPPER;
+			if (!importer) return void 0;
+			if (pathOf(id) === routerEntry && importer !== ROUTER_WRAPPER && importer.includes("@tanstack")) return ROUTER_WRAPPER;
+		},
+		load(id) {
+			if (id === ROUTER_WRAPPER) return routerWrapper(routerEntry);
+			if (id === SERVER_WRAPPER) return SERVER_ENTRY;
+			const file = pathOf(id);
+			if (this.environment.name === "client") return file === clientEntry ? `import ${JSON.stringify(ENTRY_ID)};` : void 0;
+		}
+	}, ...islx({
+		serverEnvironments: ["ssr"],
+		...options,
+		clientComponents: {
+			include: options.clientComponents?.include ?? ["src/**"],
+			exclude: ["**/node_modules/**", ...options.clientComponents?.exclude ?? []]
+		}
+	}, {
+		frameworkEntry: true,
+		frameworkBuild: true,
+		frameworkRender: true
+	})];
+}
+export { islxTanstackStart as default, islxTanstackStart };

package/dist/vite.d.mts

@@ -43,6 +43,8 @@ interface IslxOptions {
     server?: string | ServerHooks;
   };
 }
+/** @internal The browser entry, for a framework whose own entry imports it. */
+declare const ENTRY_ID = "virtual:islx/client-entry";
 /**
  * The source of a hooks module made from callbacks. Each callback is copied as written, so it
  * must not use anything from where it was written: an outside variable, an import.
@@ -53,5 +55,22 @@ declare function resolveDirectives(directives?: IslxOptions["directives"]): {
   client: string;
   server: string;
 };
-declare function islx(options?: IslxOptions): Plugin[];
-export { IslxOptions, islx as default, islx, resolveDirectives, serializeHooks };
+/**
+ * @internal How a framework integration hosts islx (`@farm.js/islx/tanstack-start`).
+ */
+interface IslxHost {
+  /** The framework's own client entry imports islx's, so islx adds no browser entry of its own. */
+  frameworkEntry?: boolean;
+  /**
+   * The framework renders pages itself, without `renderToStream`: the server runtime islands need
+   * loads with them.
+   */
+  frameworkRender?: boolean;
+  /**
+   * The framework orders the build (the browser before the server): client modules come from
+   * `clientComponents.include`, and the server build gets their files directly.
+   */
+  frameworkBuild?: boolean;
+}
+declare function islx(options?: IslxOptions, host?: IslxHost): Plugin[];
+export { ENTRY_ID, IslxHost, IslxOptions, islx as default, islx, resolveDirectives, serializeHooks };