@moku-labs/web 2.2.2 → 2.3.1

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
 /**
@@ -2571,9 +2603,70 @@ function substituteAssetPlaceholders(ctx, html) {
 	return html.replaceAll(ASSETS_PLACEHOLDER, buildAssetTags(ctx)).replaceAll(CSS_ASSETS_PLACEHOLDER, buildAssetTags(ctx, "css")).replaceAll(JS_ASSETS_PLACEHOLDER, buildAssetTags(ctx, "js"));
 }
 /**
-* Copies the configured `publicDir` (default `"public"`) verbatim into `outDir`,
-* preserving the nested directory structure. Skips silently (returns `null`) when
-* the source directory does not exist.
+* Test whether `destination` is already an up-to-date copy of the `src` file: same
+* size and at least as new (mtime). A missing destination — or any stat failure —
+* reports stale: when in doubt, copy.
+*
+* @param src - The source file path.
+* @param destination - The candidate destination file path.
+* @returns `true` when the destination can be skipped.
+* @example
+* ```ts
+* if (await isFreshCopy(src, destination)) return;
+* ```
+*/
+async function isFreshCopy(src, destination) {
+	try {
+		const [srcStat, destinationStat] = await Promise.all([(0, node_fs_promises.stat)(src), (0, node_fs_promises.stat)(destination)]);
+		return destinationStat.size === srcStat.size && destinationStat.mtimeMs >= srcStat.mtimeMs;
+	} catch {
+		return false;
+	}
+}
+/**
+* Recursively copy `from` into `to`, skipping every file whose destination is already
+* fresh. Skipping matters in dev rebuilds (which keep the previous outDir): re-copying
+* unchanged assets makes asset-watching dev servers (wrangler) reload on src-only
+* edits, and on macOS/APFS under Bun a large-file re-copy goes through clonefile(2),
+* whose FSEvents "ItemCloned" echo on the SOURCE path re-triggers `public/**` watchers
+* — a self-sustaining rebuild loop. Serial on purpose: public dirs can hold thousands
+* of assets and the skip path is stat-only, while an unbounded parallel copy risks fd
+* exhaustion.
+*
+* @param from - The source directory.
+* @param to - The destination directory (created when missing).
+* @returns The number of entries actually copied.
+* @example
+* ```ts
+* const copied = await copyDirIncremental("public", "dist");
+* ```
+*/
+async function copyDirIncremental(from, to) {
+	await (0, node_fs_promises.mkdir)(to, { recursive: true });
+	const entries = await (0, node_fs_promises.readdir)(from, { withFileTypes: true });
+	let copied = 0;
+	for (const entry of entries) {
+		const src = node_path$1.default.join(from, entry.name);
+		const destination = node_path$1.default.join(to, entry.name);
+		if (entry.isDirectory()) copied += await copyDirIncremental(src, destination);
+		else if (entry.isFile()) {
+			if (await isFreshCopy(src, destination)) continue;
+			await (0, node_fs_promises.copyFile)(src, destination);
+			copied += 1;
+		} else {
+			await (0, node_fs_promises.cp)(src, destination, { recursive: true });
+			copied += 1;
+		}
+	}
+	return copied;
+}
+/**
+* Copies the configured `publicDir` (default `"public"`) into `outDir`, preserving the
+* nested directory structure. The copy is incremental: a file whose destination already
+* exists with the same size and an mtime at least as new as the source is skipped. A
+* full build cleans outDir first, so every file misses the compare and the output is
+* identical to a verbatim copy; a dev rebuild (`skipClean`) rewrites only what changed.
+* Skips silently (returns `null`) when the source directory does not exist.
 *
 * @param ctx - Plugin context (provides `config`, `log`).
 * @returns The copy result, or `null` when the public directory is absent.
@@ -2591,14 +2684,15 @@ async function copyPublic(ctx) {
 		});
 		return null;
 	}
-	await (0, node_fs_promises.cp)(from, ctx.config.outDir, { recursive: true });
+	const copied = await copyDirIncremental(from, ctx.config.outDir);
 	ctx.log.debug("build:public", {
 		from,
-		dest: ctx.config.outDir
+		dest: ctx.config.outDir,
+		copied
 	});
 	return {
 		from: node_path$1.default.normalize(from),
-		copied: 1
+		copied
 	};
 }
 //#endregion
@@ -4460,7 +4554,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 +4638,7 @@ function createDataState(_ctx) {
 * isInvalidBaseUrl("_data"); // true
 * ```
 */
-function isInvalidBaseUrl(baseUrl) {
+function isInvalidBaseUrl$1(baseUrl) {
 	return typeof baseUrl !== "string" || !baseUrl.startsWith("/");
 }
 /**
@@ -4559,7 +4653,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 +9275,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 +9686,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",
@@ -11479,25 +11819,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
 /**
@@ -13709,44 +14052,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() {
@@ -13763,6 +14113,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;
@@ -13792,6 +14144,7 @@ exports.hreflang = hreflang;
 exports.i18nPlugin = i18nPlugin;
 exports.jsonLd = jsonLd;
 exports.lazyEmbed = lazyEmbed;
+exports.loadCollectionShard = loadCollectionShard;
 Object.defineProperty(exports, "logPlugin", {
 	enumerable: true,
 	get: function() {