camox 0.59.0 → 0.60.2

package/dist/features/sdkBundle/buildSdkBundle.js

@@ -0,0 +1,323 @@
+import { SDK_BUNDLE_TARGETS, loadsAtFirstPaint, sdkBundleEntryFile } from "./specifiers.js";
+import { SDK_BUNDLE_BUILDER_VERSION, sdkBundleName, sdkBundlePath, sdkBundleSpecifiersFor } from "./sdkBundleName.js";
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { build } from "vite-plus";
+import { readFile, writeFile } from "node:fs/promises";
+
+//#region src/features/sdkBundle/buildSdkBundle.ts
+/**
+* Builds a website's SDK Bundle: Camox, React and what they reach, once for the browser and once
+* for workerd, from the packages the website installed. Runs in Node, from the website's folder.
+*/
+/** The manifest each target's folder holds, beside its files. */
+const SDK_BUNDLE_MANIFEST = "sdk-bundle.json";
+/** The lockfile a website installed from, and the website's importer in it. */
+async function readSdkBundleLockfile(root) {
+	const website = resolve(root);
+	for (let dir = website;; dir = dirname(dir)) {
+		const file = join(dir, "pnpm-lock.yaml");
+		if (existsSync(file)) {
+			const importer = relative(dir, website).split(sep).join("/") || ".";
+			return {
+				lockfile: await readFile(file, "utf8"),
+				importer
+			};
+		}
+		if (dirname(dir) === dir) throw new Error(`Camox: no pnpm-lock.yaml in ${website} or any folder above it.`);
+	}
+}
+/** The names of the website's SDK Bundle, per target, from its lockfile and settings. */
+async function sdkBundleNamesFor({ root, settings }) {
+	const { lockfile, importer } = await readSdkBundleLockfile(root);
+	const [browser, workerd] = await Promise.all(SDK_BUNDLE_TARGETS.map((target) => sdkBundleName({
+		lockfile,
+		importer,
+		target,
+		settings
+	})));
+	return {
+		browser,
+		workerd
+	};
+}
+/**
+* Builds the SDK Bundle of the website in `root`, with its installed packages, into
+* `<outDir>/browser` and `<outDir>/workerd`. Each folder is served or loaded as is, under its own
+* name's path.
+*/
+async function buildSdkBundle({ root, outDir, settings }) {
+	const names = await sdkBundleNamesFor({
+		root,
+		settings
+	});
+	const { lockfile, importer } = await readSdkBundleLockfile(root);
+	const result = {};
+	for (const target of SDK_BUNDLE_TARGETS) {
+		const dir = join(outDir, target);
+		const specifiers = sdkBundleSpecifiersFor({
+			lockfile,
+			importer,
+			target
+		});
+		const entries = await buildTarget({
+			root: resolve(root),
+			dir,
+			target,
+			specifiers,
+			names,
+			settings
+		});
+		const manifest = {
+			name: names[target],
+			target,
+			builderVersion: "2",
+			entries
+		};
+		await writeFile(join(dir, SDK_BUNDLE_MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`);
+		result[target] = {
+			name: names[target],
+			dir
+		};
+	}
+	return result;
+}
+const ENTRY_PREFIX = "\0camox-sdk-bundle-entry:";
+const VIRTUAL_STUDIO_CSS = "virtual:camox-studio-css";
+const VIRTUAL_OVERLAY_CSS = "virtual:camox-overlay-css";
+/** The conditions the Cloudflare plugin resolves the Worker's packages with. */
+const WORKERD_CONDITIONS = [
+	"workerd",
+	"worker",
+	"module",
+	"browser",
+	"production"
+];
+async function buildTarget({ root, dir, target, specifiers, names, settings }) {
+	const entryName = (specifier) => sdkBundleEntryFile(specifier).replace(/\.mjs$/, "");
+	const workerd = target === "workerd";
+	const config = {
+		configFile: false,
+		root,
+		mode: "production",
+		logLevel: "warn",
+		define: {
+			__CAMOX_ICON_IDS__: JSON.stringify(settings.iconIds),
+			__CAMOX_TELEMETRY_DISABLED__: JSON.stringify(settings.telemetryDisabled),
+			__CAMOX_ENABLE_EXPERIMENTAL_FEATURES__: JSON.stringify(settings.experimentalFeatures),
+			__CAMOX_API_URL__: JSON.stringify(settings.apiUrl),
+			"process.env.NODE_ENV": JSON.stringify("production")
+		},
+		plugins: [
+			entries(root),
+			camoxStylesheets({
+				root,
+				target,
+				browserName: names.browser
+			}),
+			...workerd ? [wasmModules()] : []
+		],
+		resolve: {
+			alias: [{
+				find: /^tslib$/,
+				replacement: "tslib/tslib.es6.mjs"
+			}],
+			...workerd && { conditions: WORKERD_CONDITIONS }
+		},
+		...workerd && { ssr: {
+			noExternal: true,
+			target: "webworker",
+			resolve: {
+				conditions: WORKERD_CONDITIONS,
+				externalConditions: WORKERD_CONDITIONS
+			}
+		} },
+		build: {
+			outDir: dir,
+			emptyOutDir: true,
+			ssr: workerd,
+			emitAssets: true,
+			target: workerd ? "esnext" : void 0,
+			minify: true,
+			sourcemap: false,
+			reportCompressedSize: false,
+			chunkSizeWarningLimit: Infinity,
+			modulePreload: false,
+			copyPublicDir: false,
+			rolldownOptions: {
+				input: Object.fromEntries(specifiers.map((specifier) => [entryName(specifier), `${ENTRY_PREFIX}${specifier}`])),
+				preserveEntrySignatures: "strict",
+				...workerd && {
+					platform: "neutral",
+					external: [/^cloudflare:/, /^node:/]
+				},
+				onLog(level, log, handler) {
+					if (log.code === "MODULE_LEVEL_DIRECTIVE" || log.code === "EVAL") return;
+					handler(level, log);
+				},
+				output: {
+					entryFileNames: "[name].mjs",
+					chunkFileNames: (chunk) => !workerd && FIRST_PAINT_CHUNKS.has(chunk.name) ? "[name]-[hash].mjs" : "c-[hash].mjs",
+					assetFileNames: "[name]-[hash][extname]"
+				}
+			}
+		}
+	};
+	if (!workerd) {
+		const input = config.build.rolldownOptions.input;
+		const pageModules = await modulesLoadedStatically(config, Object.fromEntries(specifiers.filter(loadsAtFirstPaint).map((specifier) => [entryName(specifier), input[entryName(specifier)]])));
+		const output = config.build.rolldownOptions.output;
+		output.codeSplitting = { groups: [{
+			name: "react",
+			test: (id) => pageModules.has(id) && REACT_MODULE.test(id),
+			priority: 2
+		}, {
+			name: "page",
+			test: (id) => pageModules.has(id),
+			priority: 1
+		}] };
+	}
+	await build(config);
+	return Object.fromEntries(specifiers.map((specifier) => [specifier, sdkBundleEntryFile(specifier)]));
+}
+/**
+* The chunks a page loads at first paint, beside the entry files it imports: its code, React, and
+* the helpers Rolldown keeps in a chunk of their own.
+*/
+const FIRST_PAINT_CHUNKS = /* @__PURE__ */ new Set([
+	"page",
+	"react",
+	"rolldown-runtime"
+]);
+const REACT_MODULE = /[\\/]node_modules[\\/](react|react-dom|scheduler)[\\/]/;
+/**
+* The modules the browser loads when it imports `input`'s entries, without what they import
+* lazily: a first build of those entries alone, so what they import but never use is left out,
+* as their own build would.
+*/
+async function modulesLoadedStatically(config, input) {
+	const result = await build({
+		...config,
+		build: {
+			...config.build,
+			write: false,
+			rolldownOptions: {
+				...config.build.rolldownOptions,
+				input
+			}
+		}
+	});
+	const outputs = Array.isArray(result) ? result : [result];
+	const chunks = /* @__PURE__ */ new Map();
+	for (const { output } of outputs) for (const file of output) if (file.type === "chunk") chunks.set(file.fileName, file);
+	const loaded = /* @__PURE__ */ new Set();
+	const visit = (fileName) => {
+		if (loaded.has(fileName)) return;
+		loaded.add(fileName);
+		for (const imported of chunks.get(fileName)?.imports ?? []) visit(imported);
+	};
+	for (const chunk of chunks.values()) if (chunk.isEntry) visit(chunk.fileName);
+	const modules = /* @__PURE__ */ new Set();
+	for (const fileName of loaded) for (const [id, module] of Object.entries(chunks.get(fileName)?.modules ?? {})) if (module.renderedLength > 0) modules.add(id);
+	return modules;
+}
+/** One entry per specifier, exporting what it exports, CommonJS packages included. */
+function entries(root) {
+	return {
+		name: "camox:sdk-bundle-entries",
+		enforce: "pre",
+		resolveId(id) {
+			if (id.startsWith(ENTRY_PREFIX)) return id;
+		},
+		async load(id) {
+			if (!id.startsWith(ENTRY_PREFIX)) return;
+			const specifier = id.slice(24);
+			const resolved = await this.resolve(specifier, join(root, "package.json"));
+			if (!resolved) this.error(`Camox: the website doesn't install ${specifier}.`);
+			const imported = JSON.stringify(specifier);
+			if (isCommonJs(resolved.id)) {
+				const names = Object.keys(createRequire(resolved.id)(resolved.id)).filter((name) => name !== "default" && name !== "__esModule" && /^[A-Za-z_$][\w$]*$/.test(name));
+				return [
+					`import * as module from ${imported};`,
+					"const exports = module.default ?? module;",
+					"export default exports;",
+					...names.map((name) => `export const ${name} = exports.${name};`)
+				].join("\n");
+			}
+			const source = readFileSync(resolved.id, "utf8");
+			return `export * from ${imported};\n${/\bexport\s+default\b|\bas\s+default\b/.test(source) ? `export { default } from ${imported};\n` : ""}`;
+		}
+	};
+}
+/** Whether Node would load `file` as CommonJS. */
+function isCommonJs(file) {
+	const extension = extname(file);
+	if (extension === ".cjs") return true;
+	if (extension !== ".js") return false;
+	for (let dir = dirname(file); dirname(dir) !== dir; dir = dirname(dir)) {
+		const manifest = join(dir, "package.json");
+		if (existsSync(manifest)) return JSON.parse(readFileSync(manifest, "utf8")).type !== "module";
+	}
+	return true;
+}
+/**
+* The Studio's stylesheets, which camox's modules import as virtual modules. The browser finds
+* the Studio's from the module that asks, and the Worker from the browser bundle's path: the name
+* is known before building, so no prefix is read at runtime.
+*/
+function camoxStylesheets({ root, target, browserName }) {
+	const studioCss = createRequire(join(root, "package.json")).resolve("camox/studio.css");
+	const resolved = (id) => `\0${id}`;
+	return {
+		name: "camox:sdk-bundle-stylesheets",
+		enforce: "pre",
+		resolveId(id) {
+			if (id === VIRTUAL_STUDIO_CSS || id === VIRTUAL_OVERLAY_CSS) return resolved(id);
+		},
+		load(id) {
+			if (id === resolved(VIRTUAL_OVERLAY_CSS)) {
+				const css = readFileSync(join(dirname(studioCss), "studio-overlays.css"), "utf8");
+				return `export default ${JSON.stringify(css)};`;
+			}
+			if (id !== resolved(VIRTUAL_STUDIO_CSS)) return;
+			const css = readFileSync(studioCss, "utf8");
+			const fileName = `camox-studio-${createHash("sha256").update(css).digest("hex").slice(0, 8)}.css`;
+			if (target === "browser") {
+				this.emitFile({
+					type: "asset",
+					fileName,
+					source: css
+				});
+				return `export default new URL(/* @vite-ignore */ ${JSON.stringify(`./${fileName}`)}, import.meta.url).href;`;
+			}
+			return `export default ${JSON.stringify(sdkBundlePath(browserName) + fileName)};`;
+		}
+	};
+}
+/** WebAssembly the Worker imports, as modules of their own beside the bundle's. */
+function wasmModules() {
+	return {
+		name: "camox:sdk-bundle-wasm",
+		enforce: "pre",
+		async resolveId(id, importer) {
+			if (!id.endsWith(".wasm")) return;
+			const resolved = await this.resolve(id, importer, { skipSelf: true });
+			if (!resolved) return;
+			const file = basename(resolved.id);
+			this.emitFile({
+				type: "asset",
+				fileName: file,
+				source: await readFile(resolved.id)
+			});
+			return {
+				id: `./${file}`,
+				external: true
+			};
+		}
+	};
+}
+
+//#endregion
+export { SDK_BUNDLE_MANIFEST, buildSdkBundle, readSdkBundleLockfile, sdkBundleNamesFor };

package/dist/features/sdkBundle/localSdkBundle.d.ts

@@ -0,0 +1,44 @@
+import { SdkBundleNames, SdkBundleSettings } from "./sdkBundleName.js";
+import { SdkBundleBuild } from "./buildSdkBundle.js";
+//#region src/features/sdkBundle/localSdkBundle.d.ts
+/** Turns building against an SDK Bundle on (`1`) or off (`0`) for `vite build`. */
+export declare const SDK_BUNDLE_SWITCH_ENV = "CAMOX_INTERNAL_SDK_BUNDLE";
+/** The folder SDK Bundles are cached in, when not the website's own. */
+export declare const SDK_BUNDLE_CACHE_ENV = "CAMOX_INTERNAL_SDK_BUNDLE_CACHE";
+/** Whether `vite build` builds against an SDK Bundle. */
+export declare function buildsAgainstSdkBundle(env?: NodeJS.ProcessEnv): boolean;
+/** What a hosted build fails with when its SDK Bundle isn't in the cache: it never builds one. */
+export declare class SdkBundleMissingError extends Error {
+  readonly names: SdkBundleNames;
+  name: string;
+  readonly code = "CAMOX_SDK_BUNDLE_MISSING";
+  constructor(names: SdkBundleNames);
+}
+/**
+ * The folder a website's SDK Bundles are cached in, one folder per target's name:
+ * `CAMOX_INTERNAL_SDK_BUNDLE_CACHE`, or the website's `node_modules/.cache/camox/sdk-bundles`.
+ */
+export declare function sdkBundleCacheDir(root: string, env?: NodeJS.ProcessEnv): string;
+/**
+ * The website's SDK Bundle from the cache, built there first when it's missing and `mayBuild`.
+ * A hosted build passes `mayBuild: false`, and gets `SdkBundleMissingError` for a missing one.
+ */
+export declare function ensureLocalSdkBundle({ root, settings, mayBuild, onBuild, env }: {
+  root: string;
+  settings: SdkBundleSettings;
+  mayBuild: boolean;
+  /** Called before a missing bundle is built. */
+  onBuild?: (names: SdkBundleNames) => void;
+  env?: NodeJS.ProcessEnv;
+}): Promise<SdkBundleBuild>;
+/**
+ * Adds the SDK Bundle a website's build names to its output, so it deploys on its own: the
+ * browser files under `/_camox/sdk/<name>/` in the static assets, and the workerd modules under
+ * `_camox/sdk/<name>/` beside the Worker's. A whole-app build is left as it is. Returns the names,
+ * or null for a whole-app build.
+ */
+export declare function addSdkBundleToBuild({ root, env }: {
+  root: string;
+  env?: NodeJS.ProcessEnv;
+}): Promise<SdkBundleNames | null>;
+//#endregion

package/dist/features/sdkBundle/localSdkBundle.js

@@ -0,0 +1,162 @@
+import { SDK_BUNDLE_TARGETS } from "./specifiers.js";
+import { SDK_BUNDLE_BUILD_MANIFEST, sdkBundleMissingLine, sdkBundlePath } from "./sdkBundleName.js";
+import { buildSdkBundle, sdkBundleNamesFor } from "./buildSdkBundle.js";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { cp, mkdir, mkdtemp, readFile, rename, rm } from "node:fs/promises";
+
+//#region src/features/sdkBundle/localSdkBundle.ts
+/**
+* A website's SDK Bundle on this machine: looked up in a local cache by name, and built there when
+* it's missing, unless the build is a hosted one, which never builds one. Runs in Node.
+*/
+/** Turns building against an SDK Bundle on (`1`) or off (`0`) for `vite build`. */
+const SDK_BUNDLE_SWITCH_ENV = "CAMOX_INTERNAL_SDK_BUNDLE";
+/** Off until websites build against an SDK Bundle by default (#670). */
+const SDK_BUNDLE_SWITCH_DEFAULT = false;
+/** The folder SDK Bundles are cached in, when not the website's own. */
+const SDK_BUNDLE_CACHE_ENV = "CAMOX_INTERNAL_SDK_BUNDLE_CACHE";
+/** Whether `vite build` builds against an SDK Bundle. */
+function buildsAgainstSdkBundle(env = process.env) {
+	const value = env[SDK_BUNDLE_SWITCH_ENV];
+	if (value === "1") return true;
+	if (value === "0") return false;
+	return SDK_BUNDLE_SWITCH_DEFAULT;
+}
+/** What a hosted build fails with when its SDK Bundle isn't in the cache: it never builds one. */
+var SdkBundleMissingError = class extends Error {
+	names;
+	name = "SdkBundleMissingError";
+	code = "CAMOX_SDK_BUNDLE_MISSING";
+	constructor(names) {
+		super(`Camox: this build's SDK Bundle isn't in its cache, and a hosted build never builds one.\n` + sdkBundleMissingLine(names));
+		this.names = names;
+	}
+};
+/**
+* The folder a website's SDK Bundles are cached in, one folder per target's name:
+* `CAMOX_INTERNAL_SDK_BUNDLE_CACHE`, or the website's `node_modules/.cache/camox/sdk-bundles`.
+*/
+function sdkBundleCacheDir(root, env = process.env) {
+	const configured = env[SDK_BUNDLE_CACHE_ENV];
+	return configured ? resolve(configured) : join(resolve(root), "node_modules/.cache/camox/sdk-bundles");
+}
+/**
+* Where the cache holds a target's bundle. A linked camox, as in Camox's monorepo, has no
+* integrity in the lockfile, so its name stays the same when its code changes: the cache keys
+* it by its built files too.
+*/
+function cachedDir(cacheDir, name, salt) {
+	return join(cacheDir, salt ? `${name}-${salt}` : name);
+}
+/**
+* A digest of the linked camox's built files, or null when camox is installed from the registry.
+* Paths, sizes and modification times: enough to see a rebuild.
+*/
+function linkedCamoxSalt(root) {
+	const installed = join(resolve(root), "node_modules", "camox");
+	if (!existsSync(installed)) return null;
+	const real = realpathSync(installed);
+	if (real.split(sep).includes("node_modules")) return null;
+	const dist = join(real, "dist");
+	const hash = createHash("sha256");
+	const walk = (dir) => {
+		for (const entry of readdirSync(dir).sort()) {
+			const path = join(dir, entry);
+			const stat = statSync(path);
+			if (stat.isDirectory()) walk(path);
+			else hash.update(`${relative(dist, path)} ${stat.size} ${stat.mtimeMs}\n`);
+		}
+	};
+	if (existsSync(dist)) walk(dist);
+	return hash.digest("hex").slice(0, 12);
+}
+/**
+* The website's SDK Bundle from the cache, built there first when it's missing and `mayBuild`.
+* A hosted build passes `mayBuild: false`, and gets `SdkBundleMissingError` for a missing one.
+*/
+async function ensureLocalSdkBundle({ root, settings, mayBuild, onBuild, env = process.env }) {
+	const names = await sdkBundleNamesFor({
+		root,
+		settings
+	});
+	const cacheDir = sdkBundleCacheDir(root, env);
+	const salt = linkedCamoxSalt(root);
+	const cached = (target) => ({
+		name: names[target],
+		dir: cachedDir(cacheDir, names[target], salt)
+	});
+	const result = {
+		browser: cached("browser"),
+		workerd: cached("workerd")
+	};
+	if (SDK_BUNDLE_TARGETS.every((target) => existsSync(result[target].dir))) return result;
+	if (!mayBuild) throw new SdkBundleMissingError(names);
+	onBuild?.(names);
+	await mkdir(cacheDir, { recursive: true });
+	const staging = await mkdtemp(join(cacheDir, ".building-"));
+	try {
+		const built = await buildSdkBundle({
+			root,
+			outDir: staging,
+			settings
+		});
+		for (const target of SDK_BUNDLE_TARGETS) {
+			if (existsSync(result[target].dir)) continue;
+			await rename(built[target].dir, result[target].dir).catch((error) => {
+				if (!existsSync(result[target].dir)) throw error;
+			});
+		}
+	} finally {
+		await rm(staging, {
+			recursive: true,
+			force: true
+		});
+	}
+	return result;
+}
+/** Where the Cloudflare plugin's build put the Worker and its static assets. */
+async function buildOutput(root) {
+	const deployDir = join(resolve(root), ".wrangler/deploy");
+	const { configPath } = JSON.parse(await readFile(join(deployDir, "config.json"), "utf8"));
+	const wranglerPath = resolve(deployDir, configPath);
+	const wrangler = JSON.parse(readFileSync(wranglerPath, "utf8"));
+	const workerDir = dirname(wranglerPath);
+	return {
+		workerDir,
+		clientDir: resolve(workerDir, wrangler.assets?.directory ?? "../client")
+	};
+}
+/**
+* Adds the SDK Bundle a website's build names to its output, so it deploys on its own: the
+* browser files under `/_camox/sdk/<name>/` in the static assets, and the workerd modules under
+* `_camox/sdk/<name>/` beside the Worker's. A whole-app build is left as it is. Returns the names,
+* or null for a whole-app build.
+*/
+async function addSdkBundleToBuild({ root, env = process.env }) {
+	const { workerDir, clientDir } = await buildOutput(root);
+	const manifestPath = join(workerDir, SDK_BUNDLE_BUILD_MANIFEST);
+	if (!existsSync(manifestPath)) return null;
+	const names = JSON.parse(await readFile(manifestPath, "utf8"));
+	const cacheDir = sdkBundleCacheDir(root, env);
+	const salt = linkedCamoxSalt(root);
+	const destinations = {
+		browser: clientDir,
+		workerd: workerDir
+	};
+	for (const target of SDK_BUNDLE_TARGETS) {
+		const from = cachedDir(cacheDir, names[target], salt);
+		if (!existsSync(from)) throw new Error(`Camox: the build's SDK Bundle ${names[target]} isn't in ${cacheDir}.`);
+		const to = join(destinations[target], sdkBundlePath(names[target]).slice(1));
+		await rm(to, {
+			recursive: true,
+			force: true
+		});
+		await cp(from, to, { recursive: true });
+	}
+	return names;
+}
+
+//#endregion
+export { SDK_BUNDLE_CACHE_ENV, SDK_BUNDLE_SWITCH_ENV, SdkBundleMissingError, addSdkBundleToBuild, buildsAgainstSdkBundle, ensureLocalSdkBundle, sdkBundleCacheDir };

package/dist/features/sdkBundle/sdkBundle.d.ts

@@ -0,0 +1,3 @@
+import { BuiltSdkBundle, SDK_BUNDLE_MANIFEST, SdkBundleBuild, SdkBundleManifest, buildSdkBundle, readSdkBundleLockfile, sdkBundleNamesFor } from "./buildSdkBundle.js";
+import { SDK_BUNDLE_CACHE_ENV, SDK_BUNDLE_SWITCH_ENV, SdkBundleMissingError, addSdkBundleToBuild, buildsAgainstSdkBundle, ensureLocalSdkBundle, sdkBundleCacheDir } from "./localSdkBundle.js";
+export { BuiltSdkBundle, SDK_BUNDLE_CACHE_ENV, SDK_BUNDLE_MANIFEST, SDK_BUNDLE_SWITCH_ENV, SdkBundleBuild, SdkBundleManifest, SdkBundleMissingError, addSdkBundleToBuild, buildSdkBundle, buildsAgainstSdkBundle, ensureLocalSdkBundle, readSdkBundleLockfile, sdkBundleCacheDir, sdkBundleNamesFor };

package/dist/features/sdkBundle/sdkBundle.js

@@ -0,0 +1,4 @@
+import { SDK_BUNDLE_MANIFEST, buildSdkBundle, readSdkBundleLockfile, sdkBundleNamesFor } from "./buildSdkBundle.js";
+import { SDK_BUNDLE_CACHE_ENV, SDK_BUNDLE_SWITCH_ENV, SdkBundleMissingError, addSdkBundleToBuild, buildsAgainstSdkBundle, ensureLocalSdkBundle, sdkBundleCacheDir } from "./localSdkBundle.js";
+
+export { SDK_BUNDLE_CACHE_ENV, SDK_BUNDLE_MANIFEST, SDK_BUNDLE_SWITCH_ENV, SdkBundleMissingError, addSdkBundleToBuild, buildSdkBundle, buildsAgainstSdkBundle, ensureLocalSdkBundle, readSdkBundleLockfile, sdkBundleCacheDir, sdkBundleNamesFor };

package/dist/features/sdkBundle/sdkBundleName.d.ts

@@ -0,0 +1,59 @@
+import { LUCIDE_ICON_HELPER, SDK_BUNDLE_TARGETS, SdkBundleTarget, loadsAtFirstPaint, packageOfSpecifier, sdkBundleEntryFile, sdkBundleSpecifiers } from "./specifiers.js";
+//#region src/features/sdkBundle/sdkBundleName.d.ts
+/**
+ * The version of the code that builds SDK Bundles. Bump it whenever a change to the builder
+ * changes what a bundle holds for the same packages and settings.
+ */
+export declare const SDK_BUNDLE_BUILDER_VERSION = "2";
+/** Where a website's pages and Worker find an SDK Bundle's files: `/_camox/sdk/<name>/`. */
+export declare function sdkBundlePath(name: string): string;
+/** An SDK Bundle's name for each target: a website's build names both. */
+export type SdkBundleNames = Record<SdkBundleTarget, string>;
+/**
+ * The file a website's build names its SDK Bundle in, as `SdkBundleNames` JSON, in the server
+ * build's folder beside its `wrangler.json`. A build without it is whole-app.
+ */
+export declare const SDK_BUNDLE_BUILD_MANIFEST = "camox-sdk-bundle.json";
+/** What a hosted build whose SDK Bundle is missing fails with, followed by the names as JSON. */
+export declare const SDK_BUNDLE_MISSING = "CAMOX_SDK_BUNDLE_MISSING";
+/** The line a build that's missing its SDK Bundle prints its error with. */
+export declare function sdkBundleMissingLine(names: SdkBundleNames): string;
+/**
+ * The SDK Bundle a build's log says is missing, or null when the build failed for another reason:
+ * the caller ensures the bundle, then builds again.
+ */
+export declare function sdkBundleMissingIn(log: string): SdkBundleNames | null;
+/** The settings `camox()` compiles into an SDK Bundle. */
+export interface SdkBundleSettings {
+  /** The icon ids of the collection the website picked. */
+  iconIds: readonly string[];
+  telemetryDisabled: boolean;
+  experimentalFeatures: boolean;
+  apiUrl: string;
+}
+export interface SdkBundleNameInputs {
+  /** The website's `pnpm-lock.yaml`. */
+  lockfile: string;
+  /** The website's folder, from the lockfile's: `.` unless the website is in a workspace. */
+  importer?: string;
+  target: SdkBundleTarget;
+  settings: SdkBundleSettings;
+  /** Defaults to the builder this SDK ships. */
+  builderVersion?: string;
+}
+/**
+ * A digest of the builder's version, the target, the settings and the lockfile's resolution
+ * (name, version, integrity) of every package the target's specifiers reach.
+ */
+export declare function sdkBundleName({ lockfile, importer, target, settings, builderVersion }: SdkBundleNameInputs): Promise<string>;
+/**
+ * The specifiers the SDK Bundle of the website at `importer` holds for `target`: the packages it
+ * shares with camox are in only when it installs them.
+ */
+export declare function sdkBundleSpecifiersFor({ lockfile, importer, target }: {
+  lockfile: string;
+  importer?: string;
+  target: SdkBundleTarget;
+}): string[];
+//#endregion
+export { LUCIDE_ICON_HELPER, SDK_BUNDLE_TARGETS, SdkBundleTarget, loadsAtFirstPaint, packageOfSpecifier, sdkBundleEntryFile, sdkBundleSpecifiers };