@moku-labs/web 2.2.1 → 2.3.0

package/dist/convention-CsJw7CML.cjs

@@ -0,0 +1,120 @@
+//#region src/plugins/collection/convention.ts
+/**
+* @file collection plugin — the pure URL/file convention (no `node:*`, no DOM).
+*
+* ONE function maps a `(collection, shard)` key to its shard suffix, so the browser
+* fetch URL (`baseUrl + suffix`) and the on-disk file (`outDir + "/" + suffix`) are
+* derived from the same source and cannot drift. The collection name is the top
+* directory and the shard becomes a `.json` file beneath it (its INTERNAL slashes
+* are kept as nested dirs):
+*   ("bank", "en/animals") → "bank/en/animals.json"
+*   ("bank", "ru")         → "bank/ru.json"
+*   ("/bank/", "/en/")     → "bank/en.json"  (outer slashes trimmed)
+*
+* Encoding split: the FETCH suffix ({@link shardSuffix}) keeps the key's
+* percent-encoding (the browser requests the encoded path); the FILE path
+* ({@link relativeShardFile}) decodes it so the on-disk name is literal.
+*/
+/**
+* Strip leading/trailing slashes from `collection` and `shard` (keeping the
+* shard's INTERNAL slashes as nested path segments), then join them as
+* `` `${collection}/${shard}.json` `` — the suffix shared by the fetch URL and the
+* on-disk file.
+*
+* @param collection - The collection name (e.g. `"bank"`).
+* @param shard - The shard key within the collection (e.g. `"en/animals"`).
+* @returns The shard suffix (e.g. `"bank/en/animals.json"`).
+* @example
+* ```ts
+* shardSuffix("bank", "en/animals"); // "bank/en/animals.json"
+* shardSuffix("/bank/", "/ru/");     // "bank/ru.json"
+* ```
+*/
+function shardSuffix(collection, shard) {
+	return `${trimSlashes(collection)}/${trimSlashes(shard)}.json`;
+}
+/**
+* Strip any leading and trailing slashes from a path segment, leaving its internal
+* slashes intact.
+*
+* @param segment - The raw `collection` or `shard` value.
+* @returns The segment without outer slashes.
+* @example
+* ```ts
+* trimSlashes("/en/animals/"); // "en/animals"
+* ```
+*/
+function trimSlashes(segment) {
+	let trimmed = segment;
+	while (trimmed.startsWith("/")) trimmed = trimmed.slice(1);
+	while (trimmed.endsWith("/")) trimmed = trimmed.slice(0, -1);
+	return trimmed;
+}
+/**
+* Compute the browser fetch URL for a `(collection, shard)` key: the `baseUrl`
+* prefix joined with the {@link shardSuffix}. Exported so standalone consumers can
+* derive the same URL without composing the plugin.
+*
+* @param baseUrl - The site-root URL prefix (ends with `/`, e.g. `"/"`).
+* @param collection - The collection name (e.g. `"bank"`).
+* @param shard - The shard key within the collection (e.g. `"en/animals"`).
+* @returns The site-root-relative shard URL (e.g. `/bank/en/animals.json`).
+* @example
+* ```ts
+* collectionUrl("/", "bank", "en/animals"); // "/bank/en/animals.json"
+* ```
+*/
+function collectionUrl(baseUrl, collection, shard) {
+	return `${baseUrl}${shardSuffix(collection, shard)}`;
+}
+/**
+* Decode a shard suffix's percent-escapes so the on-disk file carries the literal
+* name (servers decode the encoded fetch URL before filesystem lookup). Falls back
+* to the raw suffix on malformed escapes.
+*
+* @param suffix - The computed shard suffix (possibly percent-encoded).
+* @returns The decoded suffix, or the raw suffix on malformed escapes.
+* @example
+* ```ts
+* decodeSuffix("bank/en/a%20%26%20b.json"); // "bank/en/a & b.json"
+* ```
+*/
+function decodeSuffix(suffix) {
+	try {
+		return decodeURIComponent(suffix);
+	} catch {
+		return suffix;
+	}
+}
+/**
+* Compute the `outDir`-relative shard file for a `(collection, shard)` key — the
+* DECODED {@link shardSuffix} (servers resolve the decoded request path against
+* literal file names). The collection name IS the top directory, so there is no
+* extra output-dir wrapper. Shared by the Node writer and the pure `fileFor`
+* accessor so the written file and the reported path never drift.
+*
+* @param collection - The collection name (e.g. `"bank"`).
+* @param shard - The shard key within the collection (e.g. `"en/animals"`).
+* @returns The `outDir`-relative file path (e.g. `bank/en/animals.json`).
+* @example
+* ```ts
+* relativeShardFile("bank", "en/animals"); // "bank/en/animals.json"
+* relativeShardFile("bank", "a%20%26%20b"); // "bank/a & b.json"
+* ```
+*/
+function relativeShardFile(collection, shard) {
+	return decodeSuffix(shardSuffix(collection, shard));
+}
+//#endregion
+Object.defineProperty(exports, "collectionUrl", {
+	enumerable: true,
+	get: function() {
+		return collectionUrl;
+	}
+});
+Object.defineProperty(exports, "relativeShardFile", {
+	enumerable: true,
+	get: function() {
+		return relativeShardFile;
+	}
+});

package/dist/index.cjs

@@ -1,5 +1,37 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_convention = require("./convention-BpDfzX7e.cjs");
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_convention = require("./convention-CLIDd9k-.cjs");
+const require_convention$1 = require("./convention-CsJw7CML.cjs");
 let _moku_labs_common = require("@moku-labs/common");
 let _moku_labs_core = require("@moku-labs/core");
 let node_fs = require("node:fs");
@@ -7,8 +39,8 @@ let node_crypto = require("node:crypto");
 let node_fs_promises = require("node:fs/promises");
 let node_os = require("node:os");
 let node_path = require("node:path");
-let node_path$1 = require_convention.__toESM(node_path, 1);
-node_path = require_convention.__toESM(node_path);
+let node_path$1 = __toESM(node_path, 1);
+node_path = __toESM(node_path);
 let feed = require("feed");
 let preact = require("preact");
 let preact_render_to_string = require("preact-render-to-string");
@@ -17,31 +49,31 @@ let node_readline = require("node:readline");
 let node_url = require("node:url");
 let _moku_labs_common_cli = require("@moku-labs/common/cli");
 let gray_matter = require("gray-matter");
-gray_matter = require_convention.__toESM(gray_matter, 1);
+gray_matter = __toESM(gray_matter, 1);
 let _shikijs_rehype = require("@shikijs/rehype");
-_shikijs_rehype = require_convention.__toESM(_shikijs_rehype, 1);
+_shikijs_rehype = __toESM(_shikijs_rehype, 1);
 let rehype_sanitize = require("rehype-sanitize");
-rehype_sanitize = require_convention.__toESM(rehype_sanitize, 1);
+rehype_sanitize = __toESM(rehype_sanitize, 1);
 let rehype_stringify = require("rehype-stringify");
-rehype_stringify = require_convention.__toESM(rehype_stringify, 1);
+rehype_stringify = __toESM(rehype_stringify, 1);
 let unified = require("unified");
 let rehype_raw = require("rehype-raw");
-rehype_raw = require_convention.__toESM(rehype_raw, 1);
+rehype_raw = __toESM(rehype_raw, 1);
 let remark_directive = require("remark-directive");
-remark_directive = require_convention.__toESM(remark_directive, 1);
+remark_directive = __toESM(remark_directive, 1);
 let remark_frontmatter = require("remark-frontmatter");
-remark_frontmatter = require_convention.__toESM(remark_frontmatter, 1);
+remark_frontmatter = __toESM(remark_frontmatter, 1);
 let remark_gfm = require("remark-gfm");
-remark_gfm = require_convention.__toESM(remark_gfm, 1);
+remark_gfm = __toESM(remark_gfm, 1);
 let remark_parse = require("remark-parse");
-remark_parse = require_convention.__toESM(remark_parse, 1);
+remark_parse = __toESM(remark_parse, 1);
 let remark_rehype = require("remark-rehype");
-remark_rehype = require_convention.__toESM(remark_rehype, 1);
+remark_rehype = __toESM(remark_rehype, 1);
 let unist_util_visit = require("unist-util-visit");
 let preact_jsx_runtime = require("preact/jsx-runtime");
 let hast_util_sanitize = require("hast-util-sanitize");
 let reading_time = require("reading-time");
-reading_time = require_convention.__toESM(reading_time, 1);
+reading_time = __toESM(reading_time, 1);
 let node_process = require("node:process");
 //#region src/config.ts
 /**
@@ -4460,7 +4492,7 @@ function dataApi(ctx) {
 		* ```
 		*/
 		async write(entries, options) {
-			const { writeData } = await Promise.resolve().then(() => require("./writer-JdhX1Wld.cjs"));
+			const { writeData } = await Promise.resolve().then(() => require("./writer-BEM-Pbgb.cjs"));
 			return writeData(ctx, entries, options);
 		},
 		/**
@@ -4544,7 +4576,7 @@ function createDataState(_ctx) {
 * isInvalidBaseUrl("_data"); // true
 * ```
 */
-function isInvalidBaseUrl(baseUrl) {
+function isInvalidBaseUrl$1(baseUrl) {
 	return typeof baseUrl !== "string" || !baseUrl.startsWith("/");
 }
 /**
@@ -4559,7 +4591,7 @@ function isInvalidBaseUrl(baseUrl) {
 * ```
 */
 function validateDataConfig(config) {
-	if (isInvalidBaseUrl(config.baseUrl)) throw new Error(`[web] data.baseUrl: must be a site-root-relative URL path starting with "/" (e.g. "/_data/").`);
+	if (isInvalidBaseUrl$1(config.baseUrl)) throw new Error(`[web] data.baseUrl: must be a site-root-relative URL path starting with "/" (e.g. "/_data/").`);
 }
 //#endregion
 //#region src/plugins/data/index.ts
@@ -9181,6 +9213,252 @@ const cliPlugin = createPlugin$1("cli", {
 	api: createApi$1
 });
 //#endregion
+//#region src/plugins/collection/read.ts
+/**
+* @file `loadCollectionShard` — the collection plugin's standalone BROWSER read
+* primitive. Internal to the `collection` plugin AND exported for standalone
+* consumers: `collection.at(...)` wraps it, and a room-layer consumer can import it
+* directly from `@moku-labs/web/browser`.
+*
+* Unlike the `data` plugin's isomorphic `loadJson`, this uses the `fetch` global
+* DIRECTLY (no `node:fs` branch). Consumers — and tests — rely on `fetch` even
+* under Node test environments, so there is no document sniffing here: a shard is
+* always fetched over HTTP from the build-authored URL. This keeps the module
+* fully node-free.
+*/
+/**
+* Fetch + parse a build-authored collection shard over HTTP. Builds the shard URL
+* via {@link collectionUrl}, fetches it, and throws on a non-OK response so the
+* caller (`collection.at`) can decide whether to fall back.
+*
+* @template T - The expected shape of the parsed shard JSON.
+* @param baseUrl - The site-root URL prefix (ends with `/`, e.g. `"/"`).
+* @param collection - The collection name (e.g. `"bank"`).
+* @param shard - The shard key within the collection (e.g. `"en/animals"`).
+* @returns The parsed shard JSON, typed as `T`.
+* @throws {Error} If the fetch is not OK.
+* @example
+* ```ts
+* const animals = await loadCollectionShard<Animal[]>("/", "bank", "en/animals");
+* ```
+*/
+async function loadCollectionShard(baseUrl, collection, shard) {
+	const url = require_convention$1.collectionUrl(baseUrl, collection, shard);
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`[web] collection: failed to fetch ${url} (${String(response.status)}).`);
+	return response.json();
+}
+//#endregion
+//#region src/plugins/collection/api.ts
+/**
+* @file collection plugin — API factory (the collection provider surface).
+*
+* Node-free by construction: this module statically imports only types + the pure
+* convention + the node-free `read` primitive. The Node write side (`write()`)
+* reaches its `node:fs` writer through a lazy `await import("./writer")` at call
+* time, so a browser bundle that composes `collection` for the read side never
+* pulls `node:*`. The read side (`at()`) uses only the `fetch`-based
+* `loadCollectionShard`.
+*/
+/**
+* Builds the collection provider — the static-data bridge. `write()` is the Node
+* persist side; `at()` is the browser read side; `urlFor`/`fileFor` are the pure
+* convention. No `onStart`/`onStop` (holds no long-lived resource).
+*
+* @param ctx - The collection plugin context.
+* @returns The {@link CollectionProvider} mounted at `app.collection`.
+* @example
+* ```ts
+* const api = collectionApi(ctx);
+* await api.write([{ collection: "bank", shard: "en/animals", data }]); // Node build
+* await api.at("bank", "en/animals");                                   // browser
+* ```
+*/
+function collectionApi(ctx) {
+	return {
+		/**
+		* READ (browser) — fetch (and cache) the persisted data for a `(collection,
+		* shard)` key. Returns the raw JSON as `unknown`; returns `null` if the fetch
+		* or JSON parse fails (so the consumer can fall back). Wraps the throwing
+		* {@link loadCollectionShard} reader into a soft null-returning app read.
+		*
+		* @param collection - The collection name (e.g. `"bank"`).
+		* @param shard - The shard key within the collection (e.g. `"en/animals"`).
+		* @returns The shard's raw data, or `null` on failure.
+		* @example
+		* ```ts
+		* const raw = await api.at("bank", "en/animals");
+		* ```
+		*/
+		async at(collection, shard) {
+			const key = `${collection}/${shard}`;
+			if (ctx.state.cache.has(key)) return ctx.state.cache.get(key);
+			try {
+				const data = await loadCollectionShard(ctx.config.baseUrl, collection, shard);
+				ctx.state.cache.set(key, data);
+				return data;
+			} catch {
+				return null;
+			}
+		},
+		/**
+		* WRITE (Node) — persist one JSON file per entry, keyed by `(collection,
+		* shard)`. Called by the build after it authors the shards. Lazily loads its
+		* `node:fs` writer (keeping a browser bundle node-free).
+		*
+		* @param entries - The per-shard data to persist.
+		* @param options - Optional `{ outDir }` override (defaults to `./dist`).
+		* @param options.outDir - Build output directory the write happens under.
+		* @returns A summary of the written files.
+		* @example
+		* ```ts
+		* await api.write([{ collection: "bank", shard: "ru", data }], { outDir: "dist" });
+		* ```
+		*/
+		async write(entries, options) {
+			const { writeCollection } = await Promise.resolve().then(() => require("./writer-BBtgz9wt.cjs"));
+			return writeCollection(ctx, entries, options);
+		},
+		/**
+		* PURE — the browser fetch URL for a `(collection, shard)` key.
+		*
+		* @param collection - The collection name.
+		* @param shard - The shard key within the collection.
+		* @returns The site-root-relative shard URL.
+		* @example
+		* ```ts
+		* api.urlFor("bank", "en/animals"); // "/bank/en/animals.json"
+		* ```
+		*/
+		urlFor(collection, shard) {
+			return require_convention$1.collectionUrl(ctx.config.baseUrl, collection, shard);
+		},
+		/**
+		* PURE — the `outDir`-relative file path for a `(collection, shard)` key.
+		*
+		* @param collection - The collection name.
+		* @param shard - The shard key within the collection.
+		* @returns The output-relative file path.
+		* @example
+		* ```ts
+		* api.fileFor("bank", "en/animals"); // "bank/en/animals.json"
+		* ```
+		*/
+		fileFor(collection, shard) {
+			return require_convention$1.relativeShardFile(collection, shard);
+		}
+	};
+}
+//#endregion
+//#region src/plugins/collection/config.ts
+/**
+* Typed default collection config (R6: no inline `as`). `baseUrl` is the READ-side
+* site-root URL prefix the browser fetches shards from; the collection name is the
+* top directory under it. The default `"/"` serves shards straight from the site
+* root (e.g. `/bank/en/animals.json`).
+*
+* @example
+* ```ts
+* createPlugin("collection", { config: defaultCollectionConfig });
+* ```
+*/
+const defaultCollectionConfig = { baseUrl: "/" };
+//#endregion
+//#region src/plugins/collection/state.ts
+/**
+* Creates initial collection state: a null `lastWrite` slot (populated by the Node
+* `write()` side) and an empty `cache` (populated lazily by the browser
+* `at(collection, shard)` side on first fetch).
+*
+* @param _ctx - Minimal context with global and config.
+* @param _ctx.global - Global framework configuration.
+* @param _ctx.config - Resolved plugin configuration.
+* @returns Fresh collection state with no recorded write and an empty per-shard cache.
+* @example
+* ```ts
+* const state = createCollectionState({ global: {}, config });
+* ```
+*/
+function createCollectionState(_ctx) {
+	return {
+		lastWrite: null,
+		cache: /* @__PURE__ */ new Map()
+	};
+}
+//#endregion
+//#region src/plugins/collection/validate.ts
+/**
+* Reports whether a `baseUrl` value is invalid: it must be a string that ends with
+* a `"/"` so the collection name appends cleanly (`baseUrl + collection + "/" + …`).
+*
+* @param baseUrl - The candidate `baseUrl` value to check.
+* @returns `true` when `baseUrl` is not a string or does not end with "/".
+* @example
+* ```ts
+* isInvalidBaseUrl("/"); // false
+* isInvalidBaseUrl("/cdn"); // true
+* ```
+*/
+function isInvalidBaseUrl(baseUrl) {
+	return typeof baseUrl !== "string" || !baseUrl.endsWith("/");
+}
+/**
+* Validates the resolved collection config: the browser `baseUrl` must be a string
+* ending with `"/"` so the collection name appends cleanly.
+*
+* @param config - The resolved plugin configuration.
+* @throws {Error} If `baseUrl` is not a string ending with "/".
+* @example
+* ```ts
+* validateCollectionConfig({ baseUrl: "/" });
+* ```
+*/
+function validateCollectionConfig(config) {
+	if (isInvalidBaseUrl(config.baseUrl)) throw new Error(`[web] collection.baseUrl: must be a URL prefix ending with "/" (e.g. "/" or "/cdn/").`);
+}
+//#endregion
+//#region src/plugins/collection/index.ts
+/**
+* @file collection — Standard tier plugin (wiring-only). The static-data
+* COLLECTION provider — the collection-keyed sibling of the page-path-keyed `data`
+* plugin.
+*
+* Owns ONE contract — `(collection, shard) → persisted JSON file` — and nothing
+* about what the data is: `write(entries)` persists per-shard JSON on Node (the
+* build supplies the shards it already authored); `at(collection, shard)` fetches +
+* caches it in the browser as `unknown`, read on demand by the consumer. NOT a
+* framework default — the consumer composes it where needed (Node build AND/OR
+* browser app).
+*
+* **No hard `depends`** — fully browser-composable; the `node:fs` writer is behind
+* a lazy `import()` inside `write()`. Build ordering is a call-site contract: the
+* build writes shards during/after its pages phase, via `app.collection.write`.
+* No `onStart`/`onStop`.
+* @see README.md
+*/
+/**
+* Collection plugin — the static-data collection provider. Mounts
+* `write(entries)` (Node persist), `at(collection, shard)` (browser read), and the
+* pure `urlFor`/`fileFor` convention at `app.collection`.
+*
+* @example
+* ```ts
+* // Node build: write build-authored shards during/after the build's pages phase.
+* const app = createApp({ plugins: [collectionPlugin, buildPlugin] });
+* await app.build.run();
+* await app.collection.write([{ collection: "bank", shard: "en/animals", data }]);
+*
+* // Browser app: compose `collectionPlugin` too; fetch a shard on demand.
+* const raw = await app.collection.at("bank", "en/animals"); // unknown | null
+* ```
+*/
+const collectionPlugin = createPlugin$1("collection", {
+	config: defaultCollectionConfig,
+	createState: createCollectionState,
+	onInit: (ctx) => validateCollectionConfig(ctx.config),
+	api: collectionApi
+});
+//#endregion
 //#region src/plugins/spa/api.ts
 /**
 * Creates the spa plugin API surface (registration / control). All methods
@@ -9346,7 +9624,7 @@ function syncHead(_head, doc) {
 }
 //#endregion
 //#region src/plugins/spa/types.ts
-var types_exports$7 = /* @__PURE__ */ require_convention.__exportAll({ ISLAND_HOOK_NAMES: () => ISLAND_HOOK_NAMES });
+var types_exports$8 = /* @__PURE__ */ __exportAll({ ISLAND_HOOK_NAMES: () => ISLAND_HOOK_NAMES });
 /** Allowed hook names — single source of truth for fail-fast validation. */
 const ISLAND_HOOK_NAMES = [
 	"onCreate",
@@ -11206,10 +11484,12 @@ function createChannel(options) {
 		ws.addEventListener("open", () => {
 			reconnectAttempts = 0;
 		});
-		ws.addEventListener("close", () => {
+		ws.addEventListener("close", (event) => {
 			if (socket !== ws || desiredId === void 0) return;
 			socket = void 0;
-			if (reconnectCfg) scheduleReconnect();
+			if (!reconnectCfg) return;
+			if (options.shouldReconnect?.(event) === false) return;
+			scheduleReconnect();
 		});
 	}
 	/**
@@ -11477,25 +11757,28 @@ const spaPlugin = createPlugin$1("spa", {
 });
 //#endregion
 //#region src/plugins/build/types.ts
-var types_exports = /* @__PURE__ */ require_convention.__exportAll({});
+var types_exports = /* @__PURE__ */ __exportAll({});
 //#endregion
 //#region src/plugins/cli/types.ts
-var types_exports$1 = /* @__PURE__ */ require_convention.__exportAll({});
+var types_exports$1 = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region src/plugins/collection/types.ts
+var types_exports$2 = /* @__PURE__ */ __exportAll({});
 //#endregion
 //#region src/plugins/content/types.ts
-var types_exports$2 = /* @__PURE__ */ require_convention.__exportAll({});
+var types_exports$3 = /* @__PURE__ */ __exportAll({});
 //#endregion
 //#region src/plugins/data/types.ts
-var types_exports$3 = /* @__PURE__ */ require_convention.__exportAll({});
+var types_exports$4 = /* @__PURE__ */ __exportAll({});
 //#endregion
 //#region src/plugins/deploy/types.ts
-var types_exports$4 = /* @__PURE__ */ require_convention.__exportAll({});
+var types_exports$5 = /* @__PURE__ */ __exportAll({});
 //#endregion
 //#region src/plugins/head/types.ts
-var types_exports$5 = /* @__PURE__ */ require_convention.__exportAll({});
+var types_exports$6 = /* @__PURE__ */ __exportAll({});
 //#endregion
 //#region src/plugins/router/types.ts
-var types_exports$6 = /* @__PURE__ */ require_convention.__exportAll({});
+var types_exports$7 = /* @__PURE__ */ __exportAll({});
 //#endregion
 //#region node_modules/unist-util-stringify-position/lib/index.js
 /**
@@ -13707,44 +13990,51 @@ Object.defineProperty(exports, "Cli", {
 		return types_exports$1;
 	}
 });
-Object.defineProperty(exports, "Content", {
+Object.defineProperty(exports, "Collection", {
 	enumerable: true,
 	get: function() {
 		return types_exports$2;
 	}
 });
-Object.defineProperty(exports, "Data", {
+Object.defineProperty(exports, "Content", {
 	enumerable: true,
 	get: function() {
 		return types_exports$3;
 	}
 });
-Object.defineProperty(exports, "Deploy", {
+Object.defineProperty(exports, "Data", {
 	enumerable: true,
 	get: function() {
 		return types_exports$4;
 	}
 });
+Object.defineProperty(exports, "Deploy", {
+	enumerable: true,
+	get: function() {
+		return types_exports$5;
+	}
+});
 exports.EmbedFacadeButton = EmbedFacadeButton;
 exports.GalleryTrack = GalleryTrack;
 Object.defineProperty(exports, "Head", {
 	enumerable: true,
 	get: function() {
-		return types_exports$5;
+		return types_exports$6;
 	}
 });
 Object.defineProperty(exports, "Router", {
 	enumerable: true,
 	get: function() {
-		return types_exports$6;
+		return types_exports$7;
 	}
 });
 Object.defineProperty(exports, "Spa", {
 	enumerable: true,
 	get: function() {
-		return types_exports$7;
+		return types_exports$8;
 	}
 });
+exports.__toESM = __toESM;
 Object.defineProperty(exports, "browserEnv", {
 	enumerable: true,
 	get: function() {
@@ -13761,6 +14051,8 @@ Object.defineProperty(exports, "cloudflareBindings", {
 		return _moku_labs_common.cloudflareBindings;
 	}
 });
+exports.collectionPlugin = collectionPlugin;
+exports.collectionUrl = require_convention$1.collectionUrl;
 exports.contentPlugin = contentPlugin;
 exports.createApp = createApp;
 exports.createChannel = createChannel;
@@ -13790,6 +14082,7 @@ exports.hreflang = hreflang;
 exports.i18nPlugin = i18nPlugin;
 exports.jsonLd = jsonLd;
 exports.lazyEmbed = lazyEmbed;
+exports.loadCollectionShard = loadCollectionShard;
 Object.defineProperty(exports, "logPlugin", {
 	enumerable: true,
 	get: function() {