forgepress 0.0.0 → 0.0.2

package/dist/_chunks/reader2.mjs

@@ -0,0 +1,797 @@
+import { isRecord, plain, same } from "./value.mjs";
+import { once } from "./once.mjs";
+import { assetUrl, base64ToText, createOutput, createPaths, isEntryId, isMediaFile, repositoryPaths, sortByCreation, textToBase64 } from "./media.mjs";
+import { createFileSource } from "./content.mjs";
+import "./serialize.mjs";
+import "./libs/diff.mjs";
+import { AuthorizationResponseError, None, ResponseBodyError, allowInsecureRequests, processRefreshTokenResponse, refreshTokenGrantRequest } from "oauth4webapi";
+import { clear, createStore, del, delMany, entries, get, set } from "idb-keyval";
+function mergeEntries(rows, overlay) {
+	if (!overlay) return [...rows];
+	const merged = new Map(rows.map((row) => [row.id, row]));
+	for (const [id, row] of Object.entries(overlay)) if (row === null) merged.delete(id);
+	else merged.set(id, row);
+	return [...merged.values()];
+}
+function stage(overlay, before, row) {
+	if (same(before, row)) delete overlay[row.id];
+	else overlay[row.id] = row;
+}
+function createContentChanges(base, ready, mutate) {
+	return {
+		schema: () => base.schema(),
+		list: async (collection) => sortByCreation(mergeEntries(await base.list(collection), (await ready()).entries[collection])),
+		entry: async (collection, id) => {
+			const staged = (await ready()).entries[collection]?.[id];
+			if (staged !== void 0) return staged ?? void 0;
+			return base.entry(collection, id);
+		},
+		writeEntry: async (collection, row) => {
+			const before = await base.entry(collection, row.id);
+			await mutate((changes) => {
+				stage(changes.entries[collection] ??= {}, before, plain(row));
+			});
+		},
+		removeEntry: async (collection, id) => {
+			const before = await base.entry(collection, id);
+			await mutate((changes) => {
+				const overlay = changes.entries[collection] ??= {};
+				if (before) overlay[id] = null;
+				else delete overlay[id];
+			});
+		}
+	};
+}
+function publishedUploads(changes) {
+	return Object.values(changes.publishedMedia ?? {}).filter(Boolean);
+}
+function localUploads(changes) {
+	const removed = new Set(changes.removed);
+	return [...new Map([...Object.values(changes.uploads), ...publishedUploads(changes)].map((upload) => [upload.name, upload])).values()].filter((upload) => !removed.has(upload.name));
+}
+function createPreviews() {
+	const urls = /* @__PURE__ */ new Map();
+	function preview(upload) {
+		if (typeof URL.createObjectURL !== "function") return "";
+		let url = urls.get(upload.name);
+		if (!url) {
+			url = URL.createObjectURL(new Blob([upload.data], { type: upload.type }));
+			urls.set(upload.name, url);
+		}
+		return url;
+	}
+	function forget(name) {
+		const url = urls.get(name);
+		if (!url) return;
+		URL.revokeObjectURL(url);
+		urls.delete(name);
+	}
+	return {
+		forget,
+		asset: (upload, prefix) => {
+			const local = preview(upload);
+			return {
+				name: upload.name,
+				url: assetUrl(prefix, upload.name),
+				type: upload.type,
+				size: upload.size,
+				modifiedAt: upload.modifiedAt,
+				...local ? { preview: local } : {}
+			};
+		},
+		clear: () => {
+			for (const name of [...urls.keys()]) forget(name);
+		}
+	};
+}
+function emptyChanges() {
+	return {
+		entries: {},
+		uploads: {},
+		removed: []
+	};
+}
+async function readChanges(store) {
+	return {
+		...emptyChanges(),
+		...await store.read()
+	};
+}
+const PROVIDERS = {
+	github: {
+		name: "GitHub",
+		root: "https://github.com",
+		tokens: "/settings/personal-access-tokens/new",
+		permissions: "read and write access to contents, and read access to actions and commit statuses",
+		commits: "/commit/"
+	},
+	gitlab: {
+		name: "GitLab",
+		root: "https://gitlab.com",
+		tokens: "/-/user_settings/personal_access_tokens",
+		permissions: "the api scope",
+		commits: "/-/commit/"
+	},
+	forgejo: {
+		name: "Forgejo",
+		root: "https://codeberg.org",
+		tokens: "/user/settings/applications",
+		permissions: "read access to your user, and read and write access to repositories",
+		commits: "/commit/"
+	}
+};
+function describe(config) {
+	const provider = PROVIDERS[config.type];
+	const root = (config.url ?? provider.root).replace(/\/+$/, "");
+	const shared = {
+		name: provider.name,
+		root,
+		tokens: `${root}${provider.tokens}`,
+		permissions: provider.permissions
+	};
+	if (config.type === "github") return {
+		...shared,
+		api: root === PROVIDERS.github.root ? "https://api.github.com" : `${root}/api/v3`,
+		scopes: config.scopes ?? []
+	};
+	if (config.type === "gitlab") return {
+		...shared,
+		api: `${root}/api/v4`,
+		scopes: config.scopes ?? ["api"],
+		oauth: {
+			issuer: root,
+			authorize: `${root}/oauth/authorize`,
+			token: `${root}/oauth/token`
+		}
+	};
+	return {
+		...shared,
+		api: `${root}/api/v1`,
+		scopes: config.scopes ?? ["read:user", "write:repository"],
+		oauth: {
+			issuer: root,
+			authorize: `${root}/login/oauth/authorize`,
+			token: `${root}/login/oauth/access_token`
+		}
+	};
+}
+function publishable(files) {
+	if (files.length === 0) throw new Error("[forgepress] there is nothing to publish");
+	return files;
+}
+function toIdentity(login, name, avatar) {
+	return {
+		login,
+		...name ? { name } : {},
+		...avatar ? { avatar } : {}
+	};
+}
+function blobs(directory, items) {
+	return items.filter((item) => item.type === "blob").map((item) => ({
+		path: `${directory}/${item.path}`,
+		sha: item.sha
+	}));
+}
+function createRepositoryApi(config, base, token, headers = {}) {
+	const { name } = describe(config);
+	let known = config.repository.branch;
+	async function send(path, init = {}) {
+		return fetch(path.startsWith("http") ? path : `${base}${path}`, {
+			...init,
+			headers: {
+				...headers,
+				authorization: `Bearer ${await token()}`,
+				...init.body === void 0 ? {} : { "content-type": "application/json" },
+				...init.headers
+			}
+		});
+	}
+	async function check(response) {
+		if (!response.ok) throw new Error(`[forgepress] ${name} ${response.status}: ${(await response.text()).slice(0, 300)}`);
+		return response;
+	}
+	async function call(path, init) {
+		const response = await check(await send(path, init));
+		return response.status === 204 ? void 0 : await response.json();
+	}
+	async function find(path, missing = [404]) {
+		const response = await send(path);
+		if (missing.includes(response.status)) return void 0;
+		return await (await check(response)).json();
+	}
+	function post(path, body) {
+		return call(path, {
+			method: "POST",
+			body: JSON.stringify(body)
+		});
+	}
+	async function details() {
+		const found = await call("");
+		known ??= found.default_branch;
+		return found;
+	}
+	async function branch() {
+		return known ?? (await details()).default_branch;
+	}
+	return {
+		send,
+		check,
+		call,
+		find,
+		post,
+		details,
+		branch
+	};
+}
+async function findTree(commit, directory, list) {
+	let tree = commit;
+	for (const segment of directory.split("/")) {
+		const found = (await list(tree)).find((item) => item.path === segment && item.type === "tree");
+		if (!found) return void 0;
+		tree = found.sha;
+	}
+	return tree;
+}
+const PAGE_SIZE$1 = 1e3;
+const STATUS_LIMIT = 50;
+const SCHEDULED = /\(schedule\)$/;
+function statusState$1(status) {
+	if (status === "success" || status === "pending") return status;
+	return status === "failure" || status === "error" ? "failure" : "skipped";
+}
+function encodePath(path) {
+	return path.split("/").map(encodeURIComponent).join("/");
+}
+function createForgejoForge(config, token) {
+	const { api, root } = describe(config);
+	const { owner, name } = config.repository;
+	const repo = createRepositoryApi(config, `${api}/repos/${owner}/${name}`, token, { accept: "application/json" });
+	async function entries(tree, recursive) {
+		const items = [];
+		for (let page = 1;; page += 1) {
+			const listed = await repo.call(`/git/trees/${tree}?recursive=${recursive}&per_page=${PAGE_SIZE$1}&page=${page}`);
+			items.push(...listed.tree);
+			if (listed.tree.length === 0 || items.length >= listed.total_count) return items;
+		}
+	}
+	async function sha(path, ref) {
+		return (await repo.find(`/contents/${encodePath(path)}?ref=${encodeURIComponent(ref)}`))?.sha;
+	}
+	return {
+		async access() {
+			const [user, repository] = await Promise.all([repo.call(`${api}/user`), repo.details()]);
+			return {
+				identity: toIdentity(user.login, user.full_name, user.avatar_url),
+				writable: repository.permissions?.push === true,
+				branch: await repo.branch()
+			};
+		},
+		async head() {
+			return (await repo.call(`/branches/${encodeURIComponent(await repo.branch())}`)).commit.id;
+		},
+		async files(commit, directory) {
+			const tree = await findTree(commit, directory, (found) => entries(found, false));
+			if (!tree) return [];
+			return blobs(directory, await entries(tree, true));
+		},
+		async read(blob) {
+			return base64ToText((await repo.call(`/git/blobs/${blob}`)).content);
+		},
+		async commit(files, message, parent) {
+			const operations = publishable((await Promise.all(files.map(async (file) => {
+				const found = await sha(file.path, parent);
+				if ("removed" in file) return found ? {
+					operation: "delete",
+					path: file.path,
+					sha: found
+				} : void 0;
+				const content = file.encoding === "base64" ? file.data : textToBase64(file.data);
+				return found ? {
+					operation: "update",
+					path: file.path,
+					content,
+					sha: found
+				} : {
+					operation: "create",
+					path: file.path,
+					content
+				};
+			}))).filter((operation) => operation !== void 0));
+			return (await repo.post("/contents", {
+				branch: await repo.branch(),
+				message,
+				files: operations
+			})).commit.sha;
+		},
+		async checks(commit) {
+			return ((await repo.call(`/commits/${commit}/status?limit=${STATUS_LIMIT}`)).statuses ?? []).filter((status) => !SCHEDULED.test(status.context)).map((status) => ({
+				name: status.context,
+				state: statusState$1(status.status),
+				...status.target_url ? { url: new URL(status.target_url, `${root}/`).href } : {}
+			}));
+		},
+		async contains(commit, ancestor) {
+			return commit === ancestor || (await repo.call(`/compare/${commit}...${ancestor}`)).total_commits === 0;
+		}
+	};
+}
+const BUILD_EVENTS = /* @__PURE__ */ new Set(["push", "workflow_run"]);
+const FAILED = /* @__PURE__ */ new Set([
+	"failure",
+	"timed_out",
+	"startup_failure"
+]);
+const UNREADABLE = [403, 404];
+function runState(status, conclusion) {
+	if (status !== "completed" || conclusion === "action_required") return "pending";
+	if (conclusion === "success") return "success";
+	return conclusion !== null && FAILED.has(conclusion) ? "failure" : "skipped";
+}
+function statusState(state) {
+	return state === "success" || state === "pending" ? state : "failure";
+}
+function linked(url) {
+	return url ? { url } : {};
+}
+function createGitHubForge(config, token) {
+	const { api } = describe(config);
+	const { owner, name } = config.repository;
+	const repo = createRepositoryApi(config, `${api}/repos/${owner}/${name}`, token, {
+		"accept": "application/vnd.github+json",
+		"x-github-api-version": "2022-11-28"
+	});
+	let apps = true;
+	async function runs(commit) {
+		return (await repo.find(`/actions/runs?head_sha=${commit}&per_page=100`, UNREADABLE))?.workflow_runs.filter((run) => BUILD_EVENTS.has(run.event) || run.path.startsWith("dynamic/pages/")).map((run) => ({
+			name: run.name ?? run.path,
+			state: runState(run.status, run.conclusion),
+			url: run.html_url
+		}));
+	}
+	async function statuses(commit) {
+		return (await repo.find(`/commits/${commit}/status?per_page=100`, UNREADABLE))?.statuses.map((status) => ({
+			name: status.context,
+			state: statusState(status.state),
+			...linked(status.target_url)
+		}));
+	}
+	async function others(commit) {
+		const found = apps ? await repo.find(`/commits/${commit}/check-runs?per_page=100`, UNREADABLE) : void 0;
+		if (!found) {
+			apps = false;
+			return [];
+		}
+		return found.check_runs.filter((run) => run.app?.slug !== "github-actions").map((run) => ({
+			name: run.name,
+			state: runState(run.status, run.conclusion),
+			...linked(run.html_url ?? run.details_url)
+		}));
+	}
+	return {
+		async access() {
+			const [user, repository] = await Promise.all([repo.call(`${api}/user`), repo.details()]);
+			return {
+				identity: toIdentity(user.login, user.name, user.avatar_url),
+				writable: repository.permissions?.push === true,
+				branch: await repo.branch()
+			};
+		},
+		async head() {
+			return (await repo.call(`/git/ref/heads/${encodeURIComponent(await repo.branch())}`)).object.sha;
+		},
+		async files(commit, directory) {
+			const sha = await findTree(commit, directory, async (tree) => (await repo.call(`/git/trees/${tree}`)).tree);
+			if (!sha) return [];
+			const tree = await repo.call(`/git/trees/${sha}?recursive=1`);
+			if (tree.truncated) throw new Error(`[forgepress] GitHub lists too many files in ${directory} to read them in one request`);
+			return blobs(directory, tree.tree);
+		},
+		async read(sha) {
+			return (await repo.check(await repo.send(`/git/blobs/${sha}`, { headers: { accept: "application/vnd.github.raw+json" } }))).text();
+		},
+		async commit(files, message, parent) {
+			const pending = publishable(files);
+			const current = await repo.call(`/git/commits/${parent}`);
+			const tree = await Promise.all(pending.map(async (file) => {
+				if ("removed" in file) return {
+					path: file.path,
+					mode: "100644",
+					type: "blob",
+					sha: null
+				};
+				const blob = await repo.post("/git/blobs", {
+					content: file.data,
+					encoding: file.encoding
+				});
+				return {
+					path: file.path,
+					mode: "100644",
+					type: "blob",
+					sha: blob.sha
+				};
+			}));
+			const next = await repo.post("/git/trees", {
+				base_tree: current.tree.sha,
+				tree
+			});
+			const created = await repo.post("/git/commits", {
+				message,
+				tree: next.sha,
+				parents: [parent]
+			});
+			await repo.call(`/git/refs/heads/${encodeURIComponent(await repo.branch())}`, {
+				method: "PATCH",
+				body: JSON.stringify({
+					sha: created.sha,
+					force: false
+				})
+			});
+			return created.sha;
+		},
+		async checks(commit) {
+			const [built, reported, rest] = await Promise.all([
+				runs(commit),
+				statuses(commit),
+				others(commit)
+			]);
+			if (!built && !reported) throw new Error("[forgepress] the GitHub token can't read the builds of this repository; give it read access to actions and commit statuses");
+			return [
+				...built ?? [],
+				...reported ?? [],
+				...rest
+			];
+		},
+		async contains(commit, ancestor) {
+			return commit === ancestor || (await repo.call(`/compare/${commit}...${ancestor}?per_page=1`)).ahead_by === 0;
+		}
+	};
+}
+const DEVELOPER = 30;
+const PAGE_SIZE = 100;
+const RUNNING = /* @__PURE__ */ new Set([
+	"created",
+	"waiting_for_resource",
+	"preparing",
+	"pending",
+	"running",
+	"scheduled",
+	"waiting_for_callback"
+]);
+function writable(project) {
+	return [project.permissions?.project_access?.access_level, project.permissions?.group_access?.access_level].some((level) => typeof level === "number" && level >= DEVELOPER);
+}
+function pipelineState(status) {
+	if (status === "success") return "success";
+	if (status === "failed") return "failure";
+	return RUNNING.has(status) ? "pending" : "skipped";
+}
+function nextPage(link) {
+	return link?.split(",").map((part) => /<([^>]+)>;\s*rel="next"/.exec(part)?.[1]).find((url) => url !== void 0);
+}
+function createGitLabForge(config, token) {
+	const { api } = describe(config);
+	const repo = createRepositoryApi(config, `${api}/projects/${encodeURIComponent(`${config.repository.owner}/${config.repository.name}`)}`, token);
+	function existing(path, ref) {
+		return repo.find(`/repository/files/${encodeURIComponent(path)}?ref=${encodeURIComponent(ref)}`);
+	}
+	return {
+		async access() {
+			const [user, project] = await Promise.all([repo.call(`${api}/user`), repo.details()]);
+			return {
+				identity: toIdentity(user.username, user.name, user.avatar_url),
+				writable: writable(project),
+				branch: await repo.branch()
+			};
+		},
+		async head() {
+			return (await repo.call(`/repository/branches/${encodeURIComponent(await repo.branch())}`)).commit.id;
+		},
+		async files(commit, directory) {
+			const files = [];
+			let page = `/repository/tree?path=${encodeURIComponent(directory)}&ref=${encodeURIComponent(commit)}&recursive=true&per_page=${PAGE_SIZE}&pagination=keyset`;
+			while (page) {
+				const response = await repo.send(page);
+				if (response.status === 404) return [];
+				const items = await (await repo.check(response)).json();
+				files.push(...items.filter((item) => item.type === "blob").map((item) => ({
+					path: item.path,
+					sha: item.id
+				})));
+				page = nextPage(response.headers.get("link"));
+			}
+			return files;
+		},
+		async read(sha) {
+			return (await repo.check(await repo.send(`/repository/blobs/${sha}/raw`))).text();
+		},
+		async commit(files, message, parent) {
+			const actions = publishable((await Promise.all(files.map(async (file) => {
+				const found = await existing(file.path, parent);
+				if ("removed" in file) return found ? {
+					action: "delete",
+					file_path: file.path,
+					last_commit_id: found.last_commit_id
+				} : void 0;
+				return found ? {
+					action: "update",
+					file_path: file.path,
+					content: file.data,
+					encoding: file.encoding === "base64" ? "base64" : "text",
+					last_commit_id: found.last_commit_id
+				} : {
+					action: "create",
+					file_path: file.path,
+					content: file.data,
+					encoding: file.encoding === "base64" ? "base64" : "text"
+				};
+			}))).filter((action) => action !== void 0));
+			return (await repo.post("/repository/commits", {
+				branch: await repo.branch(),
+				commit_message: message,
+				actions
+			})).id;
+		},
+		async checks(commit) {
+			return (await repo.call(`/pipelines?sha=${commit}&per_page=${PAGE_SIZE}`)).filter((pipeline) => pipeline.source !== "schedule").map((pipeline) => ({
+				name: pipeline.name || `Pipeline #${pipeline.iid ?? pipeline.id}`,
+				state: pipelineState(pipeline.status),
+				url: pipeline.web_url
+			}));
+		},
+		async contains(commit, ancestor) {
+			const refs = new URLSearchParams([["refs[]", commit], ["refs[]", ancestor]]);
+			return commit === ancestor || (await repo.call(`/repository/merge_base?${refs.toString()}`)).id === ancestor;
+		}
+	};
+}
+function createForge(config, token) {
+	if (config.type === "gitlab") return createGitLabForge(config, token);
+	if (config.type === "forgejo") return createForgejoForge(config, token);
+	return createGitHubForge(config, token);
+}
+const SKEW = 3e4;
+function toTokens(response, now = Date.now()) {
+	return {
+		access: response.access_token,
+		...response.refresh_token ? { refresh: response.refresh_token } : {},
+		...response.expires_in === void 0 ? {} : { expires: now + response.expires_in * 1e3 }
+	};
+}
+function expired(tokens, now = Date.now()) {
+	return tokens.expires !== void 0 && tokens.expires - SKEW <= now;
+}
+function server(endpoints) {
+	return {
+		issuer: endpoints.issuer,
+		authorization_endpoint: endpoints.authorize,
+		token_endpoint: endpoints.token
+	};
+}
+function requestOptions(endpoints) {
+	return { [allowInsecureRequests]: new URL(endpoints.token).protocol === "http:" };
+}
+function refusal(error) {
+	if (error instanceof AuthorizationResponseError) return new Error(`[forgepress] the forge refused the sign-in: ${error.error_description || error.error}`, { cause: error });
+	if (error instanceof ResponseBodyError) return new Error(`[forgepress] the forge rejected the token request: ${error.error_description || error.error}`, { cause: error });
+	return error;
+}
+async function renew(endpoints, clientId, refresh) {
+	const as = server(endpoints);
+	const client = { client_id: clientId };
+	try {
+		const response = await refreshTokenGrantRequest(as, client, None(), refresh, requestOptions(endpoints));
+		return toTokens(await processRefreshTokenResponse(as, client, response));
+	} catch (error) {
+		throw refusal(error);
+	}
+}
+function storedTokens(value) {
+	if (typeof value === "string") return value ? { access: value } : void 0;
+	return value;
+}
+async function refreshed(tokens, config) {
+	const oauth = describe(config).oauth;
+	if (!expired(tokens) || !tokens.refresh || !oauth || !config.clientId) return tokens;
+	return renew(oauth, config.clientId, tokens.refresh);
+}
+function createTokenGetter(config, read, write) {
+	let renewal;
+	async function renewed(tokens) {
+		const next = await refreshed(tokens, config);
+		if (next !== tokens) await write(next);
+		return next;
+	}
+	return async () => {
+		const tokens = await read();
+		if (!expired(tokens)) return tokens.access;
+		renewal ??= renewed(tokens).finally(() => {
+			renewal = void 0;
+		});
+		return (await renewal).access;
+	};
+}
+const CONCURRENCY = 8;
+function limit(size) {
+	const waiting = [];
+	let active = 0;
+	return async (task) => {
+		if (active < size) active += 1;
+		else await new Promise((resolve) => waiting.push(resolve));
+		try {
+			return await task();
+		} finally {
+			const next = waiting.shift();
+			if (next) next();
+			else active -= 1;
+		}
+	};
+}
+function createForgeSource(forge, target, cache) {
+	const { paths, mediaDir } = target;
+	const queue = limit(CONCURRENCY);
+	const texts = /* @__PURE__ */ new Map();
+	let pinned;
+	let snapshot = once(load);
+	function client() {
+		const current = forge();
+		if (!current) throw new Error("[forgepress] sign in to read the content from the repository");
+		return current;
+	}
+	async function restore(hashes) {
+		const cached = await cache?.keep(hashes).catch(() => void 0);
+		for (const [sha, content] of cached ?? []) if (!texts.has(sha)) texts.set(sha, Promise.resolve(content));
+	}
+	async function listing(commit, directory) {
+		const stored = await cache?.readListing(commit, directory).catch(() => void 0);
+		if (stored) return stored;
+		const listed = new Map((await client().files(commit, directory)).map((file) => [file.path, file.sha]));
+		if (forge()) cache?.writeListing(commit, directory, listed).catch(() => void 0);
+		return listed;
+	}
+	async function uploads(commit) {
+		if (mediaDir === void 0) return [];
+		return [...(await listing(commit, mediaDir)).keys()].map((path) => path.slice(mediaDir.length + 1)).filter(isMediaFile);
+	}
+	async function load() {
+		const commit = pinned ?? await client().head();
+		const listed = await listing(commit, paths.dir);
+		await restore(new Set(listed.values()));
+		return {
+			commit,
+			files: listed,
+			media: once(() => uploads(commit))
+		};
+	}
+	function text(sha) {
+		let pending = texts.get(sha);
+		if (!pending) {
+			pending = queue(() => client().read(sha));
+			texts.set(sha, pending);
+			pending.then((content) => forge() && cache?.writeFile(sha, content), () => texts.delete(sha)).catch(() => void 0);
+		}
+		return pending;
+	}
+	async function hash(path) {
+		return (await snapshot()).files.get(path);
+	}
+	return {
+		...createFileSource({
+			list: async (directory) => [...(await snapshot()).files.keys()].filter((path) => path.startsWith(`${directory}/`)),
+			read: async (path) => {
+				const sha = await hash(path);
+				return sha === void 0 ? void 0 : text(sha);
+			}
+		}, paths),
+		hashes: { entry: async (collection, id) => isEntryId(id) ? hash(paths.entry(collection, id)) : void 0 },
+		media: async () => mediaDir === void 0 ? [] : (await snapshot()).media(),
+		read: text,
+		reset: (commit) => {
+			pinned = commit;
+			snapshot = once(load);
+		}
+	};
+}
+const CHANGES = createStore("forgepress", "changes");
+const FILES = createStore("forgepress-cache", "files");
+const LISTINGS = createStore("forgepress-listings", "listings");
+function createIdbStore(key) {
+	return {
+		read: () => get(key, CHANGES),
+		write: (value) => set(key, value, CHANGES),
+		clear: () => del(key, CHANGES)
+	};
+}
+function createIdbCache() {
+	return {
+		readListing: async (commit, directory) => {
+			const stored = await get(directory, LISTINGS);
+			return stored?.commit === commit ? stored.files : void 0;
+		},
+		writeListing: (commit, directory, files) => set(directory, {
+			commit,
+			files
+		}, LISTINGS),
+		keep: async (hashes) => {
+			const kept = /* @__PURE__ */ new Map();
+			const stale = [];
+			for (const [key, text] of await entries(FILES)) if (typeof key === "string" && hashes.has(key)) kept.set(key, text);
+			else stale.push(key);
+			if (stale.length > 0) await delMany(stale, FILES);
+			return kept;
+		},
+		writeFile: (hash, text) => set(hash, text, FILES),
+		clear: async () => {
+			await Promise.all([clear(FILES), clear(LISTINGS)]);
+		}
+	};
+}
+function createMemoryStore() {
+	let value;
+	return {
+		read: async () => value,
+		write: async (next) => {
+			value = next;
+		},
+		clear: async () => {
+			value = void 0;
+		}
+	};
+}
+const TOKEN_KEY = "token";
+const CHANGES_KEY = "changes";
+function persist(key) {
+	return typeof indexedDB === "undefined" ? createMemoryStore() : createIdbStore(key);
+}
+function repositoryCache() {
+	return typeof indexedDB === "undefined" ? void 0 : createIdbCache();
+}
+function swap(value, urls) {
+	if (typeof value === "string") return [...urls].reduce((text, [url, local]) => text.split(url).join(local), value);
+	if (Array.isArray(value)) return value.map((item) => swap(item, urls));
+	if (isRecord(value)) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, swap(item, urls)]));
+	return value;
+}
+function createPreviewReader(settings) {
+	const tokens = persist(TOKEN_KEY);
+	const pending = persist(CHANGES_KEY);
+	const previews = createPreviews();
+	const shown = /* @__PURE__ */ new Set();
+	let token;
+	async function saved() {
+		const found = storedTokens(await tokens.read());
+		if (!found) throw new Error("[forgepress] sign in to the editor to preview unpublished content");
+		return found;
+	}
+	const access = createTokenGetter(settings.provider, saved, (next) => tokens.write(next));
+	const forge = createForge(settings.provider, () => {
+		token ??= access();
+		return token;
+	});
+	const source = createForgeSource(() => forge, { paths: repositoryPaths(createPaths(settings.contentPath), settings.provider.base) }, repositoryCache());
+	function local(changes) {
+		const assets = localUploads(changes).map((upload) => previews.asset(upload, settings.mediaUrl));
+		const names = new Set(assets.map((asset) => asset.name));
+		for (const name of shown) if (!names.has(name)) previews.forget(name);
+		shown.clear();
+		for (const name of names) shown.add(name);
+		return new Map(assets.flatMap((asset) => asset.preview ? [[asset.url, asset.preview]] : []));
+	}
+	return { build: async () => {
+		token = void 0;
+		source.reset();
+		const changes = await readChanges(pending);
+		const content = createContentChanges(source, async () => changes, async () => {
+			throw new Error("[forgepress] the preview only reads content");
+		});
+		const schema = await content.schema();
+		const urls = local(changes);
+		const listed = await Promise.all(Object.keys(schema.collections).map(async (collection) => [collection, await content.list(collection)]));
+		const entries = Object.fromEntries(listed.map(([collection, rows]) => [collection, Object.fromEntries(rows.map((row) => [row.id, urls.size > 0 ? swap(row, urls) : row]))]));
+		const files = await createOutput(schema, entries, {
+			commit: null,
+			unpublished: true
+		});
+		return new Map(files.map((file) => [file.path, file.text]));
+	} };
+}
+export { createPreviewReader };