forgepress 0.0.1 → 0.0.2

package/dist/_chunks/reader2.mjs

@@ -1,7 +1,11 @@
 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";
+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]));
@@ -41,6 +45,10 @@ function createContentChanges(base, ready, mutate) {
 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) {
@@ -76,6 +84,19 @@ function createPreviews() {
 		}
 	};
 }
+function emptyChanges() {
+	return {
+		entries: {},
+		uploads: {},
+		removed: []
+	};
+}
+async function readChanges(store) {
+	return {
+		...emptyChanges(),
+		...await store.read()
+	};
+}
 const PROVIDERS = {
 	github: {
 		name: "GitHub",
@@ -118,6 +139,7 @@ function describe(config) {
 		api: `${root}/api/v4`,
 		scopes: config.scopes ?? ["api"],
 		oauth: {
+			issuer: root,
 			authorize: `${root}/oauth/authorize`,
 			token: `${root}/oauth/token`
 		}
@@ -127,6 +149,7 @@ function describe(config) {
 		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`
 		}
@@ -136,6 +159,19 @@ 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;
@@ -158,6 +194,11 @@ function createRepositoryApi(config, base, token, headers = {}) {
 		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",
@@ -176,6 +217,7 @@ function createRepositoryApi(config, base, token, headers = {}) {
 		send,
 		check,
 		call,
+		find,
 		post,
 		details,
 		branch
@@ -213,19 +255,13 @@ function createForgejoForge(config, token) {
 		}
 	}
 	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 (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: {
-					login: user.login,
-					...user.full_name ? { name: user.full_name } : {},
-					...user.avatar_url ? { avatar: user.avatar_url } : {}
-				},
+				identity: toIdentity(user.login, user.full_name, user.avatar_url),
 				writable: repository.permissions?.push === true,
 				branch: await repo.branch()
 			};
@@ -236,10 +272,7 @@ function createForgejoForge(config, token) {
 		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
-			}));
+			return blobs(directory, await entries(tree, true));
 		},
 		async read(blob) {
 			return base64ToText((await repo.call(`/git/blobs/${blob}`)).content);
@@ -288,6 +321,7 @@ const FAILED = /* @__PURE__ */ new Set([
 	"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";
@@ -307,27 +341,22 @@ function createGitHubForge(config, token) {
 		"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) => ({
+		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 readable(`/commits/${commit}/status?per_page=100`))?.statuses.map((status) => ({
+		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 readable(`/commits/${commit}/check-runs?per_page=100`) : void 0;
+		const found = apps ? await repo.find(`/commits/${commit}/check-runs?per_page=100`, UNREADABLE) : void 0;
 		if (!found) {
 			apps = false;
 			return [];
@@ -342,11 +371,7 @@ function createGitHubForge(config, token) {
 		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 } : {}
-				},
+				identity: toIdentity(user.login, user.name, user.avatar_url),
 				writable: repository.permissions?.push === true,
 				branch: await repo.branch()
 			};
@@ -359,10 +384,7 @@ function createGitHubForge(config, token) {
 			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
-			}));
+			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();
@@ -449,20 +471,14 @@ function nextPage(link) {
 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();
+	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: {
-					login: user.username,
-					...user.name ? { name: user.name } : {},
-					...user.avatar_url ? { avatar: user.avatar_url } : {}
-				},
+				identity: toIdentity(user.username, user.name, user.avatar_url),
 				writable: writable(project),
 				branch: await repo.branch()
 			};
@@ -534,38 +550,40 @@ function createForge(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;
+function toTokens(response, now = Date.now()) {
 	return {
-		access,
-		...typeof refresh === "string" && refresh ? { refresh } : {},
-		...typeof expires === "number" ? { expires: now + expires * 1e3 } : {}
+		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;
 }
-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 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;
@@ -576,6 +594,22 @@ async function refreshed(tokens, config) {
 	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 = [];
@@ -592,12 +626,12 @@ function limit(size) {
 		}
 	};
 }
-function createForgeSource(forge, paths, base, cache, mediaDir) {
-	const at = prefixer(base);
+function createForgeSource(forge, target, cache) {
+	const { paths, mediaDir } = target;
 	const queue = limit(CONCURRENCY);
 	const texts = /* @__PURE__ */ new Map();
-	let snapshot;
 	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");
@@ -614,25 +648,20 @@ function createForgeSource(forge, paths, base, cache, mediaDir) {
 		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, at(paths.dir));
+		const listed = await listing(commit, paths.dir);
 		await restore(new Set(listed.values()));
 		return {
 			commit,
-			files: listed
+			files: listed,
+			media: once(() => uploads(commit))
 		};
 	}
-	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) {
@@ -642,129 +671,57 @@ function createForgeSource(forge, paths, base, cache, mediaDir) {
 		}
 		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 (await snapshot()).files.get(path);
 	}
 	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,
+		...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 = void 0;
+			snapshot = once(load);
 		}
 	};
 }
-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));
-}
+const CHANGES = createStore("forgepress", "changes");
+const FILES = createStore("forgepress-cache", "files");
+const LISTINGS = createStore("forgepress-listings", "listings");
 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)));
-		}
+		read: () => get(key, CHANGES),
+		write: (value) => set(key, value, CHANGES),
+		clear: () => del(key, CHANGES)
 	};
 }
 function createIdbCache() {
 	return {
 		readListing: async (commit, directory) => {
-			const stored = await transact(CACHE, LISTINGS, "readonly", (objects) => settle(objects.get(directory)));
+			const stored = await get(directory, LISTINGS);
 			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)));
+		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([FILES, LISTINGS].map((store) => transact(CACHE, store, "readwrite", (objects) => settle(objects.clear()))));
+			await Promise.all([clear(FILES), clear(LISTINGS)]);
 		}
 	};
 }
@@ -794,29 +751,25 @@ function swap(value, 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;
+	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, createPaths(settings.contentPath), settings.provider.base, repositoryCache());
+	const source = createForgeSource(() => forge, { paths: repositoryPaths(createPaths(settings.contentPath), settings.provider.base) }, repositoryCache());
 	function local(changes) {
-		const assets = uploads(changes).map((upload) => previews.asset(upload, settings.mediaUrl));
+		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();
@@ -826,12 +779,7 @@ function createPreviewReader(settings) {
 	return { build: async () => {
 		token = void 0;
 		source.reset();
-		const changes = {
-			entries: {},
-			uploads: {},
-			removed: [],
-			...await pending.read()
-		};
+		const changes = await readChanges(pending);
 		const content = createContentChanges(source, async () => changes, async () => {
 			throw new Error("[forgepress] the preview only reads content");
 		});

package/dist/_chunks/references.mjs

@@ -1,7 +1,10 @@
-import { isRecord, quote } from "./value.mjs";
+import { isRecord, isTranslated, quote } from "./value.mjs";
 function entryKey(collection, id) {
 	return `${collection}/${id}`;
 }
+function isEntryRef(value) {
+	return isRecord(value) && typeof value.collection === "string" && typeof value.id === "string";
+}
 function localized(value, path, translated) {
 	if (!translated) return [[path, value]];
 	return isRecord(value) ? Object.entries(value).map(([locale, item]) => [[...path, locale], item]) : [];
@@ -18,7 +21,7 @@ function references(field, value, path) {
 		collection: field.collection,
 		id
 	}] : []);
-	if (field.type === "dynamic") return value.flatMap((block, index) => isRecord(block) && typeof block.id === "string" && typeof block.collection === "string" && field.collections.includes(block.collection) ? [{
+	if (field.type === "dynamic") return value.flatMap((block, index) => isEntryRef(block) && field.collections.includes(block.collection) ? [{
 		path: [...path, index],
 		collection: block.collection,
 		id: block.id
@@ -26,8 +29,8 @@ function references(field, value, path) {
 	return [];
 }
 function entryReferences(schema, collection, row) {
-	const translatable = (schema.locales ?? []).length > 0;
-	return Object.entries(schema.collections[collection]?.fields ?? {}).flatMap(([key, field]) => localized(row[key], [key], translatable && field.translate === true).flatMap(([path, value]) => references(field, value, path)));
+	const locales = schema.locales ?? [];
+	return Object.entries(schema.collections[collection]?.fields ?? {}).flatMap(([key, field]) => localized(row[key], [key], isTranslated(field, locales)).flatMap(([path, value]) => references(field, value, path)));
 }
 function validateReferences(schema, content) {
 	const issues = [];
@@ -50,4 +53,4 @@ function validateReferences(schema, content) {
 	}
 	return issues;
 }
-export { entryKey, validateReferences };
+export { entryKey, isEntryRef, validateReferences };

package/dist/_chunks/resolve.d.mts

@@ -0,0 +1,2 @@
+import "./types.mjs";
+import "./types2.mjs";

package/dist/_chunks/response.mjs

@@ -0,0 +1,5 @@
+const OUTPUT_INDEX = "index.json";
+function isPage(response) {
+	return response.headers.get("content-type")?.includes("text/html") === true;
+}
+export { OUTPUT_INDEX, isPage };

package/dist/_chunks/routes.mjs

@@ -0,0 +1,9 @@
+const ENDPOINT = "/__forgepress";
+const EVENTS = `${ENDPOINT}/events`;
+const ROUTES = {
+	schema: "/schema",
+	content: "/content",
+	entry: "/entry",
+	media: "/media"
+};
+export { ENDPOINT, EVENTS, ROUTES };