@farm.js/islx 0.0.0-stage → 0.0.1

package/dist/_chunks/tree-fID6sz25.d.mts

@@ -0,0 +1,102 @@
+import { t as ValueStore } from "./value-store-Dm-7xJ6W.mjs";
+import { n as IslandStrategy } from "./schedule-Dw14dW0H.mjs";
+import * as React from "react";
+
+// src/react/island.d.ts
+
+interface ClientReference {
+  src: string;
+  exportName: string;
+  Component: React.ComponentType<any>;
+}
+/** The module export an island component renders, or undefined for any other type. */
+declare function getClientReference(type: unknown): ClientReference | undefined;
+/**
+ * Makes `element`'s client components part of the React root around it (a layout that hydrates
+ * as one root), instead of islands of their own.
+ */
+declare function withinClientRoot(element: React.ReactNode): React.ReactElement;
+/**
+ * Starts islands again below a `withinClientRoot`: the page a hydrating layout keeps as server
+ * HTML renders its client components as islands of their own.
+ */
+declare function isolateIslands(element: React.ReactNode): React.ReactElement;
+/**
+ * For a framework that knows the request being rendered without React context (a request store):
+ * returns the render's settings when no `IslandsProvider` or `renderToStream` gave them. Keep the
+ * same `sent` set for the whole response.
+ */
+declare function setRenderStateResolver(resolve: (() => IslandRenderState | null) | undefined): void;
+/**
+ * Gives islands a render's settings when the framework renders the page itself (not through
+ * `renderToStream`): which values the browser holds, and which this render already wrote.
+ */
+declare function IslandsProvider({
+  held,
+  children
+}: {
+  held?: ReadonlySet<string> | null;
+  children?: React.ReactNode;
+}): React.ReactElement;
+/** The render's settings, from `renderToStream`. */
+interface IslandRenderState {
+  /** Value keys the browser holds; null sends every value (a cacheable response). */
+  held: ReadonlySet<string> | null;
+  /**
+   * Value keys this render already wrote. Every value script lands in the document before the
+   * runtime runs, so an island later in the render, or in a boundary that streams later, finds it.
+   */
+  sent: Set<string>;
+}
+/**
+ * Wraps a client component so the server renders it as an island. `src` is the module the browser
+ * imports, `exportName` the component's export there.
+ */
+declare function createIsland<P extends object>(Component: React.ComponentType<P>, src: string, exportName: string, strategy?: IslandStrategy): React.ComponentType<P>;
+/**
+ * Marks a navigation response that carries only the page's payload. The browser rebuilds such a
+ * page in its layout's React root and never shows its HTML, so the server leaves the HTML out.
+ */
+declare const PAYLOAD_ONLY_ATTRIBUTE = "partial";
+interface ServerTreeRenderOptions {
+  /**
+   * Renders a part the resolver cannot represent, as server HTML whose client components are
+   * islands. Default `isolateIslands`.
+   */
+  isolate?(element: React.ReactNode): React.ReactNode;
+  /** Value keys the browser holds (`parseHeldValues(request)`): the payload leaves them out. */
+  held?: ReadonlySet<string> | null;
+  /**
+   * A navigation the browser renders in its layout's React root: send the payload, the chunks it
+   * streams and the server HTML parts it cannot represent, without the page's rendered HTML.
+   */
+  payloadOnly?: boolean;
+}
+/**
+ * Resolves a server page and returns what renders in its place: the resolved tree and its
+ * payload. Errors from the page's own code (a framework's redirect or not-found) propagate
+ * unchanged. Suspense children resolve concurrently and stream as React renders them.
+ * Needs `@farm.js/islx/react/server` imported (large values and actions are encoded there).
+ */
+declare function renderServerTree(element: React.ReactNode, options?: ServerTreeRenderOptions): Promise<React.ReactElement>;
+/** Re-renders mounted server trees that render a hot-updated client module. */
+declare function updateServerTrees(src: string, module: Record<string, unknown>): number;
+interface ServerTreeElementOptions {
+  /** Imports a client module, as the hydration runtime's `load`. */
+  load(src: string): Promise<Record<string, unknown>>;
+  /**
+   * Renders an `<f-html>` part from its server HTML and hydrates its islands:
+   * `createServerHtml(runtime)`.
+   */
+  ServerHtml: React.ComponentType<any>;
+  /** Remounts the page's client components when it changes, as a navigation does. */
+  key?: string;
+  /** The value store. Default: the page's. */
+  values?: Pick<ValueStore, "ingest" | "resolve">;
+}
+/**
+ * Rebuilds a server-tree page in the browser from its server HTML (an element, or the HTML of a
+ * navigation), after loading its client modules. Returns null for a page without a tree.
+ */
+declare function createServerTreeElement(source: ParentNode | string, options: ServerTreeElementOptions): Promise<React.ReactElement | null>;
+export { renderServerTree as a, IslandRenderState as c, getClientReference as d, isolateIslands as f, createServerTreeElement as i, IslandsProvider as l, withinClientRoot as m, ServerTreeElementOptions as n, updateServerTrees as o, setRenderStateResolver as p, ServerTreeRenderOptions as r, ClientReference as s, PAYLOAD_ONLY_ATTRIBUTE as t, createIsland as u };

package/dist/_chunks/value-store-Dm-7xJ6W.d.mts

@@ -0,0 +1,19 @@
+interface ValueStore {
+  /** Reads the value scripts under `root` that the store does not hold yet. */
+  ingest(root: ParentNode): void;
+  /**
+   * Replaces value references in parsed JSON with the values they name. Other tags stay as they
+   * are, for the codec to decode afterwards.
+   */
+  resolve(value: unknown): unknown;
+  /** The `F-Values` header value naming the keys the store holds, or undefined. */
+  heldHeader(): string | undefined;
+  /** Forgets every value, as after a full page load. */
+  clear(): void;
+}
+declare function createValueStore(): ValueStore;
+/** The page's value store, shared by every copy of islx on the page. */
+declare function getValueStore(): ValueStore;
+/** Headers a navigation sends so the server can leave out values the browser holds. */
+declare function valueHeaders(): Record<string, string>;
+export { valueHeaders as i, createValueStore as n, getValueStore as r, ValueStore as t };

package/dist/_chunks/wire-C3Rpbwl6.d.mts

@@ -0,0 +1,98 @@
+/**
+ * The names islx writes into HTML, JSON and headers, and reads back. Elements, script types and
+ * headers carry the `f` prefix; JSON uses one reserved key, `$`, whose value is a short tag. See
+ * SPEC.md for the whole format.
+ *
+ *   <f-island src="/src/toc.tsx" export="Toc" props="_R_b_" strategy="load">…</f-island>
+ *   <script type="f/props" for="_R_b_">{…props…}</script>
+ *   <script type="f/value" name="04jiw29097x8ki">…a value sent once…</script>
+ *   <f-slot name="_R_5_s0">…server output passed as children…</f-slot>
+ */
+/** The element around a client component's server HTML. */
+declare const ISLAND_ELEMENT = "f-island";
+/** The script type of an island's props; its `for` attribute names the island. */
+declare const PROPS_SCRIPT_TYPE = "f/props";
+/** The script type of a value sent once; its `name` attribute is the value's key. */
+declare const VALUE_SCRIPT_TYPE = "f/value";
+/** Set on an island once it hydrated (and its held interaction was replayed). */
+declare const HYDRATED_ATTRIBUTE = "hydrated";
+/** The element that keeps server output passed to an island as children. */
+declare const SLOT_ELEMENT = "f-slot";
+/** The script type of a page's server tree, rebuilt in the browser without the page's HTML. */
+declare const TREE_SCRIPT_TYPE = "f/tree";
+/** The script type of a server tree chunk that streamed in after the tree. */
+declare const CHUNK_SCRIPT_TYPE = "f/chunk";
+/** The element around server HTML inside a server tree. */
+declare const HTML_ELEMENT = "f-html";
+/** The script type of React's form state after a `useActionState` form post, for hydration. */
+declare const FORM_STATE_SCRIPT_TYPE = "f/form-state";
+/** The reserved JSON key whose value is a tag. */
+declare const TAG = "$";
+/** The key of a tagged object's data. */
+declare const TAG_VALUE = "v";
+/** The key of an action's sealed captured values. */
+declare const TAG_BOUND = "b";
+/** `{"$":"r","v":key}`: a value sent once, by key. */
+declare const REFERENCE_TAG = "r";
+/** `{"$":"s","v":name}`: a slot. */
+declare const SLOT_TAG = "s";
+/** `{"$":"a","v":id}` or `{"$":"a","v":id,"b":sealed}`: a server action. */
+declare const ACTION_TAG = "a";
+/** `{"$":"o","v":{…}}`: app data that has its own `$` key. */
+declare const OBJECT_TAG = "o";
+/** `{"$":"F","v":n}`: a `FormData` argument, sent as fields of a multipart call. */
+declare const FORM_DATA_TAG = "F";
+/** `{"$":"K","v":n}`: a `Blob` or `File` argument, sent as a field of a multipart call. */
+declare const BLOB_TAG = "K";
+/** The multipart field of a call's JSON (`{"a":…,"b":…}`) when it carries form data or files. */
+declare const CALL_FIELD = "$F_CALL";
+/** The multipart field name of attachment `n`, or of field `key` of `FormData` attachment `n`. */
+declare function attachmentField(index: number, key?: string): string;
+/** Request header: the value keys the browser holds. */
+declare const VALUES_HEADER = "F-Values";
+/** Request header: the layouts on screen, so the response can leave them out. */
+declare const LAYOUTS_HEADER = "F-Layouts";
+/** Request header: `tree` asks for a page's server tree without its HTML. */
+declare const RENDER_HEADER = "F-Render";
+/** Request header: the server action a client calls. */
+declare const ACTION_HEADER = "F-Action";
+/** Response header: the action id is unknown here, as after a deploy. The page should reload. */
+declare const ACTION_STALE_HEADER = "F-Action-Stale";
+/**
+ * A form or button posting a server action without JavaScript. React names the field (a hidden
+ * input for a form, the button's own name for a button) and writes the data fields after it; the
+ * last name a submission carries is the action that runs, so a clicked button wins over its form.
+ *
+ *   <input type="hidden" name="$F_REF_R_1_">
+ *   <input type="hidden" name="$F_R_1_:A" value="…action id…">
+ *   <input type="hidden" name="$F_R_1_:B" value="…sealed values…">
+ */
+declare const FORM_REF_PREFIX = "$F_REF_";
+/** A form field of the action posted under `prefix`: `A` its id, `B` its sealed values. */
+declare function formFieldName(prefix: string, field: "A" | "B"): string;
+/** Every form field the runtime owns starts with this, and is removed before an action runs. */
+declare const FORM_FIELD_PREFIX = "$F_";
+/**
+ * The action a form submission posts: the last `$F_REF_` field names it, so a clicked button
+ * wins over its form. Null for a form that posts no action.
+ */
+declare function readPostedAction(form: FormData): {
+  id: string;
+  token?: string;
+} | null;
+/** Removes the runtime's fields, so the action sees only the form's own. */
+declare function stripRuntimeFields(form: FormData): void;
+/** React's field naming which `useActionState` hook a form posted from. */
+declare const ACTION_KEY_FIELD = "$ACTION_KEY";
+/** A `FormData` argument's field for its action's sealed values, in calls from JavaScript. */
+declare const BOUND_FIELD = "$F_BOUND";
+/** A value key: 14 base-36 characters. */
+declare const VALUE_KEY_PATTERN: RegExp;
+/** Value keys a request names at most: the most recently used ones. */
+declare const MAX_HELD_VALUES = 128;
+/**
+ * The tag of a tagged object (`{"$":tag}`, `{"$":tag,"v":data}`, or an action's
+ * `{"$":"a","v":id,"b":sealed}`), or undefined for anything else.
+ */
+declare function getTag(value: unknown): string | undefined;
+export { VALUE_SCRIPT_TYPE as A, SLOT_TAG as C, TREE_SCRIPT_TYPE as D, TAG_VALUE as E, stripRuntimeFields as F, formFieldName as M, getTag as N, VALUES_HEADER as O, readPostedAction as P, SLOT_ELEMENT as S, TAG_BOUND as T, MAX_HELD_VALUES as _, BLOB_TAG as a, REFERENCE_TAG as b, CHUNK_SCRIPT_TYPE as c, FORM_REF_PREFIX as d, FORM_STATE_SCRIPT_TYPE as f, LAYOUTS_HEADER as g, ISLAND_ELEMENT as h, ACTION_TAG as i, attachmentField as j, VALUE_KEY_PATTERN as k, FORM_DATA_TAG as l, HYDRATED_ATTRIBUTE as m, ACTION_KEY_FIELD as n, BOUND_FIELD as o, HTML_ELEMENT as p, ACTION_STALE_HEADER as r, CALL_FIELD as s, ACTION_HEADER as t, FORM_FIELD_PREFIX as u, OBJECT_TAG as v, TAG as w, RENDER_HEADER as x, PROPS_SCRIPT_TYPE as y };

package/dist/_chunks/wire-CXOodE06.mjs

@@ -0,0 +1,121 @@
+// src/protocol/wire.ts
+/**
+* The names islx writes into HTML, JSON and headers, and reads back. Elements, script types and
+* headers carry the `f` prefix; JSON uses one reserved key, `$`, whose value is a short tag. See
+* SPEC.md for the whole format.
+*
+*   <f-island src="/src/toc.tsx" export="Toc" props="_R_b_" strategy="load">…</f-island>
+*   <script type="f/props" for="_R_b_">{…props…}<\/script>
+*   <script type="f/value" name="04jiw29097x8ki">…a value sent once…<\/script>
+*   <f-slot name="_R_5_s0">…server output passed as children…</f-slot>
+*/
+/** The element around a client component's server HTML. */
+const ISLAND_ELEMENT = "f-island";
+/** The script type of an island's props; its `for` attribute names the island. */
+const PROPS_SCRIPT_TYPE = "f/props";
+/** The script type of a value sent once; its `name` attribute is the value's key. */
+const VALUE_SCRIPT_TYPE = "f/value";
+/** Set on an island once it hydrated (and its held interaction was replayed). */
+const HYDRATED_ATTRIBUTE = "hydrated";
+/** The element that keeps server output passed to an island as children. */
+const SLOT_ELEMENT = "f-slot";
+/** The script type of a page's server tree, rebuilt in the browser without the page's HTML. */
+const TREE_SCRIPT_TYPE = "f/tree";
+/** The script type of a server tree chunk that streamed in after the tree. */
+const CHUNK_SCRIPT_TYPE = "f/chunk";
+/** The element around server HTML inside a server tree. */
+const HTML_ELEMENT = "f-html";
+/** The script type of React's form state after a `useActionState` form post, for hydration. */
+const FORM_STATE_SCRIPT_TYPE = "f/form-state";
+/** The reserved JSON key whose value is a tag. */
+const TAG = "$";
+/** The key of a tagged object's data. */
+const TAG_VALUE = "v";
+/** The key of an action's sealed captured values. */
+const TAG_BOUND = "b";
+/** `{"$":"r","v":key}`: a value sent once, by key. */
+const REFERENCE_TAG = "r";
+/** `{"$":"s","v":name}`: a slot. */
+const SLOT_TAG = "s";
+/** `{"$":"a","v":id}` or `{"$":"a","v":id,"b":sealed}`: a server action. */
+const ACTION_TAG = "a";
+/** `{"$":"o","v":{…}}`: app data that has its own `$` key. */
+const OBJECT_TAG = "o";
+/** `{"$":"F","v":n}`: a `FormData` argument, sent as fields of a multipart call. */
+const FORM_DATA_TAG = "F";
+/** `{"$":"K","v":n}`: a `Blob` or `File` argument, sent as a field of a multipart call. */
+const BLOB_TAG = "K";
+/** The multipart field of a call's JSON (`{"a":…,"b":…}`) when it carries form data or files. */
+const CALL_FIELD = "$F_CALL";
+/** The multipart field name of attachment `n`, or of field `key` of `FormData` attachment `n`. */
+function attachmentField(index, key) {
+	return key === void 0 ? `$F_${index}` : `$F_${index}_${key}`;
+}
+/** Request header: the value keys the browser holds. */
+const VALUES_HEADER = "F-Values";
+/** Request header: the layouts on screen, so the response can leave them out. */
+const LAYOUTS_HEADER = "F-Layouts";
+/** Request header: `tree` asks for a page's server tree without its HTML. */
+const RENDER_HEADER = "F-Render";
+/** Request header: the server action a client calls. */
+const ACTION_HEADER = "F-Action";
+/** Response header: the action id is unknown here, as after a deploy. The page should reload. */
+const ACTION_STALE_HEADER = "F-Action-Stale";
+/**
+* A form or button posting a server action without JavaScript. React names the field (a hidden
+* input for a form, the button's own name for a button) and writes the data fields after it; the
+* last name a submission carries is the action that runs, so a clicked button wins over its form.
+*
+*   <input type="hidden" name="$F_REF_R_1_">
+*   <input type="hidden" name="$F_R_1_:A" value="…action id…">
+*   <input type="hidden" name="$F_R_1_:B" value="…sealed values…">
+*/
+const FORM_REF_PREFIX = "$F_REF_";
+/** A form field of the action posted under `prefix`: `A` its id, `B` its sealed values. */
+function formFieldName(prefix, field) {
+	return `$F_${prefix}:${field}`;
+}
+/** Every form field the runtime owns starts with this, and is removed before an action runs. */
+const FORM_FIELD_PREFIX = "$F_";
+/**
+* The action a form submission posts: the last `$F_REF_` field names it, so a clicked button
+* wins over its form. Null for a form that posts no action.
+*/
+function readPostedAction(form) {
+	let prefix = null;
+	for (const key of form.keys()) if (key.startsWith("$F_REF_")) prefix = key.slice(7);
+	if (prefix === null) return null;
+	const id = form.get(formFieldName(prefix, "A"));
+	const token = form.get(formFieldName(prefix, "B"));
+	if (typeof id !== "string") return null;
+	return {
+		id,
+		token: typeof token === "string" ? token : void 0
+	};
+}
+/** Removes the runtime's fields, so the action sees only the form's own. */
+function stripRuntimeFields(form) {
+	for (const key of new Set(form.keys())) if (key.startsWith("$F_") || key === "$ACTION_KEY") form.delete(key);
+}
+/** React's field naming which `useActionState` hook a form posted from. */
+const ACTION_KEY_FIELD = "$ACTION_KEY";
+/** A `FormData` argument's field for its action's sealed values, in calls from JavaScript. */
+const BOUND_FIELD = "$F_BOUND";
+/** A value key: 14 base-36 characters. */
+const VALUE_KEY_PATTERN = /^[0-9a-z]{14}$/;
+/** Value keys a request names at most: the most recently used ones. */
+const MAX_HELD_VALUES = 128;
+/**
+* The tag of a tagged object (`{"$":tag}`, `{"$":tag,"v":data}`, or an action's
+* `{"$":"a","v":id,"b":sealed}`), or undefined for anything else.
+*/
+function getTag(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const tag = value["$"];
+	if (typeof tag !== "string") return void 0;
+	const keys = Object.keys(value);
+	if (keys.length === 1) return tag;
+	if (keys.length === 2 && "v" in value) return tag;
+	if (keys.length === 3 && tag === "a" && "v" in value && "b" in value) return tag;
+}
+export { VALUE_SCRIPT_TYPE as A, SLOT_TAG as C, TREE_SCRIPT_TYPE as D, TAG_VALUE as E, stripRuntimeFields as F, formFieldName as M, getTag as N, VALUES_HEADER as O, readPostedAction as P, SLOT_ELEMENT as S, TAG_BOUND as T, MAX_HELD_VALUES as _, BLOB_TAG as a, REFERENCE_TAG as b, CHUNK_SCRIPT_TYPE as c, FORM_REF_PREFIX as d, FORM_STATE_SCRIPT_TYPE as f, LAYOUTS_HEADER as g, ISLAND_ELEMENT as h, ACTION_TAG as i, attachmentField as j, VALUE_KEY_PATTERN as k, FORM_DATA_TAG as l, HYDRATED_ATTRIBUTE as m, ACTION_KEY_FIELD as n, BOUND_FIELD as o, HTML_ELEMENT as p, ACTION_STALE_HEADER as r, CALL_FIELD as s, ACTION_HEADER as t, FORM_FIELD_PREFIX as u, OBJECT_TAG as v, TAG as w, RENDER_HEADER as x, PROPS_SCRIPT_TYPE as y };

package/dist/client.d.mts

@@ -0,0 +1,58 @@
+import { i as valueHeaders, n as createValueStore, r as getValueStore, t as ValueStore } from "./_chunks/value-store-Dm-7xJ6W.mjs";
+import { a as hookEventName, i as defineClientHooks, n as ClientHookEvents, o as setClientHooks, r as ClientHooks, t as ClientHookEvent } from "./_chunks/hooks-De0gNpOn.mjs";
+
+// src/client/actions.d.ts
+type AnyFunction = (...args: any[]) => any;
+/** How actions reach the framework's router. */
+interface ActionNavigator {
+  /** Renders the current page again from the server, keeping client state and scroll. */
+  refresh?(): Promise<void> | void;
+  /** A client navigation to `href`, as the action's redirect. */
+  navigate?(href: string): Promise<void> | void;
+}
+/** Connects actions to the framework's router. */
+declare function setActionNavigator(navigator: ActionNavigator): void;
+/** Decodes an action in a result or props: `{"$":"a","v":id,"b"?:sealed}`. */
+declare function decodeActionReference(object: Record<string, unknown>): AnyFunction | undefined;
+/** The function that calls a server action; one per id and sealed values, so props keep identity. */
+declare function createServerReference(id: string, token?: string, name?: string): AnyFunction;
+/** Starts handling server-component forms on this page. Safe to call more than once. */
+declare function enhanceForms(): void;
+interface NavigationOptions {
+  /** Puts the fetched page in place of the current one. */
+  swap(next: Document, url: URL): void | Promise<void>;
+  /** Animates the change with `document.startViewTransition`, where the browser has it. */
+  viewTransition?: boolean;
+}
+interface NavigateOptions {
+  /** Replace the current history entry instead of adding one. */
+  replace?: boolean;
+}
+/** The `F-Render` value of a navigation: the server renders the whole page before sending it. */
+declare const NAVIGATION_RENDER = "document";
+/**
+ * Handles same-site link clicks and history from now on. Returns `navigate` for navigations the
+ * app starts itself. Safe to call more than once.
+ */
+declare function startNavigation(options: NavigationOptions): {
+  navigate(href: string, options?: NavigateOptions): Promise<void>;
+};
+/** Navigates within the site, through `startNavigation` when it runs, or by loading the page. */
+declare function navigate(href: string, options?: NavigateOptions): Promise<void>;
+/**
+ * Holding interactions that happen before the islx script has run. An inline script in the page
+ * captures a click or a submit on an island that has not hydrated (it is prevented and queued),
+ * and announces a pointerdown or a focus (which go through). The runtime then hydrates those
+ * islands first and replays what was held.
+ *
+ * The script is inlined into every page, so it stays hand-minified and imports nothing.
+ */
+/** Where the inline script queues held interactions: `{ target, kind }`. */
+declare const PENDING_INTERACTIONS = "__islxPending";
+/** The DOM event the script dispatches for each interaction it sees. */
+declare const INTERACTION_EVENT = "f:island-interaction";
+/** Elements whose click is held and replayed rather than merely observed. */
+declare const REPLAYABLE_SELECTOR = "button,[role=\"button\"],input[type=\"button\"],input[type=\"submit\"],input[type=\"reset\"]";
+/** The inline script's source (no `<script>` tag): pass it to the page's head or bootstrap. */
+declare const PREHYDRATION_SCRIPT: string;
+export { type ActionNavigator, type ClientHookEvent, type ClientHookEvents, type ClientHooks, INTERACTION_EVENT, NAVIGATION_RENDER, type NavigateOptions, type NavigationOptions, PENDING_INTERACTIONS, PREHYDRATION_SCRIPT, REPLAYABLE_SELECTOR, type ValueStore, createServerReference, createValueStore, decodeActionReference, defineClientHooks, enhanceForms, getValueStore, hookEventName, navigate, setActionNavigator, setClientHooks, startNavigation, valueHeaders };

package/dist/client.mjs

@@ -0,0 +1,197 @@
+import { a as emit, c as createValueStore, i as defineClientHooks, l as getValueStore, n as decodeActionReference, o as hookEventName, r as setActionNavigator, s as setClientHooks, t as createServerReference, u as valueHeaders } from "./_chunks/actions-CA_K-In7.mjs";
+import { F as stripRuntimeFields, P as readPostedAction, x as RENDER_HEADER } from "./_chunks/wire-CXOodE06.mjs";
+import { i as REPLAYABLE_SELECTOR, n as PENDING_INTERACTIONS, r as PREHYDRATION_SCRIPT, t as INTERACTION_EVENT } from "./_chunks/prehydration-B1GLTLdk.mjs";
+// src/client/forms.ts
+/**
+* Forms written in server components submit without reloading the page once JavaScript runs.
+* No island owns them, so nothing else would: a submit of a form that posts an action is sent as
+* a call, and the page refreshes as after any action, keeping island state. Forms inside islands
+* are React's, which handles them first.
+*/
+let enhanced = false;
+/** Starts handling server-component forms on this page. Safe to call more than once. */
+function enhanceForms() {
+	if (enhanced) return;
+	enhanced = true;
+	document.addEventListener("submit", (event) => {
+		if (event.defaultPrevented || !(event.target instanceof HTMLFormElement)) return;
+		const form = event.target;
+		const submitter = event.submitter ?? null;
+		const data = new FormData(form, submitter);
+		const posted = readPostedAction(data);
+		if (!posted) return;
+		event.preventDefault();
+		stripRuntimeFields(data);
+		form.setAttribute("aria-busy", "true");
+		createServerReference(posted.id, posted.token)(data).then(() => form.reset()).catch((error) => console.error("[islx] The form's action failed:", error)).finally(() => form.removeAttribute("aria-busy"));
+	});
+}
+// src/client/navigation.ts
+/**
+* Moving between pages without loading a new document. A click on a same-site link fetches the
+* next page (naming the values the browser holds, so the server leaves them out), and the
+* renderer swaps it in: the runtime, its loaded code and its values stay.
+*
+* Renderer-neutral: the adapter passes `swap`. Anything unusual loads the page the ordinary way:
+* a link to another site, `target`, `download`, `rel="external"`, a modifier key, a non-HTML or
+* failed response, or a page built by another deploy.
+*/
+/** The `F-Render` value of a navigation: the server renders the whole page before sending it. */
+const NAVIGATION_RENDER = "document";
+let started = null;
+/** Set by the click handler for the navigation it starts, so hooks see `kind: "link"`. */
+let clicking = false;
+/** The URL of the page's browser entry: a page from another deploy names another one. */
+function entryOf(document) {
+	return document.querySelector("script[type=\"module\"][src][async]")?.getAttribute("src") ?? null;
+}
+function isOurs(state) {
+	return !!state && typeof state === "object" && state.islx === true;
+}
+function rememberScroll() {
+	const state = {
+		islx: true,
+		scroll: [window.scrollX, window.scrollY]
+	};
+	history.replaceState({
+		...history.state,
+		...state
+	}, "");
+}
+let announcer = null;
+/** Tells screen readers the page changed, as a document load would. */
+function announce(title) {
+	if (!announcer || !announcer.isConnected) {
+		announcer = document.createElement("div");
+		announcer.setAttribute("aria-live", "assertive");
+		announcer.setAttribute("role", "status");
+		announcer.style.cssText = "position:absolute;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0,0,0,0);border:0";
+		document.body.append(announcer);
+	}
+	announcer.textContent = title;
+}
+/** Adds stylesheets the next page uses that this one has not loaded. */
+function mergeStyles(next) {
+	const loaded = new Set(Array.from(document.head.querySelectorAll("link[rel=\"stylesheet\"]"), (link) => link.href));
+	for (const link of next.head.querySelectorAll("link[rel=\"stylesheet\"]")) {
+		const href = new URL(link.getAttribute("href") ?? "", next.baseURI || location.href).href;
+		if (!loaded.has(href)) document.head.append(document.importNode(link, true));
+	}
+}
+/**
+* Handles same-site link clicks and history from now on. Returns `navigate` for navigations the
+* app starts itself. Safe to call more than once.
+*/
+function startNavigation(options) {
+	if (started) return started;
+	let current = null;
+	/** The page on screen: where a cancelled back or forward returns to. */
+	let here = new URL(location.href);
+	history.scrollRestoration = "manual";
+	rememberScroll();
+	async function go(url, push, scroll) {
+		const kind = push === "none" ? "history" : push === "push" && scroll === null && clicking ? "link" : "code";
+		clicking = false;
+		if (!emit("navigate", {
+			url,
+			from: here,
+			kind
+		})) {
+			if (push === "none") history.pushState({
+				islx: true,
+				scroll: [window.scrollX, window.scrollY]
+			}, "", here);
+			return;
+		}
+		const startedAt = performance.now();
+		current?.abort();
+		const controller = new AbortController();
+		current = controller;
+		let next;
+		let finalUrl;
+		try {
+			const response = await fetch(url, {
+				headers: {
+					accept: "text/html",
+					[RENDER_HEADER]: NAVIGATION_RENDER,
+					...valueHeaders()
+				},
+				credentials: "same-origin",
+				signal: controller.signal
+			});
+			if (!response.headers.get("content-type")?.includes("text/html")) throw new Error("not a page");
+			finalUrl = new URL(response.url || url.href);
+			if (finalUrl.origin !== location.origin) throw new Error("redirected to another site");
+			finalUrl.hash = url.hash;
+			next = new DOMParser().parseFromString(await response.text(), "text/html");
+			if (entryOf(next) !== entryOf(document)) throw new Error("built by another deploy");
+		} catch (error) {
+			if (controller.signal.aborted) return;
+			emit("navigateError", {
+				url,
+				reason: error instanceof Error ? error.message : String(error)
+			});
+			if (push === "none") location.reload();
+			else location.assign(url.href);
+			return;
+		}
+		if (controller.signal.aborted) return;
+		if (push === "push") history.pushState({
+			islx: true,
+			scroll: [0, 0]
+		}, "", finalUrl);
+		else if (push === "replace") history.replaceState({
+			islx: true,
+			scroll: [0, 0]
+		}, "", finalUrl);
+		mergeStyles(next);
+		document.title = next.title;
+		document.activeElement?.blur?.();
+		const swap = () => options.swap(next, finalUrl);
+		const transition = document.startViewTransition;
+		if (options.viewTransition && typeof transition === "function") await transition.call(document, swap).updateCallbackDone;
+		else await swap();
+		here = new URL(location.href);
+		if (scroll) window.scrollTo(scroll[0], scroll[1]);
+		else if (finalUrl.hash) document.getElementById(decodeURIComponent(finalUrl.hash.slice(1)))?.scrollIntoView();
+		else window.scrollTo(0, 0);
+		announce(next.title || finalUrl.pathname);
+		if (current === controller) current = null;
+		emit("navigated", {
+			url: finalUrl,
+			duration: performance.now() - startedAt
+		});
+	}
+	document.addEventListener("click", (event) => {
+		if (event.defaultPrevented || event.button !== 0) return;
+		if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+		const link = event.target?.closest?.("a[href]");
+		if (!(link instanceof HTMLAnchorElement)) return;
+		if (link.target && link.target !== "_self") return;
+		if (link.hasAttribute("download") || link.relList.contains("external")) return;
+		const url = new URL(link.href);
+		if (url.origin !== location.origin || !/^https?:$/.test(url.protocol)) return;
+		if (url.pathname === location.pathname && url.search === location.search && url.hash) return;
+		event.preventDefault();
+		rememberScroll();
+		clicking = true;
+		go(url, "push", null);
+	});
+	window.addEventListener("popstate", (event) => {
+		if (!isOurs(event.state)) return;
+		go(new URL(location.href), "none", event.state.scroll);
+	});
+	started = { navigate(href, navigateOptions = {}) {
+		rememberScroll();
+		return go(new URL(href, location.href), navigateOptions.replace ? "replace" : "push", null);
+	} };
+	return started;
+}
+/** Navigates within the site, through `startNavigation` when it runs, or by loading the page. */
+function navigate(href, options = {}) {
+	if (started) return started.navigate(href, options);
+	if (options.replace) location.replace(href);
+	else location.assign(href);
+	return Promise.resolve();
+}
+export { INTERACTION_EVENT, NAVIGATION_RENDER, PENDING_INTERACTIONS, PREHYDRATION_SCRIPT, REPLAYABLE_SELECTOR, createServerReference, createValueStore, decodeActionReference, defineClientHooks, enhanceForms, getValueStore, hookEventName, navigate, setActionNavigator, setClientHooks, startNavigation, valueHeaders };

package/dist/compiler.d.mts

@@ -0,0 +1,2 @@
+import { a as getActionId, i as TransformActionsResult, n as AstNode, o as hasModuleDirective, r as TransformActionsOptions, s as transformActions, t as ActionCompileError } from "./_chunks/actions-BCtIGvrP.mjs";
+export { ActionCompileError, type AstNode, type TransformActionsOptions, type TransformActionsResult, getActionId, hasModuleDirective, transformActions };

package/dist/compiler.mjs

@@ -0,0 +1 @@
+export { t as ActionCompileError, n as getActionId, r as hasModuleDirective, i as transformActions } from "./_chunks/actions-Eutk6UzT.mjs";

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { A as VALUE_SCRIPT_TYPE, C as SLOT_TAG, D as TREE_SCRIPT_TYPE, E as TAG_VALUE, F as stripRuntimeFields, M as formFieldName, N as getTag, O as VALUES_HEADER, P as readPostedAction, S as SLOT_ELEMENT, T as TAG_BOUND, _ as MAX_HELD_VALUES, a as BLOB_TAG, b as REFERENCE_TAG, c as CHUNK_SCRIPT_TYPE, d as FORM_REF_PREFIX, f as FORM_STATE_SCRIPT_TYPE, g as LAYOUTS_HEADER, h as ISLAND_ELEMENT, i as ACTION_TAG, j as attachmentField, k as VALUE_KEY_PATTERN, l as FORM_DATA_TAG, m as HYDRATED_ATTRIBUTE, n as ACTION_KEY_FIELD, o as BOUND_FIELD, p as HTML_ELEMENT, r as ACTION_STALE_HEADER, s as CALL_FIELD, t as ACTION_HEADER, u as FORM_FIELD_PREFIX, v as OBJECT_TAG, w as TAG, x as RENDER_HEADER, y as PROPS_SCRIPT_TYPE } from "./_chunks/wire-C3Rpbwl6.mjs";
+import { a as decode, c as encodeLeaf, d as plainObject, f as tagged, i as NOT_A_VALUE, l as fromBase64, n as EncodeError, o as decodeTagged, p as toBase64, r as EncodeOptions, s as encode, t as DecodeOptions, u as needsObjectTag } from "./_chunks/codec-CK8kZp4u.mjs";
+export { ACTION_HEADER, ACTION_KEY_FIELD, ACTION_STALE_HEADER, ACTION_TAG, BLOB_TAG, BOUND_FIELD, CALL_FIELD, CHUNK_SCRIPT_TYPE, type DecodeOptions, EncodeError, type EncodeOptions, FORM_DATA_TAG, FORM_FIELD_PREFIX, FORM_REF_PREFIX, FORM_STATE_SCRIPT_TYPE, HTML_ELEMENT, HYDRATED_ATTRIBUTE, ISLAND_ELEMENT, LAYOUTS_HEADER, MAX_HELD_VALUES, NOT_A_VALUE, OBJECT_TAG, PROPS_SCRIPT_TYPE, REFERENCE_TAG, RENDER_HEADER, SLOT_ELEMENT, SLOT_TAG, TAG, TAG_BOUND, TAG_VALUE, TREE_SCRIPT_TYPE, VALUES_HEADER, VALUE_KEY_PATTERN, VALUE_SCRIPT_TYPE, attachmentField, decode, decodeTagged, encode, encodeLeaf, formFieldName, fromBase64, getTag, needsObjectTag, plainObject, readPostedAction, stripRuntimeFields, tagged, toBase64 };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { A as VALUE_SCRIPT_TYPE, C as SLOT_TAG, D as TREE_SCRIPT_TYPE, E as TAG_VALUE, F as stripRuntimeFields, M as formFieldName, N as getTag, O as VALUES_HEADER, P as readPostedAction, S as SLOT_ELEMENT, T as TAG_BOUND, _ as MAX_HELD_VALUES, a as BLOB_TAG, b as REFERENCE_TAG, c as CHUNK_SCRIPT_TYPE, d as FORM_REF_PREFIX, f as FORM_STATE_SCRIPT_TYPE, g as LAYOUTS_HEADER, h as ISLAND_ELEMENT, i as ACTION_TAG, j as attachmentField, k as VALUE_KEY_PATTERN, l as FORM_DATA_TAG, m as HYDRATED_ATTRIBUTE, n as ACTION_KEY_FIELD, o as BOUND_FIELD, p as HTML_ELEMENT, r as ACTION_STALE_HEADER, s as CALL_FIELD, t as ACTION_HEADER, u as FORM_FIELD_PREFIX, v as OBJECT_TAG, w as TAG, x as RENDER_HEADER, y as PROPS_SCRIPT_TYPE } from "./_chunks/wire-CXOodE06.mjs";
+import { a as encode, c as needsObjectTag, d as toBase64, i as decodeTagged, l as plainObject, n as NOT_A_VALUE, o as encodeLeaf, r as decode, s as fromBase64, t as EncodeError, u as tagged } from "./_chunks/codec-BTDkzzPP.mjs";
+export { ACTION_HEADER, ACTION_KEY_FIELD, ACTION_STALE_HEADER, ACTION_TAG, BLOB_TAG, BOUND_FIELD, CALL_FIELD, CHUNK_SCRIPT_TYPE, EncodeError, FORM_DATA_TAG, FORM_FIELD_PREFIX, FORM_REF_PREFIX, FORM_STATE_SCRIPT_TYPE, HTML_ELEMENT, HYDRATED_ATTRIBUTE, ISLAND_ELEMENT, LAYOUTS_HEADER, MAX_HELD_VALUES, NOT_A_VALUE, OBJECT_TAG, PROPS_SCRIPT_TYPE, REFERENCE_TAG, RENDER_HEADER, SLOT_ELEMENT, SLOT_TAG, TAG, TAG_BOUND, TAG_VALUE, TREE_SCRIPT_TYPE, VALUES_HEADER, VALUE_KEY_PATTERN, VALUE_SCRIPT_TYPE, attachmentField, decode, decodeTagged, encode, encodeLeaf, formFieldName, fromBase64, getTag, needsObjectTag, plainObject, readPostedAction, stripRuntimeFields, tagged, toBase64 };