@farm.js/islx 0.0.0-stage → 0.0.1

package/dist/_chunks/actions-CA_K-In7.mjs

@@ -0,0 +1,310 @@
+import { A as VALUE_SCRIPT_TYPE, N as getTag, O as VALUES_HEADER, j as attachmentField, k as VALUE_KEY_PATTERN, o as BOUND_FIELD, s as CALL_FIELD, t as ACTION_HEADER } from "./wire-CXOodE06.mjs";
+import { a as encode, r as decode } from "./codec-BTDkzzPP.mjs";
+// src/client/value-store.ts
+/**
+* The browser's store of values sent once. It keeps every value it has read, parses each once,
+* and gives islands that share a value the same object. A navigation names the keys it holds
+* (`valueHeaders()`), so the server leaves those values out.
+*/
+/** Past this many values the store starts over at the next navigation. */
+const MAX_STORED_VALUES = 1024;
+const STORE_KEY = Symbol.for("islx.values");
+function createValueStore() {
+	const entries = /* @__PURE__ */ new Map();
+	const read = /* @__PURE__ */ new WeakSet();
+	const get = (key) => {
+		const entry = entries.get(key);
+		if (!entry) throw new Error(`islx value ${key} was not found`);
+		entries.delete(key);
+		entries.set(key, entry);
+		if (entry.state === "resolved") return entry.value;
+		if (entry.state === "resolving") throw new Error(`islx value ${key} refers to itself`);
+		entry.state = "resolving";
+		try {
+			entry.value = resolve(JSON.parse(entry.json));
+		} catch (error) {
+			entry.state = "raw";
+			throw error;
+		}
+		entry.state = "resolved";
+		entry.json = "";
+		return entry.value;
+	};
+	const resolve = (value) => {
+		if (Array.isArray(value)) return value.map(resolve);
+		if (!value || typeof value !== "object") return value;
+		const object = value;
+		const tag = getTag(object);
+		if (tag === "r" && typeof object["v"] === "string") return get(object["v"]);
+		if (tag === "o" && object["v"] && typeof object["v"] === "object") return {
+			["$"]: "o",
+			["v"]: resolveEntries(object["v"])
+		};
+		return resolveEntries(object);
+	};
+	const resolveEntries = (object) => {
+		const resolved = {};
+		for (const key of Object.keys(object)) Object.defineProperty(resolved, key, {
+			value: resolve(object[key]),
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+		return resolved;
+	};
+	return {
+		ingest(root) {
+			for (const script of root.querySelectorAll(`script[type="${VALUE_SCRIPT_TYPE}"]`)) {
+				if (read.has(script)) continue;
+				read.add(script);
+				const key = script.getAttribute("name") ?? "";
+				if (VALUE_KEY_PATTERN.test(key) && !entries.has(key)) entries.set(key, {
+					json: script.textContent || "null",
+					state: "raw"
+				});
+			}
+		},
+		resolve,
+		heldHeader() {
+			if (entries.size > MAX_STORED_VALUES) entries.clear();
+			if (entries.size === 0) return void 0;
+			return [...entries.keys()].slice(-128).join(",");
+		},
+		clear() {
+			entries.clear();
+		}
+	};
+}
+/** The page's value store, shared by every copy of islx on the page. */
+function getValueStore() {
+	const scope = globalThis;
+	return scope[STORE_KEY] ??= createValueStore();
+}
+/** Headers a navigation sends so the server can leave out values the browser holds. */
+function valueHeaders() {
+	const held = globalThis[STORE_KEY]?.heldHeader();
+	return held ? { [VALUES_HEADER]: held } : {};
+}
+// src/client/hooks.ts
+const HOOKS_KEY = Symbol.for("islx.client.hooks");
+const CANCELABLE = /* @__PURE__ */ new Set(["navigate"]);
+/** Types an app's hooks module. */
+function defineClientHooks(hooks) {
+	return hooks;
+}
+/** Installs the app's hooks; the plugin's browser entry calls it. */
+function setClientHooks(hooks) {
+	globalThis[HOOKS_KEY] = hooks;
+}
+/** The DOM event name of a hook: `navigateError` → `f:navigate-error`. */
+function hookEventName(name) {
+	return `f:${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}`;
+}
+/**
+* Runs a hook and dispatches its DOM event. Returns false when it was cancelled. A hook that
+* throws is reported, never allowed to break navigation or hydration.
+*/
+function emit(name, detail) {
+	const cancelable = CANCELABLE.has(name);
+	let prevented = false;
+	const event = {
+		...detail,
+		preventDefault() {
+			if (cancelable) prevented = true;
+		},
+		get defaultPrevented() {
+			return prevented;
+		}
+	};
+	const hook = globalThis[HOOKS_KEY]?.[name];
+	if (hook) try {
+		hook(event);
+	} catch (error) {
+		console.error(`[islx] The ${name} hook failed:`, error);
+	}
+	if (typeof document !== "undefined" && typeof CustomEvent === "function") {
+		const dom = new CustomEvent(hookEventName(name), {
+			detail,
+			cancelable
+		});
+		if (!document.dispatchEvent(dom)) prevented = cancelable;
+	}
+	return !prevented;
+}
+// src/client/actions.ts
+/**
+* The browser side of server actions. A client module's import of a `"use server"` module
+* becomes references made here, and an action passed as a prop arrives as one.
+*
+* Calls run one at a time, in order, as React expects of actions. After each, the page refreshes
+* (through the framework's router) so it shows what the action changed; a redirect from the
+* action navigates instead. An action this server no longer knows, as after a deploy, reloads the
+* page.
+*/
+const STATE_KEY = Symbol.for("islx.actions.client");
+function state() {
+	const scope = globalThis;
+	return scope[STATE_KEY] ??= {
+		navigator: {},
+		queue: Promise.resolve(),
+		references: /* @__PURE__ */ new Map(),
+		info: /* @__PURE__ */ new WeakMap()
+	};
+}
+/** Connects actions to the framework's router. */
+function setActionNavigator(navigator) {
+	state().navigator = navigator;
+}
+/** Encodes an action passed back to the server as an argument. */
+function encodeFunction(value) {
+	const reference = state().info.get(value);
+	if (!reference) return void 0;
+	if (reference.bound.length > 0) throw new TypeError("an action bound in the browser cannot be sent to the server");
+	return reference.token === void 0 ? {
+		["$"]: "a",
+		["v"]: reference.id
+	} : {
+		["$"]: "a",
+		["v"]: reference.id,
+		["b"]: reference.token
+	};
+}
+/** Decodes an action in a result or props: `{"$":"a","v":id,"b"?:sealed}`. */
+function decodeActionReference(object) {
+	if (object["$"] !== "a" || typeof object["v"] !== "string") return void 0;
+	const token = object["b"];
+	if (token !== void 0 && typeof token !== "string") return void 0;
+	return createServerReference(object["v"], token);
+}
+/** Returned by a call whose action this deploy no longer knows: the page reloads. */
+const STALE = Symbol("islx.action.stale");
+async function call(reference, args) {
+	const all = [...reference.bound, ...args];
+	const single = all.length === 1 && all[0] instanceof FormData ? all[0] : null;
+	let body;
+	const headers = { [ACTION_HEADER]: reference.id };
+	if (single) {
+		const form = new FormData();
+		for (const [key, value] of single) form.append(key, value);
+		if (reference.token !== void 0) form.append(BOUND_FIELD, reference.token);
+		body = form;
+	} else {
+		const attachments = [];
+		const encodeObject = (value) => {
+			if (value instanceof FormData || value instanceof Blob) {
+				attachments.push(value);
+				return {
+					["$"]: value instanceof FormData ? "F" : "K",
+					["v"]: attachments.length - 1
+				};
+			}
+		};
+		const json = JSON.stringify({
+			a: encode(all, {
+				encodeFunction,
+				encodeObject
+			}),
+			b: reference.token
+		});
+		if (attachments.length === 0) {
+			headers["content-type"] = "text/plain;charset=UTF-8";
+			body = json;
+		} else {
+			const form = new FormData();
+			form.append(CALL_FIELD, json);
+			attachments.forEach((attachment, index) => {
+				if (attachment instanceof FormData) for (const [key, value] of attachment) form.append(attachmentField(index, key), value);
+				else form.append(attachmentField(index), attachment);
+			});
+			body = form;
+		}
+	}
+	const response = await fetch(location.href, {
+		method: "POST",
+		headers,
+		body,
+		credentials: "same-origin"
+	});
+	if (response.headers.get("F-Action-Stale")) {
+		location.reload();
+		return STALE;
+	}
+	if (!response.ok) throw new Error(`Server action failed: ${response.status}`);
+	const payload = await response.json();
+	const navigator = state().navigator;
+	if (typeof payload.redirect === "string") {
+		reference.redirect = payload.redirect;
+		if (navigator.navigate) await navigator.navigate(payload.redirect);
+		else location.assign(payload.redirect);
+		return;
+	}
+	const result = decode(payload.result, { decodeReference: decodeActionReference });
+	if (navigator.refresh) await navigator.refresh();
+	return result;
+}
+function createReference(reference) {
+	const client = state();
+	const fn = (...args) => {
+		const { id, name } = reference;
+		let startedAt = 0;
+		const run = async () => {
+			emit("action", {
+				id,
+				name
+			});
+			startedAt = performance.now();
+			reference.redirect = void 0;
+			return call(reference, args);
+		};
+		const result = client.queue.then(run).then((value) => {
+			if (value !== STALE) {
+				const { redirect } = reference;
+				emit("actionEnd", {
+					id,
+					name,
+					ok: true,
+					duration: performance.now() - startedAt,
+					redirect
+				});
+			}
+			return value;
+		}, (error) => {
+			emit("actionEnd", {
+				id,
+				name,
+				ok: false,
+				duration: performance.now() - startedAt,
+				error
+			});
+			throw error;
+		});
+		client.queue = result.then(() => {}, () => {});
+		return result.then((value) => value === STALE ? new Promise(() => {}) : value);
+	};
+	client.info.set(fn, reference);
+	Object.defineProperty(fn, "bind", {
+		configurable: true,
+		value: (_thisArg, ...args) => createReference({
+			...reference,
+			bound: [...reference.bound, ...args]
+		})
+	});
+	return fn;
+}
+/** The function that calls a server action; one per id and sealed values, so props keep identity. */
+function createServerReference(id, token, name) {
+	const key = token === void 0 ? id : `${id}\0${token}`;
+	const references = state().references;
+	let reference = references.get(key);
+	if (!reference) {
+		reference = createReference({
+			id,
+			token,
+			bound: [],
+			name
+		});
+		references.set(key, reference);
+	}
+	return reference;
+}
+export { emit as a, createValueStore as c, defineClientHooks as i, getValueStore as l, decodeActionReference as n, hookEventName as o, setActionNavigator as r, setClientHooks as s, createServerReference as t, valueHeaders as u };

package/dist/_chunks/actions-Eutk6UzT.mjs

@@ -0,0 +1,326 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { walk } from "estree-walker";
+import isReference from "is-reference";
+import MagicString from "magic-string";
+import { analyze } from "periscopic";
+// src/compiler/actions.ts
+/**
+* The server-action compiler: a pure function from a module's source to its source for the
+* server or the browser. Bundler plugins call it; it parses with the parser they pass.
+*
+* - A `"use server"` module: on the server every export registers as an action; in the browser
+*   the module becomes references that call those ids, so its code never reaches a bundle.
+* - An inline `"use server"` function in server code: hoisted to module scope, taking the
+*   variables it read from the component around it as one array. Where it was written, it
+*   becomes a reference that carries those variables, sealed.
+*/
+/** A mistake in the source, with where it is. Bundlers show `loc` with a code frame. */
+var ActionCompileError = class extends Error {
+	loc;
+	id;
+	constructor(message, file, code, offset) {
+		const before = code.slice(0, offset).split("\n");
+		const line = before.length;
+		const column = before.at(-1).length;
+		super(`${message} (${file}:${line}:${column + 1})`);
+		this.name = "ActionCompileError";
+		this.id = file;
+		this.loc = {
+			file,
+			line,
+			column
+		};
+	}
+};
+/**
+* Whether the module's directive prologue (the strings before any other statement, after
+* comments) holds `directive`. A linear scan, for a cheap check before parsing.
+*/
+function hasModuleDirective(code, directive) {
+	let index = 0;
+	while (index < code.length) {
+		const char = code.charCodeAt(index);
+		if (char === 32 || char >= 9 && char <= 13 || char === 65279 || char === 160) index++;
+		else if (code.startsWith("//", index)) {
+			const end = code.indexOf("\n", index);
+			if (end === -1) return false;
+			index = end + 1;
+		} else if (code.startsWith("/*", index)) {
+			const end = code.indexOf("*/", index + 2);
+			if (end === -1) return false;
+			index = end + 2;
+		} else if (char === 34 || char === 39) {
+			const quote = code[index];
+			const end = code.indexOf(quote, index + 1);
+			if (end === -1) return false;
+			const value = code.slice(index + 1, end);
+			index = end + 1;
+			while (index < code.length && /[ \t]/.test(code[index])) index++;
+			if (code[index] === ";") index++;
+			else if (index < code.length && code[index] !== "\n" && code[index] !== "\r") return false;
+			if (value === directive) return true;
+		} else return false;
+	}
+	return false;
+}
+/** The id an action has on both sides: a hash of its module path from the root and its name. */
+function getActionId(root, file, name, salt = "") {
+	const relative = path.relative(root, file.split("?", 1)[0]).split(path.sep).join("/");
+	return createHash("sha256").update(`${salt}${relative}#${name}`).digest("base64url").slice(0, 22);
+}
+function hasDirective(statements, directive) {
+	for (const statement of statements ?? []) {
+		if (statement.type !== "ExpressionStatement") return false;
+		const expression = statement.expression;
+		const value = statement.directive ?? (expression?.type === "Literal" ? expression.value : void 0);
+		if (typeof value !== "string") return false;
+		if (value === directive) return true;
+	}
+	return false;
+}
+const FUNCTION_TYPES = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+function isInlineAction(node, directive) {
+	return FUNCTION_TYPES.has(node.type) && node.body?.type === "BlockStatement" && hasDirective(node.body.body, directive);
+}
+function actionName(node, parent) {
+	if (node.id?.name) return node.id.name;
+	if (parent?.type === "VariableDeclarator" && parent.id?.type === "Identifier") return parent.id.name;
+	if (parent?.type === "Property" && parent.key?.type === "Identifier") return parent.key.name;
+	if (parent?.type === "JSXExpressionContainer") return null;
+	return null;
+}
+/** Exports of a `"use server"` module, refusing what cannot be an action. */
+function collectExports(program, fail, directive) {
+	const exports = [];
+	const onlyAsync = `A "${directive}" module may export only async functions`;
+	const checkFunction = (node, name) => {
+		if (FUNCTION_TYPES.has(node.type)) {
+			if (!node.async) fail(`${onlyAsync}: make ${name} async`, node);
+			if (node.generator) fail(`${onlyAsync}: ${name} is a generator`, node);
+			return;
+		}
+		if (node.type === "Literal" || node.type === "ObjectExpression" || node.type === "ArrayExpression" || node.type === "TemplateLiteral" || node.type === "ClassExpression") fail(`${onlyAsync}; ${name} is not a function`, node);
+	};
+	for (const node of program.body ?? []) {
+		if (node.type === "ExportAllDeclaration") fail(`"${directive}" modules cannot re-export with \`export *\`: export each action by name`, node);
+		if (node.type === "ExportNamedDeclaration") {
+			if (node.exportKind === "type") continue;
+			if (node.source) fail(`"${directive}" modules cannot re-export from another module: import the actions, then export them`, node);
+			const declaration = node.declaration;
+			if (declaration?.type === "FunctionDeclaration") {
+				checkFunction(declaration, declaration.id.name);
+				exports.push({
+					exported: declaration.id.name,
+					local: declaration.id.name,
+					node: declaration
+				});
+			} else if (declaration?.type === "VariableDeclaration") for (const declarator of declaration.declarations ?? []) {
+				if (declarator.id?.type !== "Identifier") fail(`${onlyAsync}; destructured exports are not supported`, declarator);
+				if (declarator.init) checkFunction(declarator.init, declarator.id.name);
+				exports.push({
+					exported: declarator.id.name,
+					local: declarator.id.name,
+					node: declarator
+				});
+			}
+			else if (declaration?.type === "ClassDeclaration") fail(`${onlyAsync}; ${declaration.id?.name ?? "a class"} is a class`, declaration);
+			else if (declaration && !String(declaration.type).startsWith("TS")) fail(onlyAsync, declaration);
+			for (const specifier of node.specifiers ?? []) {
+				if (specifier.exportKind === "type") continue;
+				const exported = specifier.exported?.name ?? specifier.exported?.value;
+				exports.push({
+					exported,
+					local: specifier.local?.name ?? null,
+					node: specifier
+				});
+			}
+		} else if (node.type === "ExportDefaultDeclaration") {
+			const declaration = node.declaration;
+			checkFunction(declaration, "the default export");
+			const local = FUNCTION_TYPES.has(declaration.type) && declaration.id?.name || declaration.type === "Identifier" && declaration.name || null;
+			exports.push({
+				exported: "default",
+				local,
+				node
+			});
+		}
+	}
+	return exports;
+}
+/**
+* Compiles a module's server actions, or returns null when it has none. Throws an
+* `ActionCompileError` for a mistake, such as an inline action in browser code.
+*/
+function transformActions(options) {
+	const { code, id, root, environment } = options;
+	const salt = options.salt ?? "";
+	const serverRuntime = options.runtime?.server ?? "@farm.js/islx/server";
+	const clientRuntime = options.runtime?.client ?? "@farm.js/islx/client";
+	const directive = options.directive ?? "use server";
+	const moduleDirective = hasModuleDirective(code, directive);
+	if (!moduleDirective && !code.includes(directive)) return null;
+	const program = options.parse(code);
+	const file = id.split("?", 1)[0];
+	const relative = path.relative(root, file).split(path.sep).join("/");
+	const fail = (message, node) => {
+		throw new ActionCompileError(message, file, code, node.start);
+	};
+	const actionId = (name) => getActionId(root, file, name, salt);
+	const label = (name) => `${name} (${relative})`;
+	if (moduleDirective && environment === "client") {
+		const exports = collectExports(program, fail, directive);
+		const lines = [`import { createServerReference as $$islx_ref } from ${JSON.stringify(clientRuntime)};`];
+		for (const entry of exports) {
+			const reference = `$$islx_ref(${JSON.stringify(actionId(entry.exported))}, undefined, ${JSON.stringify(entry.exported === "default" ? "default" : entry.exported)})`;
+			lines.push(entry.exported === "default" ? `export default ${reference};` : `export const ${entry.exported} = ${reference};`);
+		}
+		const output = new MagicString(code);
+		output.overwrite(0, code.length, `${lines.join("\n")}\n`);
+		return {
+			code: output.toString(),
+			map: output.generateMap({
+				hires: true,
+				source: file
+			})
+		};
+	}
+	const { map, scope: moduleScope } = analyze(program);
+	const scopes = [moduleScope];
+	const scopeNodes = [program];
+	const inline = [];
+	const active = [];
+	let functionDepth = 0;
+	const ownFunctionDepth = [];
+	walk(program, {
+		enter(rawNode, rawParent) {
+			const node = rawNode;
+			const parent = rawParent;
+			if (typeof node.type === "string" && node.type.startsWith("TS")) {
+				this.skip();
+				return;
+			}
+			const scope = node === program ? void 0 : map.get(node);
+			if (scope) {
+				scopes.push(scope);
+				scopeNodes.push(node);
+			}
+			if (FUNCTION_TYPES.has(node.type)) {
+				if (isInlineAction(node, directive) && !(moduleDirective && functionDepth === 0)) {
+					if (environment === "client") fail(`An inline "${directive}" function can only be written in server code. Move it to a "${directive}" module and import it here`, node);
+					if (!node.async) fail("A server action must be an async function", node);
+					if (node.generator) fail("A server action cannot be a generator", node);
+					const action = {
+						node,
+						parent,
+						nested: functionDepth > 0,
+						name: actionName(node, parent),
+						captured: [],
+						scopeIndex: scopes.length - 1
+					};
+					inline.push(action);
+					active.push(action);
+					ownFunctionDepth.push(0);
+				} else if (node.type !== "ArrowFunctionExpression") for (let index = 0; index < ownFunctionDepth.length; index++) ownFunctionDepth[index]++;
+				functionDepth++;
+				return;
+			}
+			if (active.length === 0) return;
+			if (node.type === "ThisExpression" || node.type === "Identifier" && node.name === "arguments" && parent && isReference(node, parent)) {
+				for (let index = 0; index < active.length; index++) if (ownFunctionDepth[index] === 0) fail(`A server action cannot use \`${node.type === "ThisExpression" ? "this" : "arguments"}\`: pass what it needs as an argument`, node);
+				return;
+			}
+			if (node.type !== "Identifier" || !parent || !isReference(node, parent)) return;
+			if (parent.id === node && FUNCTION_TYPES.has(parent.type)) return;
+			const owner = scopes.at(-1).find_owner(node.name);
+			if (!owner || owner === moduleScope) return;
+			const ownerIndex = scopes.lastIndexOf(owner);
+			for (const action of active) if (ownerIndex > 0 && ownerIndex < action.scopeIndex && !action.captured.includes(node.name)) {
+				if (action.node.type === "FunctionDeclaration" && action.name === node.name) fail(`The server action ${node.name} refers to itself. To call it again, move it to a "${directive}" module`, node);
+				action.captured.push(node.name);
+			}
+		},
+		leave(rawNode) {
+			const node = rawNode;
+			if (scopeNodes.at(-1) === node && node !== program) {
+				scopes.pop();
+				scopeNodes.pop();
+			}
+			if (FUNCTION_TYPES.has(node.type)) {
+				functionDepth--;
+				if (active.at(-1)?.node === node) {
+					active.pop();
+					ownFunctionDepth.pop();
+				} else if (node.type !== "ArrowFunctionExpression") for (let index = 0; index < ownFunctionDepth.length; index++) ownFunctionDepth[index]--;
+			}
+		}
+	});
+	if (inline.length === 0 && !moduleDirective) return null;
+	const output = new MagicString(code);
+	const footer = [];
+	let usesBind = false;
+	let usesInline = false;
+	let usesReference = false;
+	const numbered = [...inline].sort((a, b) => a.node.start - b.node.start);
+	const ids = new Map(numbered.map((action, index) => [action, index]));
+	for (const action of [...inline].sort((a, b) => b.node.start - a.node.start)) {
+		const index = ids.get(action);
+		const name = action.name ?? `action ${index + 1}`;
+		const idValue = actionId(`inline:${index}`);
+		const { node } = action;
+		if (!action.nested) {
+			usesReference = true;
+			if (node.type === "FunctionDeclaration") footer.push(`$$islx_ref(${node.id.name}, ${JSON.stringify(idValue)}, ${JSON.stringify(label(name))});`);
+			else {
+				output.prependLeft(node.start, "$$islx_ref(");
+				output.appendRight(node.end, `, ${JSON.stringify(idValue)}, ${JSON.stringify(label(name))})`);
+			}
+			continue;
+		}
+		usesBind = true;
+		usesInline = true;
+		const hoisted = `$$islx_action_${index}`;
+		const params = node.params.map((param) => output.slice(param.start, param.end));
+		const captured = action.captured.length > 0 ? `[${action.captured.join(", ")}]` : "$$islx_captured";
+		const body = output.slice(node.body.start + 1, node.body.end - 1);
+		footer.push(`async function ${hoisted}(${[captured, ...params].join(", ")}) {${body}}`, `$$islx_inline(${hoisted}, ${JSON.stringify(idValue)}, ${action.captured.length}, ${JSON.stringify(label(name))});`);
+		const reference = `$$islx_bind(${JSON.stringify(idValue)}, () => [${action.captured.join(", ")}], ${JSON.stringify(action.captured)})`;
+		if (node.type === "FunctionDeclaration") {
+			const block = action.parent;
+			if (!block || block.type !== "BlockStatement" && block.type !== "StaticBlock") fail("Declare this server action directly inside a function body", node);
+			output.remove(node.start, node.end);
+			output.appendRight(block.start + 1, `const ${node.id.name} = ${reference};`);
+		} else output.overwrite(node.start, node.end, reference);
+	}
+	if (moduleDirective) {
+		usesReference = true;
+		for (const entry of collectExports(program, fail, directive)) {
+			if (!entry.local) {
+				const declaration = entry.node.declaration;
+				output.overwrite(entry.node.start, declaration.start, "const $$islx_default = ");
+				footer.push("export { $$islx_default as default };");
+				entry.local = "$$islx_default";
+			}
+			footer.push(`$$islx_ref(${entry.local}, ${JSON.stringify(actionId(entry.exported))}, ${JSON.stringify(label(entry.exported))});`);
+		}
+	}
+	const imports = [
+		usesBind && "bindInlineAction as $$islx_bind",
+		usesInline && "registerInlineAction as $$islx_inline",
+		usesReference && "registerServerReference as $$islx_ref"
+	].filter(Boolean);
+	output.prepend(`import { ${imports.join(", ")} } from ${JSON.stringify(serverRuntime)};\n`);
+	output.append(`\n${footer.join("\n")}\n`);
+	return {
+		code: output.toString(),
+		map: output.generateMap({
+			hires: true,
+			source: file
+		})
+	};
+}
+export { transformActions as i, getActionId as n, hasModuleDirective as r, ActionCompileError as t };

package/dist/_chunks/build-COIcs7wm.mjs

@@ -0,0 +1,9 @@
+// src/server/build.ts
+const BUILD_KEY = Symbol.for("islx.build");
+function setBuildDefaults(defaults) {
+	globalThis[BUILD_KEY] = defaults;
+}
+function getBuildDefaults() {
+	return globalThis[BUILD_KEY] ?? {};
+}
+export { setBuildDefaults as n, getBuildDefaults as t };