@fluid-app/sites 0.0.0-stage → 0.1.1

package/dist/sites.js

@@ -0,0 +1,2241 @@
+//#region ../sites-contracts/src/routes.ts
+/** The reserved routes every frame host and site host answers. */
+const RESERVED_ROUTES = {
+	me: "/_fluid/me",
+	api: "/_fluid/api/",
+	db: "/_fluid/db",
+	fn: "/_fluid/fn/",
+	sdk: "/_fluid/sdk/v1/sites.js",
+	frame: "/_fluid/frame",
+	static: "/_fluid/static/",
+	authSignIn: "/_fluid/auth/sign-in",
+	authCallback: "/_fluid/auth/callback",
+	authSignOut: "/_fluid/auth/sign-out"
+};
+//#endregion
+//#region ../sites-contracts/src/shell.ts
+/**
+* Contracts section 2: the storefront shell (V1) and its messages with the
+* frame.
+*
+* The address bar travels on `window.postMessage`; the token, history, the
+* cart and sign-in travel on one `MessagePort` pinned to the frame host's
+* origin.
+*/
+/** The namespace every message between the shell and the frame carries. */
+const SHELL_MESSAGE_NAMESPACE = "fluid-site";
+/** The shape an address-bar fragment must have to reach the frame. */
+const ELEMENT_ID_FRAGMENT = /^#[A-Za-z0-9_.:-]{1,128}$/;
+//#endregion
+//#region ../sites-contracts/src/api.ts
+/**
+* Contracts section 6: the `/_fluid/api` scope map and the company policy.
+*
+* Site code calls the Fluid API on its own origin. `/_fluid/api/v2026-10/<path>`
+* is the Member API's `/api/member/v2026-10/<path>`, as the viewer, within the
+* site's grants.
+*/
+/** The Member API version `/_fluid/api` serves. */
+const FLUID_API_VERSION = "v2026-10";
+//#endregion
+//#region ../sites-contracts/src/query.ts
+/** The HTTP status each `DbError` code answers with. A success is 200. */
+const DB_ERROR_STATUS = {
+	validation: 400,
+	rule_denied: 403,
+	no_database: 404,
+	unique_violation: 409,
+	quota_exceeded: 429,
+	unavailable: 503,
+	timeout: 504
+};
+//#endregion
+//#region ../sites-contracts/src/fn.ts
+/** The pattern every function name matches. */
+const FN_NAME_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+//#endregion
+//#region ../sites-contracts/src/sdk.ts
+/** The error a Supabase method this SDK leaves out throws, naming the method. */
+const NOT_SUPPORTED = "not_supported";
+//#endregion
+//#region ../sites-contracts/src/credit.ts
+/**
+* Contracts section 12: FairShare links.
+*
+* The link a rep shares is a native storefront link:
+* `<storefront>/accounts/<handle>[/<path>]`, or
+* `<storefront>/<credit>/accounts/<handle>[/<path>]` to carry a sharer's
+* credit.
+*/
+/** A company-owned site's credit, and the storefront's default. */
+const DEFAULT_CREDIT = "home";
+/** The attribute that leaves a storefront link's href alone. */
+const CREDIT_OPT_OUT_ATTRIBUTE = "data-fluid-credit";
+/**
+* Public: Whether a credit has the shape Rails accepts before it checks the
+* username: 1 to 64 characters, with no "/".
+*
+* credit - The credit from the link.
+*
+* Returns true when it may be a username.
+*/
+function isCreditShaped(credit) {
+	return credit.length > 0 && credit.length <= 64 && !credit.includes("/");
+}
+//#endregion
+//#region ../sites-contracts/src/storefront.ts
+/**
+* Contracts section 12: the storefront paths a FairShare credit may lead.
+*
+* Rails serves a credited storefront page at `/<credit>/<path>` only for the
+* paths drawn in `config/routes/storefront/affiliate_pages.rb` and
+* `member_site_lists.rb`, plus the storefront's root, `/<credit>`, and a
+* member site, `/<credit>/accounts/<handle>[/<path>]`. A link the SDK or the
+* shell credits must land on one of them, so these lists are copies of the
+* routes, and a test holds each copy equal to its Ruby source.
+*/
+/**
+* The paths after `/<credit>` that Rails serves with a GET, in the order the
+* routes draw them. `:slug` stands for any one segment, whatever the route
+* names it. The root, `/<credit>`, and `/<credit>/accounts/<handle>` are not
+* here: the root is always served, and a site address has its own rule.
+*/
+const CREDITED_STOREFRONT_PATHS = [
+	"pages",
+	"pages/:slug",
+	"categories/:slug",
+	"categories",
+	"collections",
+	"collections/:slug",
+	"blog",
+	"posts/:slug",
+	"shop",
+	"join",
+	"learn-more/:slug",
+	"success",
+	"watch/:slug",
+	"libraries",
+	"libraries/:slug",
+	"enrollments",
+	"enrollments/:slug",
+	"post/:slug",
+	"media",
+	"media/:slug",
+	"page/:slug",
+	"promo/:slug",
+	"shop/:slug",
+	"products/:slug",
+	"products",
+	"library/:slug",
+	"sites"
+];
+/**
+* The member account screens, `Themes::MemberStorefront::SystemScreens.keys`,
+* in catalogue order. `/accounts/<key>` is a screen, never a site, and takes
+* no credit.
+*/
+const MEMBER_ACCOUNT_SCREEN_KEYS = [
+	"messaging",
+	"contacts",
+	"my-site",
+	"profile",
+	"orders",
+	"subscriptions",
+	"media",
+	"playlists"
+];
+/** A site handle as the `/accounts/<handle>` routes accept it. */
+const SITE_HANDLE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+/**
+* Public: Whether Rails serves a storefront path with a credit in front of it:
+* whether `/<credit>/<segments>` is a credited route.
+*
+* segments - The path's segments after the credit, decoded; `[]` is the
+*            root. An empty segment, or one holding a "/", is never served.
+*
+* Examples
+*
+*   isCreditedStorefrontPath(["shop"])
+*   # => true
+*
+*   isCreditedStorefrontPath(["accounts", "diamond-leaders"])
+*   # => true
+*
+*   isCreditedStorefrontPath(["accounts", "orders"])
+*   # => false
+*
+*   isCreditedStorefrontPath(["privacy-policy"])
+*   # => false
+*
+* Returns true when the credited path is served.
+*/
+function isCreditedStorefrontPath(segments) {
+	if (segments.some((segment) => segment === "" || segment.includes("/"))) return false;
+	const [first, second, third] = segments;
+	if (first === void 0) return true;
+	if (first === "accounts") return second !== void 0 && SITE_HANDLE.test(second) && !MEMBER_ACCOUNT_SCREEN_KEYS.includes(second) && !(third?.startsWith("_") ?? false);
+	if (segments.length > 2) return false;
+	const shape = second === void 0 ? first : `${first}/:slug`;
+	return CREDITED_STOREFRONT_PATHS.includes(shape);
+}
+//#endregion
+//#region src/errors.ts
+/**
+* The error the SDK throws when `/_fluid/*` answers with a status that is not
+* 2xx, such as 401 `sign_in_required` or 403 `scope_not_granted`.
+*/
+var FluidRequestError = class FluidRequestError extends Error {
+	/** The HTTP status. */
+	status;
+	/** The body's `error` code, such as `scope_not_granted`, or null when there is none. */
+	code;
+	/** The parsed JSON body, or null when the body is not JSON. */
+	body;
+	constructor(status, code, body) {
+		super(code === null ? `/_fluid answered ${status}` : `/_fluid answered ${status} ${code}`);
+		this.name = "FluidRequestError";
+		this.status = status;
+		this.code = code;
+		this.body = body;
+	}
+	/**
+	* Read a failed response into an error.
+	*
+	* response - A response whose status is not 2xx.
+	*
+	* Returns the error, carrying the body's `error` code when there is one.
+	*/
+	static async fromResponse(response) {
+		const body = await response.json().catch(() => null);
+		const code = typeof body === "object" && body !== null && "error" in body && typeof body.error === "string" ? body.error : null;
+		return new FluidRequestError(response.status, code, body);
+	}
+};
+/**
+* Internal: parse a 2xx JSON response, or throw `FluidRequestError`.
+*
+* Returns the parsed body.
+* Throws FluidRequestError when the status is not 2xx.
+*/
+async function readJson(response) {
+	if (!response.ok) throw await FluidRequestError.fromResponse(response);
+	return await response.json();
+}
+/**
+* The error a Supabase method that `fluid.db` leaves out throws, such as
+* `upsert`, `rpc` or a join, so the caller learns at once which one it was
+* (contracts section 11).
+*/
+var NotSupportedError = class extends Error {
+	/** Always `not_supported`. */
+	code = NOT_SUPPORTED;
+	/** The method or feature that is not supported, such as `upsert`. */
+	method;
+	constructor(method) {
+		super(`${NOT_SUPPORTED}: fluid.db does not support ${method}`);
+		this.name = "NotSupportedError";
+		this.method = method;
+	}
+};
+//#endregion
+//#region src/transport.ts
+/**
+* Internal: the transport of the page the SDK runs in, read at call time.
+*
+* holder - The page's token holder.
+*
+* Returns the transport.
+*/
+function pageTransport(holder) {
+	return {
+		origin: () => globalThis.location.origin,
+		fetch: (input, init) => globalThis.fetch(input, init),
+		token: () => holder.token(),
+		tokenSettled: () => holder.settled()
+	};
+}
+/**
+* Internal: send one request to the site's own origin once the first token
+* came, or three seconds passed, with `Authorization: Bearer <token>` when a
+* token is held.
+*
+* transport - Where to send it and with which token.
+* url - The absolute URL to call.
+* init - The request's options; an `Authorization` header already set wins.
+*
+* Returns the response.
+* Throws TypeError when the URL is not on the site's own origin, so the token
+* never leaves it.
+*/
+async function sendToOwnOrigin(transport, url, init = {}) {
+	checkOwnOrigin(transport, url);
+	await transport.tokenSettled();
+	return sendAtOnce(transport, url, init);
+}
+/**
+* Internal: send one request to the site's own origin now, without waiting
+* for the token. Only the handshake's first `/_fluid/me` goes this way.
+*
+* transport - Where to send it and with which token.
+* url - The absolute URL to call.
+* init - The request's options; an `Authorization` header already set wins.
+*
+* Returns the response.
+* Throws TypeError when the URL is not on the site's own origin.
+*/
+async function sendAtOnce(transport, url, init = {}) {
+	checkOwnOrigin(transport, url);
+	const headers = new Headers(init.headers);
+	const token = transport.token();
+	if (token !== null && !headers.has("Authorization")) headers.set("Authorization", `Bearer ${token}`);
+	return transport.fetch(url.href, {
+		...init,
+		headers
+	});
+}
+/** Throws TypeError when the URL is not on the site's own origin. */
+function checkOwnOrigin(transport, url) {
+	if (url.origin !== transport.origin()) throw new TypeError(`@fluid-app/sites calls only its own origin, not ${url.origin}`);
+}
+//#endregion
+//#region src/api.ts
+/**
+* `fluid.api`: the Fluid API, as the viewer, within the site's grants
+* (contracts sections 6 and 11).
+*
+* `/_fluid/api/v2026-10/<path>` on the site's own origin is the Member API's
+* `/api/member/v2026-10/<path>`.
+*/
+/** The path every `fluid.api` call goes under, `/_fluid/api/v2026-10`. */
+const API_PATH_PREFIX = `${RESERVED_ROUTES.api}${FLUID_API_VERSION}`;
+/**
+* Internal: the URL on the site's own origin that a Fluid API path calls.
+*
+* Throws TypeError when the path does not start with a single `/`, or does
+* not stay under `API_PATH_PREFIX` once resolved.
+*/
+function apiUrl(origin, path, query = {}) {
+	if (!path.startsWith("/") || path.startsWith("//")) throw new TypeError(`fluid.api takes a path such as "/orders", not ${JSON.stringify(path)}`);
+	const url = new URL(`${API_PATH_PREFIX}${path}`, origin);
+	if (url.origin !== origin || !url.pathname.startsWith(`${API_PATH_PREFIX}/`)) throw new TypeError(`fluid.api path ${JSON.stringify(path)} leaves ${API_PATH_PREFIX}`);
+	for (const [name, value] of Object.entries(query)) url.searchParams.append(name, value);
+	return url;
+}
+/**
+* Internal: build `fluid.api` over a transport.
+*
+* transport - The page's origin, fetch and held token.
+*
+* Returns `fluid.api`.
+*/
+function createApi(transport) {
+	return {
+		async fetch(path, init) {
+			return sendToOwnOrigin(transport, apiUrl(transport.origin(), path), init);
+		},
+		async get(path, query) {
+			return readJson(await sendToOwnOrigin(transport, apiUrl(transport.origin(), path, query), {
+				method: "GET",
+				headers: { Accept: "application/json" }
+			}));
+		}
+	};
+}
+//#endregion
+//#region src/auth.ts
+/**
+* `fluid.auth`: who is here, and sign-in and sign-out through the shell
+* (contracts sections 2 and 11).
+*/
+/**
+* Internal: build `fluid.auth` over a transport and the link to the shell.
+*
+* transport - The page's origin, fetch and held token.
+* shell - The port to the shell, when one is connected.
+*
+* Returns `fluid.auth`.
+*/
+function createAuth(transport, shell) {
+	return {
+		async me() {
+			return readJson(await sendToOwnOrigin(transport, new URL(RESERVED_ROUTES.me, transport.origin()), { headers: { Accept: "application/json" } }));
+		},
+		signIn(opts) {
+			if (!shell.postOverPort({
+				type: "sign_in",
+				returnTo: opts?.returnTo ?? null
+			})) warnNoShell("signIn");
+		},
+		async signOut(_opts) {
+			if (!shell.postOverPort({ type: "sign_out" })) warnNoShell("signOut");
+		}
+	};
+}
+/** Log that a call needs the shell's port and there is none. */
+function warnNoShell(method) {
+	console.warn(`fluid.auth.${method} does nothing here: the page is not in a Fluid storefront shell, or the shell has not connected`);
+}
+//#endregion
+//#region src/cart.ts
+/**
+* How long a cart call waits for its `cart_result` before it rejects. The
+* shell answers once FairShare's own call settles, which waits up to three
+* seconds for FairShare to start and then for the storefront's API; thirty
+* seconds is well past both, and a shell that never answers (one without the
+* relay, or a port replaced mid-call) does not leave the call pending forever.
+*/
+const CART_RESULT_TIMEOUT_MS = 3e4;
+/**
+* Internal: build `fluid.cart` over the link to the shell.
+*
+* options - The shell link, when calls may go, and the clock.
+*
+* Returns `fluid.cart`.
+*/
+function createCart(options) {
+	const { shell, ready } = options;
+	const clock = options.clock ?? {
+		setTimeout: (callback, ms) => setTimeout(callback, ms),
+		clearTimeout: (handle) => clearTimeout(handle)
+	};
+	const pending = /* @__PURE__ */ new Map();
+	const changeListeners = /* @__PURE__ */ new Set();
+	let lastId = 0;
+	shell.onPortMessage((data) => {
+		if (typeof data !== "object" || data === null) return;
+		const message = data;
+		if (message["type"] === "cart_changed") {
+			for (const listener of changeListeners) listener(message["cart"]);
+			return;
+		}
+		if (message["type"] !== "cart_result") return;
+		const id = message["id"];
+		const call = typeof id === "string" ? pending.get(id) : void 0;
+		if (call === void 0) return;
+		pending.delete(id);
+		clock.clearTimeout(call.timer);
+		if (message["ok"] === true) call.resolve(message["value"]);
+		else call.reject(new Error(typeof message["error"] === "string" ? message["error"] : "cart_failed"));
+	});
+	const send = async (op, args) => {
+		await ready();
+		lastId += 1;
+		const id = `cart-${lastId}`;
+		return new Promise((resolve, reject) => {
+			const message = {
+				type: "cart",
+				id,
+				op,
+				args
+			};
+			const timer = clock.setTimeout(() => {
+				pending.delete(id);
+				reject(/* @__PURE__ */ new Error(`fluid.cart.${op}: the shell did not answer within ${CART_RESULT_TIMEOUT_MS / 1e3} seconds`));
+			}, CART_RESULT_TIMEOUT_MS);
+			pending.set(id, {
+				resolve,
+				reject,
+				timer
+			});
+			if (shell.postOverPort(message)) return;
+			pending.delete(id);
+			clock.clearTimeout(timer);
+			reject(new Error(noShellMessage(op)));
+		});
+	};
+	const sendAndLog = (op) => {
+		send(op, []).catch((error) => console.warn(`fluid.cart.${op} failed`, error));
+	};
+	return {
+		add: (...args) => send("add", args),
+		update: (...args) => send("update", args),
+		remove: (...args) => send("remove", args),
+		get: () => send("get", []),
+		open: () => sendAndLog("open"),
+		close: () => sendAndLog("close"),
+		checkout: () => sendAndLog("checkout"),
+		onChange(listener) {
+			changeListeners.add(listener);
+			return () => void changeListeners.delete(listener);
+		}
+	};
+}
+/** Why a cart call failed with no port. */
+function noShellMessage(op) {
+	return `fluid.cart.${op} needs the storefront shell: the page is not in a Fluid storefront shell, or the shell has not connected`;
+}
+/** FairShare's declarative cart attributes, the `data-fluid-add-to-cart` family. */
+const CART_ATTRIBUTES = "[data-fluid-cart],[data-fluid-add-combined],[data-fluid-add-enrollment-pack],[data-fluid-add-to-cart]";
+/**
+* Internal: relay a click on FairShare's declarative cart attributes, read the
+* way FairShare's own script reads them (`web-widgets/src/web-components/cdn.ts`):
+*
+* - `data-fluid-add-to-cart="501"` or `"501,502"` → `add([{ variant_id, quantity, subscribe, ... }])`,
+*   with `data-fluid-quantity`, `data-fluid-subscribe` (one value, or one per
+*   variant), `data-fluid-subscription-plan-id` and `data-fluid-bundled-items`
+*   (JSON); then `open`, unless `data-fluid-open-cart-after-add="false"`.
+* - `data-fluid-cart="open"` or `"close"` → `open` or `close`.
+*
+* Enrollment packs (`data-fluid-add-enrollment-pack`, `data-fluid-add-combined`)
+* and `data-fluid-cart="toggle"` have no cart op to relay, so they log a
+* warning and do nothing.
+*
+* source - Where clicks bubble to, usually `document`.
+* cart - `fluid.cart`.
+*
+* Returns nothing.
+*/
+function relayCartClicks(source, cart) {
+	source.addEventListener("click", (event) => {
+		const clicked = event.target;
+		if (typeof clicked?.closest !== "function") return;
+		const target = clicked.closest(CART_ATTRIBUTES);
+		if (target === null) return;
+		const control = target.getAttribute("data-fluid-cart");
+		if (control === "open") cart.open();
+		else if (control === "close") cart.close();
+		else if (control !== null) console.warn(`fluid.cart has no relay for data-fluid-cart="${control}"`);
+		if (target.getAttribute("data-fluid-add-enrollment-pack") !== null || target.getAttribute("data-fluid-add-combined") !== null) {
+			console.warn("fluid.cart cannot add an enrollment pack from a site: the cart relay has no op for it");
+			return;
+		}
+		const variants = target.getAttribute("data-fluid-add-to-cart");
+		if (variants === null) return;
+		const items = readAddToCartItems(target, variants);
+		if (items === null) {
+			console.error(`fluid.cart: data-fluid-add-to-cart="${variants}" is not a comma list of variant ids`);
+			return;
+		}
+		cart.add(items).catch((error) => console.error("fluid.cart: failed to add to cart", error));
+		if (target.getAttribute("data-fluid-open-cart-after-add") !== "false") cart.open();
+	});
+}
+/**
+* Read the lines an add-to-cart element adds, as FairShare's script does.
+*
+* target - The element with `data-fluid-add-to-cart`.
+* variants - Its value, a comma list of variant ids.
+*
+* Returns the lines, or null when a variant id is not a number.
+*/
+function readAddToCartItems(target, variants) {
+	const variantIds = variants.split(",").map((id) => parseInt(id.trim(), 10));
+	if (variantIds.length === 0 || variantIds.some(Number.isNaN)) return null;
+	const quantityAttribute = target.getAttribute("data-fluid-quantity");
+	const quantity = quantityAttribute ? parseInt(quantityAttribute, 10) : 1;
+	const planAttribute = target.getAttribute("data-fluid-subscription-plan-id");
+	const parsedPlan = planAttribute ? parseInt(planAttribute.trim(), 10) : NaN;
+	const planId = Number.isNaN(parsedPlan) ? void 0 : parsedPlan;
+	const subscribeAttribute = target.getAttribute("data-fluid-subscribe");
+	const subscribeValues = subscribeAttribute ? subscribeAttribute.includes(",") ? subscribeAttribute.split(",").map((flag) => flag.trim().toLowerCase() === "true") : variantIds.map(() => subscribeAttribute.toLowerCase() === "true") : null;
+	const bundledItems = readBundledItems(target);
+	return variantIds.map((variantId, index) => ({
+		variant_id: variantId,
+		quantity,
+		subscribe: subscribeValues?.[index] ?? planId !== void 0,
+		...planId === void 0 ? {} : { subscription_plan_id: planId },
+		...bundledItems === void 0 ? {} : { bundled_items: bundledItems }
+	}));
+}
+/** `data-fluid-bundled-items`, parsed; undefined when absent or not a JSON array. */
+function readBundledItems(target) {
+	const attribute = target.getAttribute("data-fluid-bundled-items");
+	if (attribute === null) return void 0;
+	try {
+		const parsed = JSON.parse(attribute);
+		if (Array.isArray(parsed)) return parsed;
+	} catch {}
+	console.error("fluid.cart: data-fluid-bundled-items is not a JSON array");
+}
+//#endregion
+//#region src/db/or-parser.ts
+const COMPARISON_OPERATORS = new Set([
+	"eq",
+	"neq",
+	"gt",
+	"gte",
+	"lt",
+	"lte"
+]);
+const GROUP_PATTERN = /^(not\.)?(and|or)\(([\s\S]*)\)$/;
+const NUMBER_PATTERN = /^-?(0|[1-9]\d*)(\.\d+)?$/;
+/**
+* Internal: the condition a Supabase filter operator makes of a column and a
+* typed value, as `.not(column, operator, value)` and `.or(...)` name them.
+*
+* column - The column's name.
+* operator - `eq`, `neq`, `gt`, `gte`, `lt`, `lte`, `in`, `is`, `like` or
+*            `ilike`.
+* value - The value: a list for `in`, `null` for `is`, text for `like`.
+*
+* Returns the condition.
+* Throws NotSupportedError for any other operator, and for `is` with a value
+* that is not null.
+* Throws TypeError when the value does not fit the operator.
+*/
+function conditionOf(column, operator, value) {
+	if (COMPARISON_OPERATORS.has(operator)) return {
+		column,
+		op: operator,
+		value
+	};
+	switch (operator) {
+		case "in":
+			if (!Array.isArray(value)) throw new TypeError(`in on ${column} takes a list of values`);
+			return {
+				column,
+				op: "in",
+				value
+			};
+		case "is":
+			if (value !== null) throw new NotSupportedError(`is ${JSON.stringify(value)}: only is null`);
+			return {
+				column,
+				op: "is_null",
+				value: true
+			};
+		case "like":
+		case "ilike":
+			if (typeof value !== "string") throw new TypeError(`${operator} on ${column} takes a text pattern`);
+			return {
+				column,
+				op: operator,
+				value
+			};
+		default: throw new NotSupportedError(`the ${operator} filter operator`);
+	}
+}
+/**
+* Internal: read `.or(...)`'s filter string.
+*
+* text - Such as `"status.eq.open,and(priority.gt.2,owner.is.null)"`.
+*
+* Returns `{ or: [...] }`, one filter per top-level item.
+* Throws TypeError when the string cannot be read, and NotSupportedError for
+* an operator `fluid.db` leaves out.
+*/
+function parseOrFilter(text) {
+	return { or: splitItems(text).map(parseItem) };
+}
+/**
+* Internal: read a PostgREST list, `(a,b,"c,d")`, as `.not(column, "in",
+* "(a,b)")` and `in.(a,b)` write it.
+*
+* Returns the values, each read as the module comment says.
+* Throws TypeError when the text is not a parenthesised list.
+*/
+function parseList(text) {
+	if (!text.startsWith("(") || !text.endsWith(")")) throw new TypeError(`a list is written (a,b,c), not ${JSON.stringify(text)}`);
+	const inner = text.slice(1, -1);
+	return inner.trim() === "" ? [] : splitItems(inner).map(readScalar);
+}
+/** Split at the commas outside parentheses and quotes, trimming each item. */
+function splitItems(text) {
+	const items = [];
+	let depth = 0;
+	let quoted = false;
+	let start = 0;
+	for (let index = 0; index < text.length; index += 1) {
+		const character = text[index];
+		if (quoted) {
+			if (character === "\\") index += 1;
+			else if (character === "\"") quoted = false;
+		} else if (character === "\"") quoted = true;
+		else if (character === "(") depth += 1;
+		else if (character === ")") {
+			depth -= 1;
+			if (depth < 0) throw unreadable(text, "a ) with no (");
+		} else if (character === "," && depth === 0) {
+			items.push(text.slice(start, index).trim());
+			start = index + 1;
+		}
+	}
+	if (quoted) throw unreadable(text, "a \" with no closing \"");
+	if (depth !== 0) throw unreadable(text, "a ( with no )");
+	items.push(text.slice(start).trim());
+	if (items.some((item) => item === "")) throw unreadable(text, "an empty item");
+	return items;
+}
+/** One item: a nested group, or `column[.not].op.value`. */
+function parseItem(item) {
+	const group = GROUP_PATTERN.exec(item);
+	if (group !== null) {
+		const [, negated, kind, inner = ""] = group;
+		const children = splitItems(inner).map(parseItem);
+		const filter = kind === "and" ? { and: children } : { or: children };
+		return negated === void 0 ? filter : { not: filter };
+	}
+	const columnEnd = item.indexOf(".");
+	if (columnEnd <= 0) throw unreadable(item, "no column.operator.value in it");
+	const column = item.slice(0, columnEnd);
+	let rest = item.slice(columnEnd + 1);
+	const negated = rest.startsWith("not.");
+	if (negated) rest = rest.slice(4);
+	const operatorEnd = rest.indexOf(".");
+	if (operatorEnd <= 0) throw unreadable(item, "no operator.value in it");
+	const operator = rest.slice(0, operatorEnd);
+	const condition = conditionOf(column, operator, readValue(operator, rest.slice(operatorEnd + 1)));
+	return negated ? { not: condition } : condition;
+}
+/** An item's value, read for its operator. */
+function readValue(operator, raw) {
+	if (operator === "in") return parseList(raw);
+	if (operator === "like" || operator === "ilike") return unquote(raw).replaceAll("*", "%");
+	return readScalar(raw);
+}
+/** A single value: quoted text, null, a boolean, a number, or text. */
+function readScalar(raw) {
+	if (isQuoted(raw)) return unquote(raw);
+	if (raw === "null") return null;
+	if (raw === "true") return true;
+	if (raw === "false") return false;
+	if (NUMBER_PATTERN.test(raw)) {
+		const number = Number(raw);
+		if (!Number.isInteger(number) || Number.isSafeInteger(number)) return number;
+	}
+	return raw;
+}
+function isQuoted(raw) {
+	return raw.length >= 2 && raw.startsWith("\"") && raw.endsWith("\"");
+}
+/** Drop the quotes and the backslashes that escape within them. */
+function unquote(raw) {
+	return isQuoted(raw) ? raw.slice(1, -1).replaceAll(/\\(.)/g, "$1") : raw;
+}
+function unreadable(text, problem) {
+	return /* @__PURE__ */ new TypeError(`fluid.db cannot read the filter ${JSON.stringify(text)}: ${problem}`);
+}
+//#endregion
+//#region src/db/builder.ts
+/**
+* `fluid.db`: the site's database, Supabase-style (contracts sections 8 and
+* 11).
+*
+* `fluid.db.from(table)` starts a `QueryBuilder`. Each call adds to one
+* `DbRequestV1`; awaiting the builder sends it to `POST /_fluid/db` on the
+* site's own origin, with the held token, and resolves `{ data, error }`
+* whatever the HTTP status. Every Supabase method the contract leaves out,
+* such as `upsert`, joins and `rpc`, throws `NotSupportedError` naming it.
+*/
+/** The `QueryBuilder` methods Supabase has and `fluid.db` leaves out. */
+const NOT_SUPPORTED_QUERY_METHODS = [
+	"upsert",
+	"likeAllOf",
+	"likeAnyOf",
+	"ilikeAllOf",
+	"ilikeAnyOf",
+	"regexMatch",
+	"regexIMatch",
+	"isDistinct",
+	"contains",
+	"containedBy",
+	"rangeGt",
+	"rangeGte",
+	"rangeLt",
+	"rangeLte",
+	"rangeAdjacent",
+	"overlaps",
+	"textSearch",
+	"filter",
+	"abortSignal",
+	"csv",
+	"geojson",
+	"explain",
+	"rollback",
+	"returns",
+	"overrideTypes",
+	"maxAffected",
+	"setHeader",
+	"throwOnError"
+];
+/** The Supabase client methods beside `from` that `fluid.db` leaves out. */
+const NOT_SUPPORTED_DB_METHODS = [
+	"rpc",
+	"schema",
+	"channel",
+	"getChannels",
+	"removeChannel",
+	"removeAllChannels"
+];
+/** Internal: one `fluid.db.from(table)` query, built up call by call. */
+var DbQuery = class {
+	#transport;
+	#table;
+	#op;
+	#columns;
+	#count;
+	#returning = false;
+	#rows;
+	#set;
+	#filters = [];
+	#order = [];
+	#limit;
+	#offset;
+	constructor(transport, table) {
+		this.#transport = transport;
+		this.#table = table;
+	}
+	select(columns, opts) {
+		if (this.#op === "select" || this.#returning) throw new TypeError("select() is already on this query");
+		if (this.#op === void 0) {
+			this.#op = "select";
+			this.#columns = readColumns(columns);
+			this.#count = opts?.count;
+			return this;
+		}
+		if (readColumns(columns) !== void 0) throw new NotSupportedError(`select(${JSON.stringify(columns)}) after ${this.#op}: it returns every column`);
+		if (opts?.count !== void 0) throw new NotSupportedError(`count after ${this.#op}`);
+		this.#returning = true;
+		return this;
+	}
+	insert(rows) {
+		this.#begin("insert");
+		this.#rows = Array.isArray(rows) ? [...rows] : [rows];
+		return this;
+	}
+	update(set) {
+		this.#begin("update");
+		this.#set = set;
+		return this;
+	}
+	delete() {
+		this.#begin("delete");
+		return this;
+	}
+	eq(column, value) {
+		return this.#where({
+			column,
+			op: "eq",
+			value
+		});
+	}
+	neq(column, value) {
+		return this.#where({
+			column,
+			op: "neq",
+			value
+		});
+	}
+	gt(column, value) {
+		return this.#where({
+			column,
+			op: "gt",
+			value
+		});
+	}
+	gte(column, value) {
+		return this.#where({
+			column,
+			op: "gte",
+			value
+		});
+	}
+	lt(column, value) {
+		return this.#where({
+			column,
+			op: "lt",
+			value
+		});
+	}
+	lte(column, value) {
+		return this.#where({
+			column,
+			op: "lte",
+			value
+		});
+	}
+	in(column, values) {
+		return this.#where(conditionOf(column, "in", values));
+	}
+	is(column, value) {
+		return this.#where(conditionOf(column, "is", value));
+	}
+	like(column, pattern) {
+		return this.#where(conditionOf(column, "like", pattern));
+	}
+	ilike(column, pattern) {
+		return this.#where(conditionOf(column, "ilike", pattern));
+	}
+	not(column, op, value) {
+		const operand = op === "in" && typeof value === "string" ? parseList(value) : value;
+		return this.#where({ not: conditionOf(column, op, operand) });
+	}
+	or(filters) {
+		return this.#where(parseOrFilter(filters));
+	}
+	match(values) {
+		return this.#where({ and: Object.entries(values).map(([column, value]) => ({
+			column,
+			op: "eq",
+			value
+		})) });
+	}
+	order(column, opts) {
+		const nullsFirst = opts?.nullsFirst;
+		this.#order.push({
+			column,
+			ascending: opts?.ascending ?? true,
+			...nullsFirst === void 0 ? {} : { nulls: nullsFirst ? "first" : "last" }
+		});
+		return this;
+	}
+	limit(count) {
+		this.#limit = count;
+		return this;
+	}
+	range(from, to) {
+		this.#offset = from;
+		this.#limit = to - from + 1;
+		return this;
+	}
+	single() {
+		return this.#one(true);
+	}
+	maybeSingle() {
+		return this.#one(false);
+	}
+	then(onfulfilled, onrejected) {
+		return this.#send().then(onfulfilled, onrejected);
+	}
+	/**
+	* The `DbRequestV1` this query sends.
+	*
+	* Throws TypeError when the calls make no request, such as an update with
+	* no filter or an insert with a filter.
+	*/
+	#request() {
+		const op = this.#op ?? "select";
+		const table = this.#table;
+		const filter = combine(this.#filters);
+		const returning = this.#returning ? { returning: true } : {};
+		if (op === "select") return {
+			op,
+			table,
+			...this.#columns === void 0 ? {} : { columns: this.#columns },
+			...filter === void 0 ? {} : { filter },
+			...this.#order.length === 0 ? {} : { order: [...this.#order] },
+			...this.#limit === void 0 ? {} : { limit: this.#limit },
+			...this.#offset === void 0 ? {} : { offset: this.#offset },
+			...this.#count === void 0 ? {} : { count: this.#count }
+		};
+		if (this.#order.length > 0 || this.#limit !== void 0 || this.#offset !== void 0) throw new TypeError(`${op} takes no order, limit or range`);
+		if (op === "insert") {
+			if (filter !== void 0) throw new TypeError("insert takes no filter");
+			return {
+				op,
+				table,
+				rows: this.#rows ?? [],
+				...returning
+			};
+		}
+		if (filter === void 0) throw new TypeError(`${op} needs a filter, such as .eq("id", id), so it never touches every row`);
+		if (op === "update") return {
+			op,
+			table,
+			filter,
+			set: this.#set ?? {},
+			...returning
+		};
+		return {
+			op,
+			table,
+			filter,
+			...returning
+		};
+	}
+	#begin(op) {
+		if (this.#op !== void 0) throw new TypeError(`${op}() cannot follow ${this.#op}() on one query`);
+		this.#op = op;
+	}
+	#where(filter) {
+		this.#filters.push(filter);
+		return this;
+	}
+	async #send() {
+		const body = JSON.stringify(this.#request());
+		const url = new URL(RESERVED_ROUTES.db, this.#transport.origin());
+		let response;
+		try {
+			response = await sendToOwnOrigin(this.#transport, url, {
+				method: "POST",
+				headers: {
+					Accept: "application/json",
+					"Content-Type": "application/json"
+				},
+				body
+			});
+		} catch (error) {
+			return failure(`${RESERVED_ROUTES.db} could not be reached: ${String(error)}`, null);
+		}
+		const answer = await response.json().catch(() => null);
+		if (isDbResponse(answer)) return answer;
+		return failure(`${RESERVED_ROUTES.db} answered ${response.status}`, {
+			status: response.status,
+			body: answer
+		});
+	}
+	#one(required) {
+		const send = () => this.#send().then((response) => onlyRow(response, required));
+		return { then: (onfulfilled, onrejected) => send().then(onfulfilled, onrejected) };
+	}
+};
+for (const method of NOT_SUPPORTED_QUERY_METHODS) Object.defineProperty(DbQuery.prototype, method, { value: notSupported(method) });
+/**
+* Internal: build `fluid.db` over a transport.
+*
+* transport - The page's origin, fetch and held token.
+*
+* Returns `fluid.db`.
+*/
+function createDb(transport) {
+	const db = { from: (table) => new DbQuery(transport, table) };
+	for (const method of NOT_SUPPORTED_DB_METHODS) Object.defineProperty(db, method, { value: notSupported(method) });
+	return db;
+}
+function notSupported(method) {
+	return () => {
+		throw new NotSupportedError(method);
+	};
+}
+/**
+* `select`'s column list: undefined for every column, else the names.
+*
+* Throws NotSupportedError for a join, an alias, a cast or a JSON path.
+*/
+function readColumns(columns) {
+	if (columns === void 0 || columns.trim() === "*") return void 0;
+	if (columns.includes("(")) throw new NotSupportedError(`joins, as in select(${JSON.stringify(columns)})`);
+	const names = columns.split(",").map((name) => name.trim());
+	for (const name of names) if (name.includes(":") || name.includes("->")) throw new NotSupportedError(`aliases, casts and JSON paths, as in select(${JSON.stringify(columns)})`);
+	return names;
+}
+/** One filter alone, several under `and`, none as undefined. */
+function combine(filters) {
+	if (filters.length === 0) return void 0;
+	if (filters.length === 1) return filters[0];
+	return { and: [...filters] };
+}
+/**
+* Whether an answer is a well-formed `DbResponseV1`: `data` null or an array
+* of plain-object rows, `count` absent or a finite number, and `error` null
+* or a `DbError` with a known code and a string message. `details` is any
+* JSON value, as the contract types it.
+*/
+function isDbResponse(answer) {
+	if (!isPlainObject(answer)) return false;
+	if (!("data" in answer) || !("error" in answer)) return false;
+	const { data, error } = answer;
+	const dataIsRows = data === null || Array.isArray(data) && data.every(isPlainObject);
+	const countIsNumber = !("count" in answer) || typeof answer.count === "number" && Number.isFinite(answer.count);
+	return dataIsRows && countIsNumber && (error === null || isDbError(error));
+}
+function isDbError(error) {
+	return isPlainObject(error) && typeof error.code === "string" && Object.hasOwn(DB_ERROR_STATUS, error.code) && typeof error.message === "string";
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** A `DbResponseV1` for an answer that is not one: `unavailable`. */
+function failure(message, details) {
+	return {
+		data: null,
+		error: {
+			code: "unavailable",
+			message,
+			...details === null ? {} : { details }
+		}
+	};
+}
+/** `single()` and `maybeSingle()`: the one row, or an error. */
+function onlyRow(response, required) {
+	if (response.error !== null) return {
+		data: null,
+		error: response.error
+	};
+	const rows = response.data ?? [];
+	if (rows.length === 1) return {
+		data: rows[0] ?? null,
+		error: null
+	};
+	if (rows.length === 0 && !required) return {
+		data: null,
+		error: null
+	};
+	return {
+		data: null,
+		error: {
+			code: "validation",
+			message: `expected ${required ? "exactly one row" : "at most one row"}, the query returned ${rows.length}`,
+			details: { rows: rows.length }
+		}
+	};
+}
+//#endregion
+//#region src/fn.ts
+/**
+* `fluid.fn`: the site's own server functions (contracts sections 10 and 11).
+*
+* Server functions arrive after V1. Until then `/_fluid/fn/<name>` answers
+* 404 `fn_not_available`, and `fluid.fn.fetch` returns that response as it
+* is, so site code written for functions runs unchanged once they ship.
+*/
+/**
+* Internal: build `fluid.fn` over a transport.
+*
+* transport - The page's origin, fetch and held token.
+*
+* Returns `fluid.fn`.
+*/
+function createFn(transport) {
+	return { async fetch(name, init) {
+		if (name.length > 40 || !FN_NAME_PATTERN.test(name)) throw new TypeError(`fluid.fn takes a function name such as "rsvp", not ${JSON.stringify(name)}`);
+		return sendToOwnOrigin(transport, new URL(`${RESERVED_ROUTES.fn}${name}`, transport.origin()), init);
+	} };
+}
+//#endregion
+//#region src/shell/frame-session.ts
+/**
+* Internal: renew a private site's frame session cookie with each fresh
+* shell token (contracts section 5).
+*
+* `/_fluid/frame` set the cookie once, before the site's first page. The
+* cookie lives ten minutes and a token five, so the SDK posts each new token
+* to `POST /_fluid/frame`, and the gateway renews the cookie on the answer.
+*/
+/**
+* Internal: build the frame session renewer over a transport.
+*
+* transport - The page's origin and fetch.
+*
+* Returns the renewer.
+*/
+function createFrameSession(transport) {
+	return { async renew(token) {
+		try {
+			const response = await sendToOwnOrigin(transport, new URL(RESERVED_ROUTES.frame, transport.origin()), {
+				method: "POST",
+				headers: { Authorization: `Bearer ${token}` }
+			});
+			if (response.ok) return true;
+			console.warn(`@fluid-app/sites could not renew the frame session: /_fluid/frame answered ${response.status}`);
+		} catch (error) {
+			console.warn("@fluid-app/sites could not renew the frame session", error);
+		}
+		return false;
+	} };
+}
+//#endregion
+//#region src/shell/go.ts
+/**
+* Internal: follow the shell's `go` (contracts section 2, M-7 and "History:
+* only the shell adds entries").
+*
+* The shell sends `go` over the port on Back and Forward, on a re-sync after
+* a restore, and after `connect` to pass the address bar's fragment. The SDK
+* moves the site there: a fragment on the page it shows with `replaceState`
+* and a scroll, another page through the site's router when one listens on
+* `fluid.history.onGo`, else with `location.replace`.
+*/
+/**
+* Internal: read a `go` message from the port.
+*
+* data - What arrived on the port.
+*
+* Returns the message, or null when it is anything else, has the wrong
+* shape, or carries a fragment that is not an element id.
+*/
+function readGoMessage(data) {
+	if (typeof data !== "object" || data === null) return null;
+	const message = data;
+	if (message["type"] !== "go") return null;
+	const { path, hash } = message;
+	if (typeof path !== "string" || path.length === 0 || path.length > 2048) return null;
+	if (hash !== null && (typeof hash !== "string" || !ELEMENT_ID_FRAGMENT.test(hash))) return null;
+	return {
+		type: "go",
+		path,
+		hash
+	};
+}
+/**
+* Internal: move the frame to the page a `go` names.
+*
+* go - The message.
+* options - The page, the address bar, the unpatched `replaceState`, and the
+*           site's router listeners.
+*
+* Returns nothing. A path that resolves off the frame's own origin is
+* ignored.
+*/
+function followGo(go, options) {
+	const { page, addressBar, replaceState, routers } = options;
+	const here = new URL(page.href());
+	let target;
+	try {
+		target = new URL(go.path, here.origin);
+	} catch {
+		return;
+	}
+	if (target.origin !== here.origin) return;
+	const path = `${target.pathname}${target.search}`;
+	const fragment = go.hash ?? "";
+	addressBar.following(path);
+	if (path === `${here.pathname}${here.search}`) {
+		replaceState(page.history.state, "", `${path}${fragment}`);
+		if (go.hash !== null) page.scrollToId(go.hash.slice(1));
+		return;
+	}
+	if (routers.length > 0) {
+		for (const router of routers) router(path, go.hash);
+		return;
+	}
+	page.replaceLocation(`${path}${fragment}`);
+}
+//#endregion
+//#region src/me.ts
+/**
+* Internal: the page's first `/_fluid/me`, read once at load with no token
+* (contracts section 11, "The handshake").
+*
+* The handshake reads `shellOrigins` from it, and `fluid.storefront` reads
+* `storefrontUrl` and the credit from it, so a page sends it once.
+*/
+const firstAnswers = /* @__PURE__ */ new WeakMap();
+/**
+* Internal: read `/_fluid/me` now, without waiting for the token, once per
+* transport.
+*
+* transport - The page's origin and fetch.
+*
+* Returns the parsed answer, or null when the call fails or answers with a
+* status that is not 2xx.
+*/
+function readMeAtOnce(transport) {
+	let answer = firstAnswers.get(transport);
+	if (answer === void 0) {
+		answer = sendMe(transport);
+		firstAnswers.set(transport, answer);
+	}
+	return answer;
+}
+async function sendMe(transport) {
+	try {
+		const response = await sendAtOnce(transport, new URL(RESERVED_ROUTES.me, transport.origin()), { headers: { Accept: "application/json" } });
+		if (!response.ok) return null;
+		return await response.json();
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/storefront.ts
+/**
+* `fluid.storefront`: the company's storefront, as the SDK sees it, and the
+* visit's FairShare credit carried back to it (contracts sections 2, 11 and
+* 12).
+*
+* A link to the storefront cannot open from the frame: the sandbox refuses
+* `target="_top"`, and a plain link would load the storefront inside the
+* frame. So the SDK tells such a link apart, and hands its path to the shell
+* in a `navigate-top` message (shell/links.ts).
+*
+* The address carries the visit's credit as the storefront's own `/:credit`
+* links do: `https://yoli.com/janedoe/shop`. `fluid.storefront.url` builds
+* one, and in a V1 frame the SDK rewrites the page's storefront links into
+* that form on load and as the page changes, so a link opened in a new tab
+* keeps the credit too.
+*
+* No credit, or the storefront's default `home`, adds no prefix: Rails reads
+* `/shop` and `/home/shop` alike (`FluidCreditConcern`). A credit goes only
+* on a path Rails serves with one (`isCreditedStorefrontPath`), so a path the
+* storefront serves only without a credit, such as `/cart`, stays reachable.
+*/
+/**
+* Internal: build `fluid.storefront`.
+*
+* options - The transport and the shell's credit.
+*
+* Returns `fluid.storefront`.
+*/
+function createStorefront(options) {
+	const { transport, portCredit } = options;
+	return { async url(path) {
+		await transport.tokenSettled();
+		const visit = readStorefrontVisit(await readMeAtOnce(transport));
+		if (visit === null) throw new Error("fluid.storefront.url needs the storefront's address, and /_fluid/me gave none");
+		const address = new URL(path, `${visit.storefrontOrigin}/`);
+		if (address.origin !== visit.storefrontOrigin) throw new TypeError(`fluid.storefront.url takes a storefront path such as "/shop", not ${JSON.stringify(path)}`);
+		const credit = portCredit() ?? visit.credit;
+		return creditedHref(address.href, [visit.storefrontOrigin], credit) ?? address.href;
+	} };
+}
+/**
+* Internal: read the storefront from a `/_fluid/me` answer.
+*
+* answer - The parsed answer, unchecked.
+*
+* Returns the visit, or null when the answer has no usable `storefrontUrl`.
+*/
+function readStorefrontVisit(answer) {
+	if (typeof answer !== "object" || answer === null) return null;
+	const { storefrontUrl, shellOrigins, credit } = answer;
+	const storefrontOrigin = originOf(storefrontUrl);
+	if (storefrontOrigin === null) return null;
+	return {
+		storefrontOrigin,
+		origins: storefrontOrigins(storefrontUrl, Array.isArray(shellOrigins) ? shellOrigins.filter((origin) => typeof origin === "string") : []),
+		credit: typeof credit === "string" && credit !== "" ? credit : null
+	};
+}
+/**
+* Internal: a storefront link's address carrying the credit, or null to
+* leave it as it is.
+*
+* Only a path Rails serves with a credit takes one
+* (`isCreditedStorefrontPath`): the root, a credited page such as `/shop`
+* or `/products/tea`, and a member site at `/accounts/<handle>`. Every other
+* path, such as `/cart`, `/privacy-policy`, `/my/janedoe` or the account
+* screen `/accounts/orders`, is served only without one and stays as written.
+*
+* href - The link's address, absolute.
+* origins - The storefront's origins.
+* credit - The visit's credit, or null.
+*
+* Examples
+*
+*   creditedHref("https://yoli.com/shop", ["https://yoli.com"], "janedoe")
+*   # => "https://yoli.com/janedoe/shop"
+*
+*   creditedHref("https://yoli.com/home/shop", ["https://yoli.com"], "janedoe")
+*   # => "https://yoli.com/janedoe/shop"
+*
+*   creditedHref("https://yoli.com/janedoe/shop", ["https://yoli.com"], "janedoe")
+*   # => null
+*
+*   creditedHref("https://yoli.com/privacy-policy", ["https://yoli.com"], "janedoe")
+*   # => null
+*
+* Returns the credited address, or null when the link goes elsewhere,
+* already carries the credit, has no credited route, or there is no credit
+* to add. A link carrying the default `home` has it swapped for the credit,
+* as the storefront's own links do (`LinkableUrlGenerator`), when the
+* credited path is served; `/home/blog/<slug>`, whose credited article is
+* `/<credit>/posts/<slug>`, is left alone.
+*/
+function creditedHref(href, origins, credit) {
+	if (credit === null || isDefaultCredit(credit)) return null;
+	let url;
+	try {
+		url = new URL(href);
+	} catch {
+		return null;
+	}
+	if (!origins.includes(url.origin)) return null;
+	const written = url.pathname.split("/").slice(1);
+	const trailingSlash = written.length > 1 && written.at(-1) === "";
+	if (trailingSlash || written.length === 1 && written[0] === "") written.pop();
+	const [first] = written.map(decodeSegment);
+	if (first?.toLowerCase() === credit.toLowerCase()) return null;
+	const path = first !== void 0 && isDefaultCredit(first) ? written.slice(1) : written;
+	if (!isCreditedStorefrontPath(path.map(decodeSegment))) return null;
+	url.pathname = [
+		"",
+		encodeURIComponent(credit),
+		...path,
+		...trailingSlash ? [""] : []
+	].join("/");
+	return url.href;
+}
+/** Whether a credit is the storefront's default, `home`. */
+function isDefaultCredit(credit) {
+	return credit.toLowerCase() === DEFAULT_CREDIT;
+}
+/** A path segment, decoded; one that does not decode stays as it is. */
+function decodeSegment(segment) {
+	try {
+		return decodeURIComponent(segment);
+	} catch {
+		return segment;
+	}
+}
+/**
+* Internal: rewrite the page's storefront links into their credited form,
+* once `/_fluid/me` answers, as links are added or changed, and again each
+* time a new credit arrives. A link with `data-fluid-credit="off"` keeps its
+* `href`. A link the site changes afterwards is read afresh.
+*
+* options - The page, the `/_fluid/me` answer, the shell's credit, and how
+*           to hear of a new one.
+*
+* Returns a promise that resolves once the first pass has run.
+*/
+async function creditStorefrontLinks(options) {
+	const { page, portCredit, onCredit } = options;
+	const visit = readStorefrontVisit(await options.me);
+	if (visit === null) return;
+	const rewrites = /* @__PURE__ */ new WeakMap();
+	const rewrite = (links) => {
+		const credit = portCredit() ?? visit.credit;
+		for (const link of links) {
+			const href = link.getAttribute("href");
+			if (href === null) continue;
+			const earlier = rewrites.get(link);
+			const ours = earlier !== void 0 && earlier.written === href;
+			const original = ours ? earlier.original : href;
+			const credited = link.getAttribute("data-fluid-credit")?.trim().toLowerCase() === "off" ? null : creditedHref(absolute(original, link.baseURI), visit.origins, credit);
+			if (credited === null) {
+				if (ours) link.setAttribute("href", original);
+				rewrites.delete(link);
+				continue;
+			}
+			if (credited !== href) link.setAttribute("href", credited);
+			rewrites.set(link, {
+				original,
+				written: credited
+			});
+		}
+	};
+	page.onLinksChange(rewrite);
+	onCredit(() => rewrite(page.links()));
+	rewrite(page.links());
+}
+/** An `href` resolved against its base, or the `href` as it is when it does not resolve. */
+function absolute(href, base) {
+	try {
+		return new URL(href, base).href;
+	} catch {
+		return href;
+	}
+}
+const LINK_SELECTOR = "a[href], area[href]";
+/**
+* Internal: the credit link page of a real document.
+*
+* document - The frame's document.
+*
+* Returns the page.
+*/
+function browserCreditLinkPage(document) {
+	return {
+		links: () => document.querySelectorAll(LINK_SELECTOR),
+		onLinksChange(listener) {
+			const root = document.documentElement;
+			if (root === null || typeof MutationObserver === "undefined") return;
+			new MutationObserver((records) => {
+				const changed = /* @__PURE__ */ new Set();
+				for (const record of records) {
+					if (record.type === "attributes") {
+						if (record.target instanceof Element) changed.add(record.target);
+						continue;
+					}
+					for (const node of record.addedNodes) {
+						if (!(node instanceof Element)) continue;
+						if (node.matches(LINK_SELECTOR)) changed.add(node);
+						for (const link of node.querySelectorAll(LINK_SELECTOR)) changed.add(link);
+					}
+				}
+				listener([...changed].filter((element) => element.matches(LINK_SELECTOR)));
+			}).observe(root, {
+				subtree: true,
+				childList: true,
+				attributes: true,
+				attributeFilter: ["href", CREDIT_OPT_OUT_ATTRIBUTE]
+			});
+		}
+	};
+}
+/**
+* Internal: the storefront's origins, from a `/_fluid/me` answer: the origin
+* of `storefrontUrl`, then every shell origin, each once.
+*
+* storefrontUrl - `storefrontUrl` as `/_fluid/me` answered it, unchecked.
+* shellOrigins - The storefront origins that may frame the site.
+*
+* Examples
+*
+*   storefrontOrigins("https://yoli.com/", ["https://yoli.com", "https://shop.yoli.com"])
+*   # => ["https://yoli.com", "https://shop.yoli.com"]
+*
+* Returns the origins; a `storefrontUrl` that is not a URL adds none.
+*/
+function storefrontOrigins(storefrontUrl, shellOrigins) {
+	const origins = /* @__PURE__ */ new Set();
+	const primary = originOf(storefrontUrl);
+	if (primary !== null) origins.add(primary);
+	for (const origin of shellOrigins) {
+		const shellOrigin = originOf(origin);
+		if (shellOrigin !== null) origins.add(shellOrigin);
+	}
+	return [...origins];
+}
+/**
+* Internal: the path a `navigate-top` message carries for a link, when the
+* link points at the storefront.
+*
+* href - The link's absolute address.
+* origins - The storefront's origins.
+*
+* Examples
+*
+*   storefrontPath("https://yoli.com/shop?c=2#top", ["https://yoli.com"])
+*   # => "/shop?c=2#top"
+*
+*   storefrontPath("https://other.test/shop", ["https://yoli.com"])
+*   # => null
+*
+* Returns the path, query and fragment, or null when the link goes elsewhere
+* or its path is longer than a shell message allows.
+*/
+function storefrontPath(href, origins) {
+	let url;
+	try {
+		url = new URL(href);
+	} catch {
+		return null;
+	}
+	if (!origins.includes(url.origin)) return null;
+	const path = `${url.pathname}${url.search}${url.hash}`;
+	return path.length > 2048 ? null : path;
+}
+/** The http(s) origin of a URL, or null. */
+function originOf(candidate) {
+	if (typeof candidate !== "string") return null;
+	try {
+		const url = new URL(candidate);
+		return url.protocol === "https:" || url.protocol === "http:" ? url.origin : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/shell/links.ts
+/**
+* Internal: links in a V1 frame (contracts section 2, M-6 and "History: only
+* the shell adds entries"; section 3, "How the gateway maps a path to a
+* file").
+*
+* A plain left click on a link to another of the site's pages (no modifier
+* key, no `download`, `target` empty or `_self`) moves the frame with
+* `location.replace`, and the new page posts `navigate` (history.ts), so the
+* shell, not the frame, adds the history entry. A link to a fragment of the
+* page it shows moves with `location.replace` too, and adds no entry.
+*
+* A plain left click on a link to the storefront posts `navigate-top`, and
+* the shell opens it in the top window: the sandbox refuses `target="_top"`.
+* The shell opens it only with user activation, so a click without one, such
+* as a script's `click()`, is left to the browser rather than cancelled.
+*
+* The path is the link's `href` as it reads at the click, so a link the SDK
+* rewrote carries the visit's credit already (storefront.ts, contracts
+* section 12), and one with `data-fluid-credit="off"` carries none of the
+* SDK's.
+*
+* The target is the link's effective one, so `<base target="_blank">` keeps
+* a link opening elsewhere. Every other click is left to the browser, and so
+* is any click the site's own handlers took with `preventDefault`, even ones
+* added after the SDK (history.ts).
+*/
+/** The targets that open in the frame or, for the storefront, in the top window. */
+const SAME_FRAME_TARGETS = new Set(["", "_self"]);
+const STOREFRONT_TARGETS = new Set([
+	"",
+	"_self",
+	"_top",
+	"_parent"
+]);
+/**
+* Internal: take plain left clicks on the site's own links and on storefront
+* links.
+*
+* options - The page, the link to the shell, the address bar, and the
+*           storefront's origins as the shell connected with them.
+*
+* Returns nothing.
+*/
+function followLinkClicks(options) {
+	const { page, shell, addressBar, storefrontOrigins } = options;
+	page.onLinkClick((click) => {
+		const { link } = click;
+		if (link === null || link.download || !isPlainLeftClick(click)) return;
+		let url;
+		try {
+			url = new URL(link.href);
+		} catch {
+			return;
+		}
+		const target = link.target.trim().toLowerCase();
+		const here = new URL(page.href());
+		if (url.origin === here.origin) {
+			if (!SAME_FRAME_TARGETS.has(target)) return;
+			click.preventDefault();
+			const path = `${url.pathname}${url.search}`;
+			if (!(path === `${here.pathname}${here.search}` && url.hash !== "")) addressBar.leavingFor(path);
+			page.replaceLocation(url.href);
+			return;
+		}
+		if (!STOREFRONT_TARGETS.has(target) || !click.userActivated) return;
+		const path = storefrontPath(url.href, storefrontOrigins());
+		if (path === null) return;
+		if (shell.postToShell({
+			ns: "fluid-site",
+			v: 1,
+			type: "navigate-top",
+			path
+		})) click.preventDefault();
+	});
+}
+/** A primary-button click no one took, with no modifier key. */
+function isPlainLeftClick(click) {
+	return !click.defaultPrevented && click.button === 0 && !click.metaKey && !click.ctrlKey && !click.shiftKey && !click.altKey;
+}
+//#endregion
+//#region src/shell/history.ts
+/**
+* Internal: history and the address bar in a V1 frame (contracts section 2,
+* "History: only the shell adds entries").
+*
+* The frame never adds a history entry; the shell adds one per in-site move.
+* So the SDK turns the site's `history.pushState` into `replaceState` and
+* posts `navigate`, moves to another of its own pages with `location.replace`
+* (links.ts), reports each page and its title as `location`, and follows the
+* shell's `go` on Back and Forward (go.ts).
+*
+* A move to another document posts its `navigate` from the new document,
+* once it connects, not from the old one: a message the old document posts
+* as it unloads can reach the shell with an `event.source` that is no longer
+* the frame's window, and the shell drops it (M-1). Chromium did. So the old
+* document leaves a note in `sessionStorage`, and the new one posts
+* `navigate` before its first `location`. When `sessionStorage` refuses the
+* note, it rides in `window.name`, which outlives a same-origin move in the
+* frame; the new document restores the name. Only a page that can leave no
+* note at all posts `navigate` itself.
+*/
+/**
+* The most moves held for a shell that has not connected: past it, the last
+* one is replaced, so a runaway router cannot flood the shell's history.
+*/
+const UNSENT_MOVES_MAX = 50;
+/** How long a move note stays good: the next document loads well within it. */
+const MOVE_NOTE_TTL_MS = 1e4;
+/**
+* Internal: the frame's own path and query, as every message carries it.
+*
+* href - An absolute address on the frame host.
+*
+* Examples
+*
+*   framePath("https://acme-public.sites.fluid.app/events/42?tab=2#agenda")
+*   # => "/events/42?tab=2"
+*
+* Returns the path and query.
+*/
+function framePath(href) {
+	const url = new URL(href);
+	return `${url.pathname}${url.search}`;
+}
+/**
+* Internal: take over the frame's history. Call it only in a frame: on a
+* page with no shell the site's history is its own.
+*
+* options - The page, and the link to the shell.
+*
+* Returns `fluid.history`.
+*/
+function startHistory(options) {
+	const { page, shell } = options;
+	const history = page.history;
+	const replaceState = history.replaceState.bind(history);
+	const addressBar = createAddressBar(page, shell);
+	const routers = /* @__PURE__ */ new Set();
+	let storefrontOrigins = [];
+	history.pushState = (data, unused, url) => {
+		replaceState(data, unused, url);
+		addressBar.moved();
+	};
+	history.replaceState = (data, unused, url) => {
+		replaceState(data, unused, url);
+		addressBar.corrected();
+	};
+	page.onTitleChange(() => addressBar.report());
+	shell.onConnect((connected) => {
+		storefrontOrigins = connected.storefrontOrigins;
+		addressBar.connected();
+	});
+	shell.onPortMessage((data) => {
+		const go = readGoMessage(data);
+		if (go !== null) followGo(go, {
+			page,
+			addressBar,
+			replaceState,
+			routers: [...routers]
+		});
+	});
+	followLinkClicks({
+		page,
+		shell,
+		addressBar,
+		storefrontOrigins: () => storefrontOrigins
+	});
+	return { onGo(listener) {
+		routers.add(listener);
+		return () => void routers.delete(listener);
+	} };
+}
+/**
+* Internal: the SDK's view of the shell's current entry.
+*
+* page - The frame.
+* shell - The link to the shell; a post before `connect` is dropped.
+*
+* Returns the address bar.
+*/
+function createAddressBar(page, shell) {
+	let entryPath = framePath(page.href());
+	const unsentMoves = [];
+	let lastReport = null;
+	const note = readMoveNote(page.takeNote());
+	if (note !== null && note.to === entryPath && note.from !== entryPath) unsentMoves.push(entryPath);
+	const sendNavigate = (path) => path.length > 2048 || shell.postToShell({
+		ns: "fluid-site",
+		v: 1,
+		type: "navigate",
+		path
+	});
+	const addressBar = {
+		moved() {
+			const path = framePath(page.href());
+			if (path !== entryPath) {
+				entryPath = path;
+				if (unsentMoves.length > 0 || !sendNavigate(path)) if (unsentMoves.length < UNSENT_MOVES_MAX) unsentMoves.push(path);
+				else unsentMoves[unsentMoves.length - 1] = path;
+			}
+			addressBar.report();
+		},
+		corrected() {
+			entryPath = framePath(page.href());
+			if (unsentMoves.length > 0) unsentMoves[unsentMoves.length - 1] = entryPath;
+			addressBar.report();
+		},
+		leavingFor(path) {
+			if (path === entryPath) return;
+			const moveNote = {
+				from: entryPath,
+				to: path,
+				at: Date.now()
+			};
+			entryPath = path;
+			if (!page.leaveNote(JSON.stringify(moveNote))) sendNavigate(path);
+		},
+		following(path) {
+			entryPath = path;
+			unsentMoves.length = 0;
+		},
+		report() {
+			const path = framePath(page.href());
+			if (path.length > 2048) return;
+			const title = page.title().slice(0, 200);
+			const report = JSON.stringify([path, title]);
+			if (report === lastReport) return;
+			if (shell.postToShell({
+				ns: "fluid-site",
+				v: 1,
+				type: "location",
+				path,
+				title
+			})) lastReport = report;
+		},
+		connected() {
+			while (unsentMoves.length > 0 && sendNavigate(unsentMoves[0])) unsentMoves.shift();
+			lastReport = null;
+			addressBar.report();
+		}
+	};
+	return addressBar;
+}
+/** A move note that is well formed and fresh, or null. */
+function readMoveNote(text) {
+	if (text === null) return null;
+	try {
+		const parsed = JSON.parse(text);
+		if (typeof parsed !== "object" || parsed === null) return null;
+		const { from, to, at } = parsed;
+		if (typeof from !== "string" || typeof to !== "string") return null;
+		if (typeof at !== "number") return null;
+		const age = Date.now() - at;
+		return age >= 0 && age <= MOVE_NOTE_TTL_MS ? {
+			from,
+			to,
+			at
+		} : null;
+	} catch {
+		return null;
+	}
+}
+/** The `sessionStorage` key of the move note. */
+const MOVE_NOTE_KEY = "fluid-site:move";
+/** The prefix of a move note carried in `window.name` when storage refuses it. */
+const MOVE_NOTE_NAME_PREFIX = "fluid-site:move:";
+/**
+* Internal: the history page of a real browser window.
+*
+* window - The frame's window.
+*
+* Returns the page.
+*/
+function browserHistoryPage(window) {
+	const { document } = window;
+	return {
+		href: () => window.location.href,
+		replaceLocation: (url) => window.location.replace(url),
+		history: window.history,
+		title: () => document.title,
+		onTitleChange(listener) {
+			if (typeof MutationObserver === "undefined") return;
+			new MutationObserver(listener).observe(document.head ?? document, {
+				subtree: true,
+				childList: true,
+				characterData: true
+			});
+		},
+		scrollToId: (id) => document.getElementById(id)?.scrollIntoView(),
+		onLinkClick(listener) {
+			afterSiteClickHandlers(window, (event) => listener(browserLinkClick(event, window)));
+		},
+		leaveNote(note) {
+			try {
+				window.sessionStorage.setItem(MOVE_NOTE_KEY, note);
+				return true;
+			} catch {
+				window.name = `${MOVE_NOTE_NAME_PREFIX}${JSON.stringify([note, window.name])}`;
+				return true;
+			}
+		},
+		takeNote() {
+			const named = takeNamedNote(window);
+			try {
+				const note = window.sessionStorage.getItem(MOVE_NOTE_KEY);
+				window.sessionStorage.removeItem(MOVE_NOTE_KEY);
+				return note ?? named;
+			} catch {
+				return named;
+			}
+		}
+	};
+}
+/** Take a move note from `window.name`, restoring the name it replaced, or null. */
+function takeNamedNote(window) {
+	if (!window.name.startsWith(MOVE_NOTE_NAME_PREFIX)) return null;
+	try {
+		const parsed = JSON.parse(window.name.slice(16));
+		if (Array.isArray(parsed) && typeof parsed[0] === "string" && typeof parsed[1] === "string") {
+			window.name = parsed[1];
+			return parsed[0];
+		}
+	} catch {}
+	window.name = "";
+	return null;
+}
+/**
+* Internal: run a listener on each click after every bubble-phase click
+* handler the site has on the window, including ones it added after the SDK,
+* so a site handler's `preventDefault` keeps the SDK off the link.
+*
+* A capture listener, which runs before any bubble one, adds a fresh one-shot
+* bubble listener for this click: the window's bubble listeners are read when
+* the click reaches the window again, so it runs last, still inside the click
+* and its user activation. A click whose propagation the site stops never
+* reaches it; the next click's capture listener removes it, in a microtask
+* (removing a listener mid-dispatch can cut the listener walk short), so
+* stopped clicks never pile listeners up. Only listeners of clicks whose
+* dispatch has finished are removed, so a click the site dispatches from
+* inside another click's handler leaves the outer click's listener in place.
+*
+* target - The window.
+* listener - Called with the click.
+*
+* Returns nothing.
+*/
+function afterSiteClickHandlers(target, listener) {
+	const pending = /* @__PURE__ */ new Map();
+	target.addEventListener("click", (captured) => {
+		for (const [event, stale] of pending) {
+			if (event.eventPhase !== 0) continue;
+			pending.delete(event);
+			queueMicrotask(() => target.removeEventListener("click", stale));
+		}
+		const last = (event) => {
+			if (event !== captured) return;
+			target.removeEventListener("click", last);
+			pending.delete(captured);
+			listener(event);
+		};
+		pending.set(captured, last);
+		target.addEventListener("click", last);
+	}, { capture: true });
+}
+/**
+* Internal: the browsing context a link opens in, as the browser picks it:
+* its own `target`, else the first `<base target>`, else "".
+*
+* element - The link.
+*
+* Returns the target, as written.
+*/
+function linkTarget(element) {
+	if (element.hasAttribute("target")) return element.getAttribute("target") ?? "";
+	return element.ownerDocument.querySelector("base[target]")?.getAttribute("target") ?? "";
+}
+/** A click as links.ts reads it, with the link it landed in, across shadow roots. */
+function browserLinkClick(event, window) {
+	const element = event.composedPath().find((node) => node instanceof Element && node.matches("a[href], area[href]"));
+	let href = null;
+	if (element !== void 0) try {
+		href = new URL(element.getAttribute("href") ?? "", element.baseURI).href;
+	} catch {
+		href = null;
+	}
+	return {
+		button: event.button,
+		metaKey: event.metaKey,
+		ctrlKey: event.ctrlKey,
+		shiftKey: event.shiftKey,
+		altKey: event.altKey,
+		defaultPrevented: event.defaultPrevented,
+		userActivated: window.navigator.userActivation?.isActive ?? event.isTrusted,
+		link: element === void 0 || href === null ? null : {
+			href,
+			target: linkTarget(element),
+			download: element.hasAttribute("download")
+		},
+		preventDefault: () => event.preventDefault()
+	};
+}
+//#endregion
+//#region src/shell/token.ts
+/**
+* Internal: the shell token the SDK holds in memory, and the visit's credit
+* that arrives with it (contracts sections 2 and 5).
+*
+* The token lives in a closure, never in storage, a cookie or a URL. Every
+* `/_fluid/*` call but the first `/_fluid/me` waits until the holder is
+* settled: the first `token` message arrived, or three seconds passed, or the
+* SDK learned it has no shell to wait for.
+*/
+/** How long a call waits for the first token before it goes as a guest. */
+const TOKEN_WAIT_MS = 3e3;
+/**
+* Internal: build a token holder.
+*
+* clock - The timers to wait on; defaults to the page's.
+*
+* Returns the holder.
+*/
+function createTokenHolder(clock = { setTimeout: (callback, ms) => setTimeout(callback, ms) }) {
+	let heldToken = null;
+	let visitCredit = null;
+	let waiting = false;
+	const creditListeners = [];
+	let settle = () => void 0;
+	const whenSettled = new Promise((resolve) => {
+		settle = resolve;
+	});
+	return {
+		token: () => heldToken,
+		credit: () => visitCredit,
+		onCredit(listener) {
+			creditListeners.push(listener);
+		},
+		settled: () => whenSettled,
+		startWaiting() {
+			if (waiting) return;
+			waiting = true;
+			clock.setTimeout(settle, TOKEN_WAIT_MS);
+		},
+		settleAsGuest: () => settle(),
+		receive(message) {
+			const token = message.token === "" ? null : message.token;
+			const fresh = token !== null && token !== heldToken;
+			heldToken = token;
+			const newCredit = message.credit !== visitCredit;
+			visitCredit = message.credit;
+			settle();
+			if (newCredit) for (const listener of creditListeners) listener(message.credit);
+			return fresh;
+		}
+	};
+}
+/**
+* Internal: read a `token` message from the port, or null when the message
+* is anything else or has the wrong shape.
+*
+* data - What arrived on the port.
+*
+* Returns the message, or null.
+*/
+function readTokenMessage(data) {
+	if (typeof data !== "object" || data === null) return null;
+	const message = data;
+	if (message["type"] !== "token") return null;
+	const { token, expiresAt, credit } = message;
+	if (token !== null && typeof token !== "string") return null;
+	if (expiresAt !== null && typeof expiresAt !== "string") return null;
+	if (typeof credit !== "string" || !isCreditShaped(credit)) return null;
+	return {
+		type: "token",
+		token,
+		expiresAt,
+		credit
+	};
+}
+//#endregion
+//#region src/shell/handshake.ts
+/**
+* Internal: the handshake with the V1 shell (contracts section 2, M-3).
+*
+* On load the SDK reads `/_fluid/me` at once, with no token, for
+* `shellOrigins`; then it says `hello` to `window.parent`. It accepts
+* `connect` only from `window.parent` and from an origin in `shellOrigins`,
+* keeps the port it carries, and posts every later window message to that
+* origin. Every document says `hello`, so a multi-page site runs this on each
+* page.
+*
+* The shell's script may not be listening yet when the frame first says
+* `hello`, so the SDK says it again on a short backoff until the first
+* `connect` arrives or the repeats run out. The shell answers each `hello`
+* with a fresh port, so a late `connect` replaces the port held.
+*
+* The link tells the rest of the SDK when a shell connects, with the
+* storefront origins it read from `/_fluid/me`, and hands it every port
+* message that is not a `token`, such as `cart_result` or `go`.
+*/
+/** The first wait before `hello` is said again. */
+const HELLO_FIRST_RETRY_MS = 100;
+/** The longest wait between two `hello`s. */
+const HELLO_RETRY_CAP_MS = 1e3;
+/** How long after the first `hello` the SDK keeps saying it. */
+const HELLO_RETRY_TOTAL_MS = 1e4;
+/**
+* Internal: start the handshake. A page with no parent is not in a shell:
+* the holder settles at once and calls go as a guest.
+*
+* options - The page, its transport, the token holder and the frame session.
+*
+* Returns the link to the shell; it connects later, or never.
+*/
+function startHandshake(options) {
+	const { page, transport, holder, frameSession } = options;
+	const parent = page.parent;
+	let port = null;
+	let shellOrigin = null;
+	let stopSayingHello = () => void 0;
+	const connectListeners = [];
+	const portListeners = [];
+	const link = {
+		postOverPort(message) {
+			if (port === null) return false;
+			port.postMessage(message);
+			return true;
+		},
+		postToShell(message) {
+			if (parent === null || parent === void 0 || shellOrigin === null) return false;
+			parent.postMessage(message, shellOrigin);
+			return true;
+		},
+		onConnect(listener) {
+			connectListeners.push(listener);
+		},
+		onPortMessage(listener) {
+			portListeners.push(listener);
+		}
+	};
+	if (parent === null || parent === void 0 || parent === page) {
+		holder.settleAsGuest();
+		return link;
+	}
+	const shell = parent;
+	holder.startWaiting();
+	readShellFacts(transport).then((facts) => {
+		if (facts === null) return holder.settleAsGuest();
+		page.addEventListener("message", (event) => {
+			if (event.source !== shell) return;
+			if (!facts.shellOrigins.includes(event.origin)) return;
+			if (!isConnect(event.data)) return;
+			const next = event.ports[0];
+			if (next === void 0) return;
+			stopSayingHello();
+			port?.close();
+			port = next;
+			shellOrigin = event.origin;
+			next.onmessage = ({ data }) => {
+				const tokenMessage = readTokenMessage(data);
+				if (tokenMessage === null) {
+					for (const listener of portListeners) listener(data);
+					return;
+				}
+				if (holder.receive(tokenMessage) && facts.privateSite && tokenMessage.token !== null) frameSession.renew(tokenMessage.token);
+			};
+			const connected = { storefrontOrigins: facts.storefrontOrigins };
+			for (const listener of connectListeners) listener(connected);
+		});
+		const hello = {
+			ns: SHELL_MESSAGE_NAMESPACE,
+			v: 1,
+			type: "hello"
+		};
+		stopSayingHello = sayHelloUntilConnected(() => shell.postMessage(hello, "*"));
+	});
+	return link;
+}
+/**
+* Say `hello` now, then again after 100 ms, 200 ms, 400 ms, 800 ms and every
+* second after that, until ten seconds have passed since the first.
+*
+* sayHello - Posts one `hello` to the shell.
+*
+* Returns a function that stops the repeats.
+*/
+function sayHelloUntilConnected(sayHello) {
+	let timer;
+	let elapsed = 0;
+	let wait = HELLO_FIRST_RETRY_MS;
+	const sayAgainLater = () => {
+		if (elapsed + wait > HELLO_RETRY_TOTAL_MS) return;
+		timer = setTimeout(() => {
+			elapsed += wait;
+			wait = Math.min(wait * 2, HELLO_RETRY_CAP_MS);
+			sayHello();
+			sayAgainLater();
+		}, wait);
+	};
+	sayHello();
+	sayAgainLater();
+	return () => clearTimeout(timer);
+}
+/**
+* Read `shellOrigins` from `/_fluid/me` now, with no token, whether the
+* site is private, and the storefront's origins. A guest gets no `site` on a
+* site that is not public, so no `site` means private.
+*
+* Returns the facts, or null when the call fails or the answer has no
+* origins.
+*/
+async function readShellFacts(transport) {
+	const answer = await readMeAtOnce(transport);
+	if (typeof answer !== "object" || answer === null) return null;
+	const { shellOrigins, site, storefrontUrl } = answer;
+	if (!Array.isArray(shellOrigins) || !shellOrigins.every((origin) => typeof origin === "string")) return null;
+	return {
+		shellOrigins,
+		privateSite: (typeof site === "object" && site !== null ? site["visibility"] : null) !== "public",
+		storefrontOrigins: storefrontOrigins(storefrontUrl, shellOrigins)
+	};
+}
+/** Whether a window message is the shell's `connect`. */
+function isConnect(data) {
+	if (typeof data !== "object" || data === null) return false;
+	const message = data;
+	return message["ns"] === "fluid-site" && message["v"] === 1 && message["type"] === "connect";
+}
+//#endregion
+//#region src/window.ts
+/**
+* Internal: put the SDK's namespaces on `host.fluid`.
+*
+* `host.fluid` stays a plain object: the SDK creates one when there is none,
+* merges into the one already there, and never freezes or seals it, so a
+* script loaded later, such as the Passport, can add its own namespace. A
+* `host.fluid` that is not an object is replaced; one that refuses a key
+* (frozen by an older SDK) keeps what it has.
+*
+* host - The page's global object, usually `window`.
+* namespaces - The SDK's namespaces, such as `{ auth, api }`.
+*
+* Returns the object at `host.fluid`.
+*/
+function installFluid(host, namespaces) {
+	const existing = host.fluid;
+	const target = typeof existing === "object" && existing !== null ? existing : {};
+	if (target !== existing) host.fluid = target;
+	for (const [name, namespace] of Object.entries(namespaces)) try {
+		target[name] = namespace;
+	} catch {}
+	return target;
+}
+//#endregion
+//#region src/index.ts
+/**
+* `@fluid-app/sites`: the member-sites browser SDK (contracts section 11).
+*
+* It speaks only to the site's own origin, so it works the same on a V1 frame
+* host and a V2 site host. Importing it puts `fluid` on `window.fluid`,
+* merged into any `window.fluid` already there, and, in a V1 frame, starts
+* the handshake with the shell that hands it the viewer's token, relays cart
+* calls and FairShare's add-to-cart clicks to the shell, leaves history
+* entries to the shell, and makes the page's storefront links carry the
+* visit's FairShare credit.
+*
+* ```ts
+* import { fluid } from "@fluid-app/sites";
+*
+* const me = await fluid.auth.me();
+* const orders = await fluid.api.get("/orders", { page: "1" });
+* const { data, error } = await fluid.db
+*   .from("rsvps")
+*   .select("name,guests")
+*   .eq("event_id", eventId);
+* ```
+*/
+const holder = createTokenHolder();
+const transport = pageTransport(holder);
+const shell = typeof window === "undefined" ? noShell() : startHandshake({
+	page: window,
+	transport,
+	holder,
+	frameSession: createFrameSession(transport)
+});
+/** The SDK, also at `window.fluid`. */
+const fluid = {
+	auth: createAuth(transport, shell),
+	api: createApi(transport),
+	db: createDb(transport),
+	fn: createFn(transport),
+	cart: createCart({
+		shell,
+		ready: () => holder.settled()
+	}),
+	history: isFramed() ? startHistory({
+		page: browserHistoryPage(window),
+		shell
+	}) : { onGo: () => () => void 0 },
+	storefront: createStorefront({
+		transport,
+		portCredit: holder.credit
+	})
+};
+if (typeof document !== "undefined") relayCartClicks(document, fluid.cart);
+if (isFramed() && typeof document !== "undefined") creditStorefrontLinks({
+	page: browserCreditLinkPage(document),
+	me: readMeAtOnce(transport),
+	portCredit: holder.credit,
+	onCredit: holder.onCredit
+});
+if (typeof window !== "undefined") installFluid(window, { ...fluid });
+/** Outside a browser there is no shell: calls go as a guest at once. */
+function noShell() {
+	holder.settleAsGuest();
+	return {
+		postOverPort: () => false,
+		postToShell: () => false,
+		onConnect: () => void 0,
+		onPortMessage: () => void 0
+	};
+}
+/**
+* Whether the page runs in a frame, as in a V1 shell. A top-level page, and
+* every V2 page, keeps its own history.
+*/
+function isFramed() {
+	return typeof window !== "undefined" && window.parent !== void 0 && window.parent !== null && window.parent !== window;
+}
+//#endregion
+export { API_PATH_PREFIX, CART_RESULT_TIMEOUT_MS, FluidRequestError, NotSupportedError, fluid };