@farm.js/islx 0.0.0-stage → 0.0.2

package/dist/_chunks/actions-B8dJ8f7L.mjs

@@ -0,0 +1,615 @@
+import { M as formFieldName, O as VALUES_HEADER, d as FORM_REF_PREFIX, k as VALUE_KEY_PATTERN } from "./wire-CXOodE06.mjs";
+import { a as encode, c as needsObjectTag, o as encodeLeaf, r as decode, t as EncodeError } from "./codec-DqfVYKsx.mjs";
+import { t as getBuildDefaults } from "./build-COIcs7wm.mjs";
+// src/server/values.ts
+/**
+* Values sent once: which parts of an island's props travel as values of their own, keyed by a
+* hash of their JSON, and which of those a response leaves out because the browser already holds
+* them. The browser side is `@farm.js/islx/client` (`getValueStore`).
+*/
+/** Shorter values stay inline: a reference and its script cost about 60 bytes. */
+const VALUE_MIN_LENGTH = 512;
+/** A 64-bit hash of a value's JSON, as 14 base-36 characters. Not cryptographic. */
+function hashValue(json) {
+	let h1 = 3735928559 ^ json.length;
+	let h2 = 1103547991 ^ json.length;
+	for (let index = 0; index < json.length; index++) {
+		const code = json.charCodeAt(index);
+		h1 = Math.imul(h1 ^ code, 2654435761);
+		h2 = Math.imul(h2 ^ code, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return (h2 >>> 0).toString(36).padStart(7, "0") + (h1 >>> 0).toString(36).padStart(7, "0");
+}
+/**
+* Serializes props with every value whose JSON reaches `minLength` replaced by a reference to it.
+* Types JSON cannot hold are tagged first (the codec), so a `Map` or a `Date` is addressed like
+* any other value. Inner values are addressed first, so a large value that differs between pages
+* in one place still shares its unchanged parts.
+*/
+function addressValues(props, { minLength = 512, encodeSpecial, encoded = false } = {}) {
+	const values = /* @__PURE__ */ new Map();
+	const reference = (json, children, parent) => {
+		const key = hashValue(json);
+		if (!values.has(key)) values.set(key, {
+			key,
+			json,
+			children
+		});
+		parent.push(key);
+		return `{"$":"r","v":"${key}"}`;
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const encode = (value, parent) => {
+		const special = encoded ? void 0 : encodeSpecial?.(value);
+		if (special !== void 0) {
+			const json = JSON.stringify(special);
+			return [json, json.length];
+		}
+		const leaf = encoded ? void 0 : encodeLeaf(value);
+		if (leaf) {
+			const json = JSON.stringify(leaf);
+			return [json, json.length];
+		}
+		if (typeof value === "function") throw new TypeError("functions are not serializable");
+		if (typeof value === "symbol") throw new TypeError("symbol values are not serializable");
+		if (value === null || typeof value !== "object") {
+			const json = JSON.stringify(value);
+			return [typeof value === "string" && json.length >= minLength ? reference(json, [], parent) : json, json.length];
+		}
+		if (seen.has(value)) throw new TypeError("circular values are not serializable");
+		seen.add(value);
+		try {
+			if (!encoded && (value instanceof Map || value instanceof Set)) {
+				const entries = value instanceof Map ? Array.from(value, ([key, entry]) => [key, entry]) : [...value];
+				const [json, length] = encode(entries, parent);
+				const prefix = `{"$":"${value instanceof Map ? "M" : "S"}","v":`;
+				return [`${prefix}${json}}`, length + prefix.length + 1];
+			}
+			const prototype = Object.getPrototypeOf(value);
+			if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) throw new TypeError("class instances are not serializable");
+			const own = [];
+			let length = 2;
+			const parts = [];
+			if (Array.isArray(value)) for (const entry of value) {
+				const [json, entryLength] = encode(entry, own);
+				parts.push(json);
+				length += entryLength + 1;
+			}
+			else for (const [key, entry] of Object.entries(value)) {
+				const [json, entryLength] = encode(entry, own);
+				const name = JSON.stringify(key);
+				parts.push(`${name}:${json}`);
+				length += name.length + entryLength + 2;
+			}
+			let json = Array.isArray(value) ? `[${parts.join(",")}]` : `{${parts.join(",")}}`;
+			if (!encoded && !Array.isArray(value) && needsObjectTag(value)) {
+				json = `{"$":"o","v":${json}}`;
+				length += 14;
+			}
+			const wrapper = own.length === 1 && json.length < minLength / 4;
+			if (length >= minLength && !wrapper) return [reference(json, own, parent), length];
+			parent.push(...own);
+			return [json, length];
+		} finally {
+			seen.delete(value);
+		}
+	};
+	const roots = [];
+	return {
+		json: `{${Object.entries(props).map(([key, entry]) => `${JSON.stringify(key)}:${encode(entry, roots)[0]}`).join(",")}}`,
+		values,
+		roots
+	};
+}
+/**
+* The values a response sends for `addressed`, parents first. A value the browser holds is left
+* out with everything inside it: the browser kept those when it read the value.
+*/
+function selectValuesToSend(addressed, held) {
+	const send = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (key) => {
+		if (seen.has(key)) return;
+		seen.add(key);
+		if (held?.has(key)) return;
+		const value = addressed.values.get(key);
+		send.push(value);
+		value.children.forEach(visit);
+	};
+	addressed.roots.forEach(visit);
+	return send;
+}
+/**
+* The value keys a request names (`F-Values`): well-formed keys only, at most `MAX_HELD_VALUES`.
+*
+* A response that leaves values out is one browser's. Integrations must keep it out of shared
+* caches (CDN, ISR, PPR shells), and add `Vary: F-Values` to cacheable responses.
+*/
+function parseHeldValues(input) {
+	const header = typeof input === "string" || input == null ? input : (input instanceof Request ? input.headers : input).get(VALUES_HEADER);
+	const held = /* @__PURE__ */ new Set();
+	if (!header) return held;
+	for (const key of header.split(",", 256)) {
+		const trimmed = key.trim();
+		if (VALUE_KEY_PATTERN.test(trimmed)) held.add(trimmed);
+		if (held.size === 128) break;
+	}
+	return held;
+}
+/** A value script's JSON, safe inside a `<script>` element. */
+function escapeScriptJson(json) {
+	return json.replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+// src/server/seal.ts
+/**
+* Sealing an action's captured values. An inline `"use server"` function that reads a variable of
+* the render around it (`user` below) runs in a later request, so the value makes the round trip
+* through the browser:
+*
+*   async function Page() {
+*     const user = await getUser();
+*     async function rename(form) {
+*       "use server";
+*       await db.rename(user.id, form.get("name"));
+*     }
+*     return <form action={rename}>…</form>;
+*   }
+*
+* The browser must not read or change it, so it travels sealed: AES-GCM with a fresh random IV,
+* and the action id as additional data, so a sealed value only opens for the action it was made
+* for. Web Crypto only, so it runs on Node, Bun, Deno, workerd and every other runtime with
+* `crypto.subtle`.
+*
+* Sealing is asynchronous. React's server renderer waits for it: a form whose action's values
+* are still sealing suspends, and renders once they are ready.
+*
+*   sealed = base64url( version (1 byte) ‖ key id (1 byte) ‖ IV (12 bytes) ‖ ciphertext+tag )
+*/
+const VERSION = 1;
+const IV_BYTES = 12;
+const KEY_BYTES = 32;
+/** Thrown when a sealed value does not open: changed, made for another action, or stale. */
+var SealError = class extends Error {
+	/**
+	* `stale`: sealed with a key this server does not have, as after a deploy that changed keys.
+	* The page should reload. `invalid`: anything else; answer 400.
+	*/
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.name = "SealError";
+		this.reason = reason;
+	}
+};
+function base64url(bytes) {
+	let binary = "";
+	for (let index = 0; index < bytes.length; index += 32768) binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64url(text) {
+	if (!/^[A-Za-z0-9_-]*$/.test(text)) return null;
+	try {
+		const binary = atob(text.replace(/-/g, "+").replace(/_/g, "/"));
+		const bytes = new Uint8Array(binary.length);
+		for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+		return bytes;
+	} catch {
+		return null;
+	}
+}
+/** A new random key, as base64url: what `FURROW_ACTIONS_KEY` holds. */
+function generateActionKey() {
+	return base64url(crypto.getRandomValues(new Uint8Array(KEY_BYTES)));
+}
+async function importKey(secret) {
+	const bytes = fromBase64url(secret.trim());
+	if (!bytes || bytes.length !== KEY_BYTES) throw new TypeError("an actions key must be 32 random bytes as base64url; create one with generateActionKey() from @farm.js/islx/server");
+	return crypto.subtle.importKey("raw", bytes, "AES-GCM", false, ["encrypt", "decrypt"]);
+}
+/** The key's id: its first byte of SHA-256, so a value names the key that sealed it. */
+async function keyId(secret) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(secret.trim()));
+	return new Uint8Array(digest)[0];
+}
+/**
+* The keys values are sealed and opened with. `current` seals; `previous` keys still open
+* values, so pages rendered before a key rotation keep working until they are reloaded.
+*
+* Every server that may receive an action must have the same keys. When an app runs more than
+* one instance, or builds and serves on different machines, set them from the environment.
+*/
+async function createActionKeys(current, previous = []) {
+	const byId = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const add = async (secret) => {
+		const trimmed = secret.trim();
+		if (seen.has(trimmed)) return;
+		seen.add(trimmed);
+		const id = await keyId(trimmed);
+		const key = await importKey(trimmed);
+		byId.set(id, [...byId.get(id) ?? [], key]);
+		return {
+			id,
+			key
+		};
+	};
+	const { id: currentId, key: currentKey } = await add(current);
+	for (const secret of previous) await add(secret);
+	return {
+		current: currentKey,
+		currentId,
+		byId
+	};
+}
+function additionalData(actionId) {
+	return new TextEncoder().encode(`islx:action:${actionId}`);
+}
+/** Seals an action's captured values for the browser to carry. */
+async function sealBound(keys, actionId, values, options = {}) {
+	let json;
+	try {
+		json = JSON.stringify(values.map((value, index) => encode(value, {
+			encodeFunction: options.encodeFunction,
+			path: [options.names?.[index] ?? `$${index}`]
+		})));
+	} catch (error) {
+		if (error instanceof EncodeError) {
+			const name = String(error.path[0]);
+			const where = error.path.length > 1 ? ` (at ${error.location})` : "";
+			const action = options.label ? ` ${options.label}` : "";
+			throw new TypeError(`\`${name}\` cannot be captured by the server action${action}${where}: ${error.reason}. Read it inside the action instead, or capture a plain value.`, { cause: error });
+		}
+		throw error;
+	}
+	const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
+	const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv,
+		additionalData: additionalData(actionId)
+	}, keys.current, new TextEncoder().encode(json)));
+	const sealed = new Uint8Array(14 + ciphertext.length);
+	sealed[0] = VERSION;
+	sealed[1] = keys.currentId;
+	sealed.set(iv, 2);
+	sealed.set(ciphertext, 14);
+	return base64url(sealed);
+}
+/**
+* Opens values sealed for `actionId`. Throws a `SealError`: `stale` when no key this server has
+* sealed them, `invalid` when they were changed or sealed for another action.
+*/
+async function unsealBound(keys, actionId, sealed, options = {}) {
+	const bytes = fromBase64url(sealed);
+	if (!bytes || bytes.length < 30) throw new SealError("invalid", "sealed action values are malformed");
+	if (bytes[0] !== VERSION) throw new SealError("stale", "sealed action values use another format version");
+	const candidates = keys.byId.get(bytes[1]);
+	if (!candidates) throw new SealError("stale", "sealed action values use a key this server does not have");
+	let plaintext;
+	for (const key of candidates) try {
+		plaintext = await crypto.subtle.decrypt({
+			name: "AES-GCM",
+			iv: bytes.subarray(2, 14),
+			additionalData: additionalData(actionId)
+		}, key, bytes.subarray(14));
+		break;
+	} catch {}
+	if (!plaintext) throw new SealError("invalid", "sealed action values do not open for this action");
+	const values = decode(JSON.parse(new TextDecoder().decode(plaintext)), options);
+	if (!Array.isArray(values)) throw new SealError("invalid", "sealed action values are malformed");
+	return values;
+}
+// src/server/actions.ts
+/**
+* Server actions: functions the browser can call. Each has an id; the compiler registers every
+* export of a `"use server"` module, and hoists each inline `"use server"` function out of the
+* component it is written in, with the variables it reads passed back to it.
+*
+* A reference is what the browser holds: an id, and the action's bound values (the variables an
+* inline action captured, and arguments added with `.bind`) sealed so only the server reads them.
+*
+* Reference functions carry React's progressive-enhancement hooks, so `<form action={fn}>` works
+* before JavaScript loads, and `useActionState` keeps its state across a form post.
+*/
+const REGISTRY_KEY = Symbol.for("islx.actions.registry");
+const REFERENCES_KEY = Symbol.for("islx.actions.references");
+const KEYS_KEY = Symbol.for("islx.actions.keys");
+function registry() {
+	return globalThis[REGISTRY_KEY] ??= /* @__PURE__ */ new Map();
+}
+function references() {
+	return globalThis[REFERENCES_KEY] ??= /* @__PURE__ */ new WeakMap();
+}
+let warnedGeneratedKey = false;
+/**
+* Sets the keys bound values are sealed with: `key` seals, `previousKeys` still open values
+* sealed before a rotation. Without it, `ISLX_ACTIONS_KEY` and `ISLX_ACTIONS_PREVIOUS_KEYS`
+* (comma-separated) are read from the environment; failing those, the key the bundler plugin
+* made for this build; failing that, a key generated for this process: fine for one long-lived
+* server, wrong for several instances or serverless, where every server must hold the same key.
+*/
+function configureActionKeys(options) {
+	globalThis[KEYS_KEY] = createActionKeys(options.key, options.previousKeys);
+}
+function actionKeys() {
+	const scope = globalThis;
+	if (scope[KEYS_KEY]) return scope[KEYS_KEY];
+	const env = globalThis.process?.env;
+	const key = env?.ISLX_ACTIONS_KEY;
+	if (key) {
+		const previous = (env?.ISLX_ACTIONS_PREVIOUS_KEYS ?? "").split(",").filter(Boolean);
+		return scope[KEYS_KEY] = createActionKeys(key, previous);
+	}
+	const buildKey = getBuildDefaults().key;
+	if (buildKey) return scope[KEYS_KEY] = createActionKeys(buildKey);
+	if (!warnedGeneratedKey && env?.NODE_ENV === "production") {
+		warnedGeneratedKey = true;
+		console.warn("[islx] ISLX_ACTIONS_KEY is not set: server actions use a key generated for this process. Pages rendered by another instance or before a restart cannot run actions that captured values. Set ISLX_ACTIONS_KEY on every instance (generateActionKey() makes one).");
+	}
+	return scope[KEYS_KEY] = createActionKeys(generateActionKey());
+}
+function settle(promise) {
+	const settled = promise;
+	settled.status = "pending";
+	settled.then((value) => {
+		settled.status = "fulfilled";
+		settled.value = value;
+	}, (reason) => {
+		settled.status = "rejected";
+		settled.reason = reason;
+	});
+	settled.catch(() => {});
+	return settled;
+}
+function capturedValues(state) {
+	if (!state.captured) return [];
+	return state.capturedValues ??= state.captured();
+}
+/** The values a reference seals, captured variables first. */
+function boundValues(state) {
+	return [...capturedValues(state), ...state.bound];
+}
+/** The nested references inside `values` whose own values are still sealing. */
+function pendingNested(values) {
+	const pending = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (!value || seen.has(value)) return;
+		seen.add(value);
+		if (typeof value === "function") {
+			const nested = references().get(value);
+			const sealed = nested && startSeal(nested);
+			if (sealed && sealed.status === "pending") pending.push(sealed);
+			return;
+		}
+		if (typeof value !== "object") return;
+		if (value instanceof Map) for (const [key, entry] of value) {
+			visit(key);
+			visit(entry);
+		}
+		else if (value instanceof Set) for (const entry of value) visit(entry);
+		else for (const entry of Object.values(value)) visit(entry);
+	};
+	values.forEach(visit);
+	return pending;
+}
+/**
+* Starts sealing a reference's bound values, if it has any. A captured value that is itself an
+* action reference is sealed first, so the outer seal carries it sealed.
+*/
+function startSeal(state) {
+	if (state.sealed !== void 0) return state.sealed;
+	if (state.token !== void 0) {
+		state.sealed = settle(Promise.resolve(state.token));
+		state.sealed.status = "fulfilled";
+		state.sealed.value = state.token;
+		return state.sealed;
+	}
+	const values = boundValues(state);
+	if (values.length === 0) return state.sealed = null;
+	const label = registry().get(state.id)?.label;
+	const names = [...state.names, ...state.bound.map((_, index) => `bound argument ${index + 1}`)];
+	state.sealed = settle((async () => {
+		const keys = await actionKeys();
+		for (let pending = pendingNested(values); pending.length > 0; pending = pendingNested(values)) await Promise.all(pending);
+		return sealBound(keys, state.id, values, {
+			names,
+			label,
+			encodeFunction: (fn) => {
+				const nested = references().get(fn);
+				if (!nested) return void 0;
+				if (nested === state) throw new TypeError("a server action cannot capture itself");
+				return referenceJson(nested.id, readSealed(nested));
+			}
+		});
+	})());
+	return state.sealed;
+}
+function referenceJson(id, sealed) {
+	return sealed === void 0 ? {
+		["$"]: "a",
+		["v"]: id
+	} : {
+		["$"]: "a",
+		["v"]: id,
+		["b"]: sealed
+	};
+}
+/**
+* The sealed values of a reference, synchronously: React reads them while it renders. While
+* they are still sealing this throws the pending promise, which React waits for (the part of the
+* page being rendered suspends, then renders again).
+*/
+function readSealed(state) {
+	const sealed = startSeal(state);
+	if (!sealed) return void 0;
+	if (sealed.status === "fulfilled") return sealed.value;
+	if (sealed.status === "rejected") throw sealed.reason;
+	throw sealed;
+}
+async function invoke(state, args) {
+	const entry = registry().get(state.id);
+	if (!entry) throw new Error(`server action ${state.id} is not registered`);
+	return runEntry(entry, state.token !== void 0 ? await openToken(state.id, state.token) : boundValues(state), args);
+}
+function runEntry(entry, values, args) {
+	if (entry.captured === 0) return entry.fn(...values, ...args);
+	return entry.fn(values.slice(0, entry.captured), ...values.slice(entry.captured), ...args);
+}
+/** A reference function: calling it runs the action, on the server too. */
+function createReference(state, base) {
+	const reference = base ?? ((...args) => invoke(state, args));
+	references().set(reference, state);
+	attachHooks(reference, state);
+	return reference;
+}
+function attachHooks(reference, state) {
+	const define = (name, value) => Object.defineProperty(reference, name, {
+		value,
+		configurable: true
+	});
+	define("$$FORM_ACTION", (prefix) => {
+		const sealed = readSealed(state);
+		const data = new FormData();
+		data.append(formFieldName(prefix, "A"), state.id);
+		if (sealed !== void 0) data.append(formFieldName(prefix, "B"), sealed);
+		return {
+			name: `${FORM_REF_PREFIX}${prefix}`,
+			action: "",
+			method: "POST",
+			encType: "multipart/form-data",
+			data
+		};
+	});
+	define("$$IS_SIGNATURE_EQUAL", (id, boundCount) => {
+		return id === state.id && boundCount === state.bound.length;
+	});
+	define("bind", function(_thisArg, ...args) {
+		if (state.token !== void 0) throw new TypeError("a server action received from the browser cannot be bound again");
+		return createReference({
+			id: state.id,
+			captured: state.captured,
+			capturedValues: state.capturedValues,
+			names: state.names,
+			bound: [...state.bound, ...args]
+		});
+	});
+}
+/**
+* Registers an export of a `"use server"` module. The export itself stays the function it was;
+* it gains the hooks forms need and an id props can name.
+*/
+function registerServerReference(action, id, label = id) {
+	if (typeof action !== "function") throw new TypeError(`${label} is exported from a "use server" module but is not a function. A "use server" module may export only async functions.`);
+	registry().set(id, {
+		fn: action,
+		captured: 0,
+		label
+	});
+	if (!references().has(action)) createReference({
+		id,
+		captured: null,
+		names: [],
+		bound: []
+	}, action);
+	return action;
+}
+/**
+* Registers an inline action the compiler hoisted to module scope. It takes the `captured`
+* variables it read as one array, then its own arguments.
+*/
+function registerInlineAction(hoisted, id, captured, label = id) {
+	const fn = captured === 0 ? (...args) => hoisted([], ...args) : hoisted;
+	registry().set(id, {
+		fn,
+		captured,
+		label
+	});
+}
+/**
+* The function an inline action stands for where it was written: calling it runs the hoisted
+* action with the captured variables, and passing it to a form or a client component sends them
+* sealed. `capture` is read when first needed, after the component has assigned them.
+*/
+function bindInlineAction(id, capture, names) {
+	return createReference({
+		id,
+		captured: names.length > 0 ? capture : null,
+		names,
+		bound: []
+	});
+}
+/** The reference a function stands for, if it is a server action. */
+function getActionReference(value) {
+	if (typeof value !== "function") return void 0;
+	const state = references().get(value);
+	if (!state) return void 0;
+	return {
+		id: state.id,
+		sealed: () => readSealed(state),
+		ready: async () => {
+			await startSeal(state);
+		}
+	};
+}
+/** Encodes a server action for JSON (`encode`'s `encodeFunction`), or undefined for any other function. */
+function encodeActionReference(value) {
+	const reference = getActionReference(value);
+	return reference && referenceJson(reference.id, reference.sealed());
+}
+async function openToken(id, token) {
+	return unsealBound(await actionKeys(), id, token, { decodeReference: decodeNestedReference });
+}
+/** A reference inside sealed values: it stays sealed until it runs. */
+function decodeNestedReference(object) {
+	if (object["$"] !== "a" || typeof object["v"] !== "string") return void 0;
+	const id = object["v"];
+	const token = object["b"];
+	if (token !== void 0 && typeof token !== "string") return void 0;
+	return createReference({
+		id,
+		captured: null,
+		names: [],
+		bound: [],
+		token
+	});
+}
+/**
+* Decodes an action reference the browser sent back (an argument): an id this server registered,
+* whose sealed values open when it runs. Unknown ids are refused.
+*/
+function decodeActionReference(object) {
+	if (object["$"] !== "a" || typeof object["v"] !== "string") return void 0;
+	if (!registry().has(object["v"])) return void 0;
+	return decodeNestedReference(object);
+}
+/** Finds the action an id names, and opens its sealed values. */
+async function resolveAction(id, token) {
+	const entry = registry().get(id);
+	if (!entry) return {
+		ok: false,
+		reason: "unknown"
+	};
+	let values = [];
+	if (token !== void 0) try {
+		values = await openToken(id, token);
+	} catch (error) {
+		if (error instanceof SealError) return {
+			ok: false,
+			reason: error.reason
+		};
+		throw error;
+	}
+	if (values.length < entry.captured) return {
+		ok: false,
+		reason: "invalid"
+	};
+	return {
+		ok: true,
+		boundCount: values.length - entry.captured,
+		label: entry.label,
+		run: async (args) => runEntry(entry, values, args)
+	};
+}
+export { hashValue as _, getActionReference as a, resolveAction as c, generateActionKey as d, sealBound as f, escapeScriptJson as g, addressValues as h, encodeActionReference as i, SealError as l, VALUE_MIN_LENGTH as m, configureActionKeys as n, registerInlineAction as o, unsealBound as p, decodeActionReference as r, registerServerReference as s, bindInlineAction as t, createActionKeys as u, parseHeldValues as v, selectValuesToSend as y };

package/dist/_chunks/actions-BCtIGvrP.d.mts

@@ -0,0 +1,58 @@
+import MagicString from "magic-string";
+
+// src/compiler/actions.d.ts
+/** An ESTree node with source offsets, as Rollup, Rolldown, oxc and acorn produce. */
+interface AstNode {
+  type: string;
+  start: number;
+  end: number;
+  [key: string]: any;
+}
+interface TransformActionsOptions {
+  /** The module's source. */
+  code: string;
+  /** The module's file path. */
+  id: string;
+  /** The app root: ids are made from paths relative to it, so they match on every machine. */
+  root: string;
+  /** Whether the output runs on the server or in the browser. */
+  environment: "server" | "client";
+  /** Parses JavaScript (or the language the plugin runs after) to an ESTree program. */
+  parse(code: string): AstNode;
+  /** Mixed into every id, so ids of one build are not guessable from another's. */
+  salt?: string;
+  /** The directive that marks actions, at the top of a module or a function. Default `"use server"`. */
+  directive?: string;
+  /** Where the runtime is imported from. */
+  runtime?: {
+    server?: string;
+    client?: string;
+  };
+}
+interface TransformActionsResult {
+  code: string;
+  map: ReturnType<MagicString["generateMap"]>;
+}
+/** A mistake in the source, with where it is. Bundlers show `loc` with a code frame. */
+declare class ActionCompileError extends Error {
+  readonly loc: {
+    file: string;
+    line: number;
+    column: number;
+  };
+  readonly id: string;
+  constructor(message: string, file: string, code: string, offset: number);
+}
+/**
+ * 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.
+ */
+declare function hasModuleDirective(code: string, directive: string): boolean;
+/** The id an action has on both sides: a hash of its module path from the root and its name. */
+declare function getActionId(root: string, file: string, name: string, salt?: string): string;
+/**
+ * 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.
+ */
+declare function transformActions(options: TransformActionsOptions): TransformActionsResult | null;
+export { getActionId as a, TransformActionsResult as i, AstNode as n, hasModuleDirective as o, TransformActionsOptions as r, transformActions as s, ActionCompileError as t };