forgepress 0.0.0 → 0.0.1

package/dist/_chunks/reader2.mjs

@@ -0,0 +1,849 @@
+import { isRecord, plain, same } from "./value.mjs";
+import { assetUrl, base64ToText, createOutput, createPaths, isEntryFile, isEntryId, isMediaFile, prefixer, sortByCreation, textToBase64 } from "./output.mjs";
+import "./validate.mjs";
+import { parseEntry, parseSchema } from "./parse.mjs";
+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 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);
+		}
+	};
+}
+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: {
+			authorize: `${root}/oauth/authorize`,
+			token: `${root}/oauth/token`
+		}
+	};
+	return {
+		...shared,
+		api: `${root}/api/v1`,
+		scopes: config.scopes ?? ["read:user", "write:repository"],
+		oauth: {
+			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 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();
+	}
+	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,
+		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) {
+		const response = await repo.send(`/contents/${encodePath(path)}?ref=${encodeURIComponent(ref)}`);
+		if (response.status === 404) return void 0;
+		return (await (await repo.check(response)).json()).sha;
+	}
+	return {
+		async access() {
+			const [user, repository] = await Promise.all([repo.call(`${api}/user`), repo.details()]);
+			return {
+				identity: {
+					login: user.login,
+					...user.full_name ? { name: user.full_name } : {},
+					...user.avatar_url ? { avatar: 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 (await entries(tree, true)).filter((item) => item.type === "blob").map((item) => ({
+				path: `${directory}/${item.path}`,
+				sha: item.sha
+			}));
+		},
+		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"
+]);
+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 readable(path) {
+		const response = await repo.send(path);
+		if (response.status === 403 || response.status === 404) return void 0;
+		return await (await repo.check(response)).json();
+	}
+	async function runs(commit) {
+		return (await readable(`/actions/runs?head_sha=${commit}&per_page=100`))?.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 readable(`/commits/${commit}/status?per_page=100`))?.statuses.map((status) => ({
+			name: status.context,
+			state: statusState(status.state),
+			...linked(status.target_url)
+		}));
+	}
+	async function others(commit) {
+		const found = apps ? await readable(`/commits/${commit}/check-runs?per_page=100`) : 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: {
+					login: user.login,
+					...user.name ? { name: user.name } : {},
+					...user.avatar_url ? { avatar: 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 tree.tree.filter((item) => item.type === "blob").map((item) => ({
+				path: `${directory}/${item.path}`,
+				sha: item.sha
+			}));
+		},
+		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);
+	async function existing(path, ref) {
+		const response = await repo.send(`/repository/files/${encodeURIComponent(path)}?ref=${encodeURIComponent(ref)}`);
+		if (response.status === 404) return void 0;
+		return await (await repo.check(response)).json();
+	}
+	return {
+		async access() {
+			const [user, project] = await Promise.all([repo.call(`${api}/user`), repo.details()]);
+			return {
+				identity: {
+					login: user.username,
+					...user.name ? { name: user.name } : {},
+					...user.avatar_url ? { avatar: 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(payload, now = Date.now()) {
+	const access = payload.access_token;
+	if (typeof access !== "string" || !access) throw new Error("[forgepress] the forge returned no access token");
+	const refresh = payload.refresh_token;
+	const expires = payload.expires_in;
+	return {
+		access,
+		...typeof refresh === "string" && refresh ? { refresh } : {},
+		...typeof expires === "number" ? { expires: now + expires * 1e3 } : {}
+	};
+}
+function expired(tokens, now = Date.now()) {
+	return tokens.expires !== void 0 && tokens.expires - SKEW <= now;
+}
+async function form(endpoints, body) {
+	const response = await fetch(endpoints.token, {
+		method: "POST",
+		headers: {
+			"accept": "application/json",
+			"content-type": "application/x-www-form-urlencoded"
+		},
+		body: new URLSearchParams(body).toString()
+	});
+	if (!response.ok) throw new Error(`[forgepress] the forge rejected the token request (${response.status}): ${(await response.text()).slice(0, 200)}`);
+	return toTokens(await response.json());
+}
+function renew(endpoints, clientId, refresh) {
+	return form(endpoints, {
+		client_id: clientId,
+		grant_type: "refresh_token",
+		refresh_token: refresh
+	});
+}
+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);
+}
+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, paths, base, cache, mediaDir) {
+	const at = prefixer(base);
+	const queue = limit(CONCURRENCY);
+	const texts = /* @__PURE__ */ new Map();
+	let snapshot;
+	let pinned;
+	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 load() {
+		const commit = pinned ?? await client().head();
+		const listed = await listing(commit, at(paths.dir));
+		await restore(new Set(listed.values()));
+		return {
+			commit,
+			files: listed
+		};
+	}
+	function current() {
+		if (!snapshot) {
+			const loading = load();
+			snapshot = loading;
+			loading.catch(() => {
+				if (snapshot === loading) snapshot = void 0;
+			});
+		}
+		return snapshot;
+	}
+	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 files() {
+		return (await current()).files;
+	}
+	async function hash(path) {
+		return (await files()).get(path);
+	}
+	async function media() {
+		if (mediaDir === void 0) return [];
+		const found = await current();
+		const directory = `${at(mediaDir)}/`;
+		if (!found.media) {
+			const loading = listing(found.commit, at(mediaDir)).then((listed) => [...listed.keys()].map((path) => path.slice(directory.length)).filter(isMediaFile));
+			found.media = loading;
+			loading.catch(() => {
+				if (found.media === loading) delete found.media;
+			});
+		}
+		return found.media;
+	}
+	async function list(collection) {
+		const directory = `${at(paths.collection(collection))}/`;
+		const rows = [...await files()].filter(([path]) => path.startsWith(directory) && isEntryFile(path.slice(directory.length))).map(async ([path, sha]) => parseEntry(await text(sha), path));
+		return sortByCreation(await Promise.all(rows));
+	}
+	return {
+		schema: async () => {
+			const path = at(paths.schema);
+			const sha = await hash(path);
+			if (sha === void 0) throw new Error(`[forgepress] ${path} does not exist in the repository`);
+			return parseSchema(await text(sha), path);
+		},
+		list,
+		entry: async (collection, id) => {
+			const path = at(paths.entry(collection, id));
+			const sha = isEntryId(id) ? await hash(path) : void 0;
+			return sha === void 0 ? void 0 : parseEntry(await text(sha), path);
+		},
+		hashes: { entry: async (collection, id) => isEntryId(id) ? hash(at(paths.entry(collection, id))) : void 0 },
+		media,
+		read: text,
+		reset: (commit) => {
+			pinned = commit;
+			snapshot = void 0;
+		}
+	};
+}
+const DATABASE = "forgepress";
+const STORE = "changes";
+const CACHE = "forgepress-cache";
+const FILES = "files";
+const LISTINGS = "listings";
+const STORES = {
+	[DATABASE]: [STORE],
+	[CACHE]: [FILES, LISTINGS]
+};
+function settle(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error ?? /* @__PURE__ */ new Error("[forgepress] IndexedDB request failed"));
+	});
+}
+function open(name) {
+	return new Promise((resolve, reject) => {
+		const opening = indexedDB.open(name, 1);
+		opening.onupgradeneeded = () => {
+			for (const store of STORES[name] ?? []) if (!opening.result.objectStoreNames.contains(store)) opening.result.createObjectStore(store);
+		};
+		opening.onsuccess = () => resolve(opening.result);
+		opening.onerror = () => reject(opening.error ?? /* @__PURE__ */ new Error("[forgepress] IndexedDB is unavailable"));
+		opening.onblocked = () => reject(/* @__PURE__ */ new Error("[forgepress] IndexedDB is blocked by another open tab"));
+	});
+}
+const databases = /* @__PURE__ */ new Map();
+async function transact(name, store, mode, run) {
+	let database = databases.get(name);
+	if (!database) {
+		database = open(name);
+		databases.set(name, database);
+	}
+	return await run((await database).transaction(store, mode).objectStore(store));
+}
+function createIdbStore(key) {
+	return {
+		read: () => transact(DATABASE, STORE, "readonly", (objects) => settle(objects.get(key))),
+		write: async (value) => {
+			await transact(DATABASE, STORE, "readwrite", (objects) => settle(objects.put(value, key)));
+		},
+		clear: async () => {
+			await transact(DATABASE, STORE, "readwrite", (objects) => settle(objects.delete(key)));
+		}
+	};
+}
+function createIdbCache() {
+	return {
+		readListing: async (commit, directory) => {
+			const stored = await transact(CACHE, LISTINGS, "readonly", (objects) => settle(objects.get(directory)));
+			return stored?.commit === commit ? stored.files : void 0;
+		},
+		writeListing: async (commit, directory, files) => {
+			await transact(CACHE, LISTINGS, "readwrite", (objects) => settle(objects.put({
+				commit,
+				files
+			}, directory)));
+		},
+		keep: (hashes) => transact(CACHE, FILES, "readwrite", (objects) => new Promise((resolve, reject) => {
+			const keys = objects.getAllKeys();
+			const values = objects.getAll();
+			keys.onerror = () => reject(keys.error ?? /* @__PURE__ */ new Error("[forgepress] IndexedDB request failed"));
+			values.onerror = () => reject(values.error ?? /* @__PURE__ */ new Error("[forgepress] IndexedDB request failed"));
+			values.onsuccess = () => {
+				const kept = /* @__PURE__ */ new Map();
+				keys.result.forEach((key, index) => {
+					if (typeof key === "string" && hashes.has(key)) kept.set(key, values.result[index]);
+					else objects.delete(key);
+				});
+				resolve(kept);
+			};
+		})),
+		writeFile: async (hash, text) => {
+			await transact(CACHE, FILES, "readwrite", (objects) => settle(objects.put(text, hash)));
+		},
+		clear: async () => {
+			await Promise.all([FILES, LISTINGS].map((store) => transact(CACHE, store, "readwrite", (objects) => settle(objects.clear()))));
+		}
+	};
+}
+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 uploads(changes) {
+	return [...Object.values(changes.uploads), ...publishedUploads(changes)];
+}
+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 access() {
+		const saved = storedTokens(await tokens.read());
+		if (!saved) throw new Error("[forgepress] sign in to the editor to preview unpublished content");
+		const current = await refreshed(saved, settings.provider);
+		if (current !== saved) await tokens.write(current);
+		return current.access;
+	}
+	const forge = createForge(settings.provider, () => {
+		token ??= access();
+		return token;
+	});
+	const source = createForgeSource(() => forge, createPaths(settings.contentPath), settings.provider.base, repositoryCache());
+	function local(changes) {
+		const assets = uploads(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 = {
+			entries: {},
+			uploads: {},
+			removed: [],
+			...await pending.read()
+		};
+		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 };