forgepress 0.0.1 → 0.0.2

package/dist/_chunks/{validate.mjs → content.mjs}

@@ -1,5 +1,136 @@
-import { isRecord, quote } from "./value.mjs";
-import { isCollectionName } from "./output.mjs";
+import { ENTRY_STATUSES, META_KEYS, compilePattern, fieldTypeNames, fieldTypes, isRecord, isTranslated, quote } from "./value.mjs";
+import { entryKey, validateReferences } from "./references.mjs";
+import { isCollectionName, isEntryFile, isEntryId, sortByCreation, toEntryFile, toEntryId, toEntryRef } from "./media.mjs";
+const LOCALE_CODE = /^[a-z][\w-]*$/i;
+const RESERVED_FIELDS = META_KEYS;
+const SCHEMA_KEYS = /* @__PURE__ */ new Set(["collections", "locales"]);
+const COLLECTION_KEYS = /* @__PURE__ */ new Set([
+	"label",
+	"description",
+	"fields"
+]);
+const BASE_OPTIONS = {
+	label: "text",
+	description: "text",
+	optional: "boolean",
+	translate: "boolean"
+};
+const INDEXABLE = fieldTypeNames.filter((type) => "index" in fieldTypes[type].options);
+const KINDS = {
+	text: "a string",
+	number: "a number",
+	boolean: "true or false",
+	collection: "a collection name",
+	collections: "a list of collection names"
+};
+function isFieldType(type) {
+	return typeof type === "string" && fieldTypeNames.includes(type);
+}
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function fits(kind, value) {
+	if (kind === "number") return finite(value);
+	if (kind === "boolean") return typeof value === "boolean";
+	if (kind === "collections") return Array.isArray(value) && value.every((item) => typeof item === "string");
+	return typeof value === "string";
+}
+function optionKinds(type) {
+	const options = Object.entries(fieldTypes[type].options).map(([option, spec]) => [option, spec.type]);
+	return {
+		...BASE_OPTIONS,
+		...Object.fromEntries(options)
+	};
+}
+function checkLocales(report, locales) {
+	if (locales === void 0) return [];
+	if (!Array.isArray(locales)) {
+		report(["locales"], "\"locales\" has to be a list of locale codes");
+		return [];
+	}
+	locales.forEach((locale, index) => {
+		if (typeof locale !== "string" || !LOCALE_CODE.test(locale)) report(["locales", index], `${quote(locale)} is not a locale code`);
+		else if (locales.indexOf(locale) < index) report(["locales", index], `Locale ${quote(locale)} is listed twice`);
+	});
+	return locales;
+}
+function checkReferences(context, path, label, targets, listed) {
+	targets.forEach((target, index) => {
+		const at = listed ? [...path, index] : path;
+		if (!context.collections.has(target)) context.report(at, `Field ${quote(label)} references unknown collection ${quote(target)}`);
+		else if (targets.indexOf(target) < index) context.report(at, `Field ${quote(label)} lists collection ${quote(target)} twice`);
+	});
+}
+function checkOption(context, path, label, option, kind, value) {
+	if (!fits(kind, value)) context.report(path, `${quote(option)} of field ${quote(label)} has to be ${KINDS[kind]}`);
+	else if (kind === "collection" || kind === "collections") checkReferences(context, path, label, kind === "collection" ? [value] : value, kind === "collections");
+}
+function checkConstraints(report, path, label, field) {
+	if (field.type === "text" && typeof field.validation === "string") {
+		const pattern = compilePattern(field.validation);
+		if (pattern instanceof SyntaxError) report([...path, "validation"], `"validation" of field ${quote(label)} is not a valid regular expression: ${pattern.message.replace(/^Invalid regular expression: /, "")}`);
+	}
+	if (field.type !== "number") return;
+	if (finite(field.step) && field.step <= 0) report([...path, "step"], `"step" of field ${quote(label)} has to be greater than 0`);
+	if (finite(field.min) && finite(field.max) && field.min > field.max) report([...path, "min"], `"min" of field ${quote(label)} can't be greater than "max"`);
+}
+function checkField(context, path, collection, key, field) {
+	const { report } = context;
+	const label = `${collection}.${key}`;
+	if (RESERVED_FIELDS.includes(key)) report(path, `Field ${quote(label)} uses ${quote(key)}, which is reserved for entry metadata`);
+	if (!isRecord(field)) return report(path, `Field ${quote(label)} has to be an object`);
+	if (field.type === void 0) return report(path, `Field ${quote(label)} needs a type`);
+	if (!isFieldType(field.type)) return report([...path, "type"], `Field ${quote(label)} has unknown type ${quote(field.type)}; use one of ${fieldTypeNames.join(", ")}`);
+	const kinds = optionKinds(field.type);
+	for (const [option, value] of Object.entries(field)) {
+		const kind = kinds[option];
+		if (option === "type") continue;
+		if (kind) checkOption(context, [...path, option], label, option, kind, value);
+		else if (option === "index") report([...path, option], `Field ${quote(label)} can't be indexed; only ${INDEXABLE.slice(0, -1).join(", ")} and ${INDEXABLE.at(-1)} fields can`);
+		else report([...path, option], `Field ${quote(label)} has no option ${quote(option)}`);
+	}
+	for (const [option, spec] of Object.entries(fieldTypes[field.type].options)) if ("required" in spec && field[option] === void 0) report(path, `Field ${quote(label)} needs ${quote(option)}`);
+	checkConstraints(report, path, label, field);
+	if (field.translate === true && context.locales.length === 0) report([...path, "translate"], `Field ${quote(label)} is translated, but the schema has no locales`);
+}
+function checkCollection(context, name, collection) {
+	const { report } = context;
+	const path = ["collections", name];
+	if (!isCollectionName(name)) report(path, `Collection ${quote(name)} has to start with a lowercase letter and contain only letters and digits`);
+	if (!isRecord(collection)) return report(path, `Collection ${quote(name)} has to be an object`);
+	for (const [key, value] of Object.entries(collection)) if (!COLLECTION_KEYS.has(key)) report([...path, key], `Collection ${quote(name)} has no option ${quote(key)}`);
+	else if (key !== "fields" && typeof value !== "string") report([...path, key], `${quote(key)} of collection ${quote(name)} has to be a string`);
+	if (!isRecord(collection.fields)) return report(collection.fields === void 0 ? path : [...path, "fields"], `Collection ${quote(name)} needs "fields" as an object`);
+	for (const [key, field] of Object.entries(collection.fields)) checkField(context, [
+		...path,
+		"fields",
+		key
+	], name, key, field);
+}
+function validateSchema(schema) {
+	const issues = [];
+	const report = (path, message) => issues.push({
+		path,
+		message
+	});
+	if (!isRecord(schema)) {
+		report([], "The schema has to be an object");
+		return issues;
+	}
+	for (const key of Object.keys(schema)) if (!SCHEMA_KEYS.has(key)) report([key], `The schema has no option ${quote(key)}`);
+	const locales = checkLocales(report, schema.locales);
+	if (!isRecord(schema.collections)) {
+		report(schema.collections === void 0 ? [] : ["collections"], "The schema needs \"collections\" as an object");
+		return issues;
+	}
+	const context = {
+		report,
+		collections: new Set(Object.keys(schema.collections)),
+		locales
+	};
+	for (const [name, collection] of Object.entries(schema.collections)) checkCollection(context, name, collection);
+	return issues;
+}
 function formatIssue(issue) {
 	return `${issue.file}:${issue.line}:${issue.column} ${issue.message}`;
 }
@@ -357,244 +488,246 @@ function parseModule(text, file) {
 		}
 	};
 }
-const META_KEYS = [
-	"id",
-	"status",
-	"createdAt",
-	"updatedAt"
-];
-const dynamic = {
-	type: "dynamic",
-	label: "Dynamic",
-	options: { collections: {
-		label: "Collections",
-		type: "collections",
-		required: true
-	} }
-};
-const image = {
-	type: "image",
-	label: "Image",
-	options: { multiple: {
-		label: "Multiple",
-		type: "boolean"
-	} }
-};
-const number = {
-	type: "number",
-	label: "Number",
-	options: {
-		min: {
-			label: "Minimum",
-			type: "number"
-		},
-		max: {
-			label: "Maximum",
-			type: "number"
-		},
-		step: {
-			label: "Step",
-			type: "number"
-		},
-		index: {
-			label: "Indexed",
-			type: "boolean",
-			description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry."
-		}
-	}
-};
-const relation = {
-	type: "relation",
-	label: "Relation",
-	options: {
-		collection: {
-			label: "Collection",
-			type: "collection",
-			required: true
-		},
-		multiple: {
-			label: "Multiple",
-			type: "boolean"
-		},
-		index: {
-			label: "Indexed",
-			type: "boolean",
-			description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry."
-		}
-	}
-};
-const richtext = {
-	type: "richtext",
-	label: "Rich Text",
-	options: {}
-};
-const text = {
-	type: "text",
-	label: "Text",
-	options: {
-		validation: {
-			label: "Validation Pattern",
-			type: "text"
-		},
-		index: {
-			label: "Indexed",
-			type: "boolean",
-			description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry."
-		}
-	}
-};
-function compilePattern(validation) {
+function parseFile(file) {
 	try {
-		return new RegExp(validation, "u");
+		return parseModule(file.text, file.path);
 	} catch (error) {
-		return error;
-	}
-}
-const fieldTypes = {
-	text,
-	richtext,
-	number,
-	image,
-	video: {
-		type: "video",
-		label: "Video",
-		options: { multiple: {
-			label: "Multiple",
-			type: "boolean"
-		} }
-	},
-	relation,
-	dynamic
-};
-const fieldTypeNames = Object.keys(fieldTypes);
-const LOCALE_CODE = /^[a-z][\w-]*$/i;
-const RESERVED_FIELDS = META_KEYS;
-const SCHEMA_KEYS = /* @__PURE__ */ new Set(["collections", "locales"]);
-const COLLECTION_KEYS = /* @__PURE__ */ new Set([
-	"label",
-	"description",
-	"fields"
-]);
-const BASE_OPTIONS = {
-	label: "text",
-	description: "text",
-	optional: "boolean",
-	translate: "boolean"
-};
-const INDEXABLE = fieldTypeNames.filter((type) => "index" in fieldTypes[type].options);
-const KINDS = {
-	text: "a string",
-	number: "a number",
-	boolean: "true or false",
-	collection: "a collection name",
-	collections: "a list of collection names"
-};
-function isFieldType(type) {
-	return typeof type === "string" && fieldTypeNames.includes(type);
-}
-function finite(value) {
-	return typeof value === "number" && Number.isFinite(value);
-}
-function fits(kind, value) {
-	if (kind === "number") return finite(value);
-	if (kind === "boolean") return typeof value === "boolean";
-	if (kind === "collections") return Array.isArray(value) && value.every((item) => typeof item === "string");
-	return typeof value === "string";
+		if (error instanceof ContentError) return error.issues;
+		throw error;
+	}
 }
-function optionKinds(type) {
-	const options = Object.entries(fieldTypes[type].options).map(([option, spec]) => [option, spec.type]);
+function located(file, parsed, issue) {
 	return {
-		...BASE_OPTIONS,
-		...Object.fromEntries(options)
+		file,
+		...parsed.locate(issue.path),
+		message: issue.message
 	};
 }
-function checkLocales(report, locales) {
-	if (locales === void 0) return [];
-	if (!Array.isArray(locales)) {
-		report(["locales"], "\"locales\" has to be a list of locale codes");
-		return [];
-	}
-	locales.forEach((locale, index) => {
-		if (typeof locale !== "string" || !LOCALE_CODE.test(locale)) report(["locales", index], `${quote(locale)} is not a locale code`);
-		else if (locales.indexOf(locale) < index) report(["locales", index], `Locale ${quote(locale)} is listed twice`);
-	});
-	return locales;
+function parseSchemaFile(file) {
+	const parsed = parseFile(file);
+	if (!("value" in parsed)) return { issues: [...parsed] };
+	const issues = validateSchema(parsed.value);
+	return issues.length > 0 ? { issues: issues.map((issue) => located(file.path, parsed, issue)) } : { schema: parsed.value };
 }
-function checkReferences(context, path, label, targets, listed) {
-	targets.forEach((target, index) => {
-		const at = listed ? [...path, index] : path;
-		if (!context.collections.has(target)) context.report(at, `Field ${quote(label)} references unknown collection ${quote(target)}`);
-		else if (targets.indexOf(target) < index) context.report(at, `Field ${quote(label)} lists collection ${quote(target)} twice`);
+function parseSchema(text, file) {
+	const parsed = parseSchemaFile({
+		path: file,
+		text
 	});
+	if ("issues" in parsed) throw new ContentError(parsed.issues);
+	return parsed.schema;
 }
-function checkOption(context, path, label, option, kind, value) {
-	if (!fits(kind, value)) context.report(path, `${quote(option)} of field ${quote(label)} has to be ${KINDS[kind]}`);
-	else if (kind === "collection" || kind === "collections") checkReferences(context, path, label, kind === "collection" ? [value] : value, kind === "collections");
+function parseEntry(text, file) {
+	const { value, locate } = parseModule(text, file);
+	if (!isRecord(value)) throw new ContentError([{
+		file,
+		...locate([]),
+		message: "An entry has to be an object"
+	}]);
+	return value;
 }
-function checkConstraints(report, path, label, field) {
-	if (field.type === "text" && typeof field.validation === "string") {
-		const pattern = compilePattern(field.validation);
-		if (pattern instanceof SyntaxError) report([...path, "validation"], `"validation" of field ${quote(label)} is not a valid regular expression: ${pattern.message.replace(/^Invalid regular expression: /, "")}`);
+const ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2}))?$/;
+const MEDIA_OPTIONS = {
+	url: ["a string", (value) => typeof value === "string"],
+	alt: ["a string", (value) => typeof value === "string"],
+	width: ["a number", (value) => typeof value === "number"],
+	height: ["a number", (value) => typeof value === "number"]
+};
+const BLOCK_KEYS = /* @__PURE__ */ new Set(["collection", "id"]);
+function isDate(value) {
+	const match = typeof value === "string" ? ISO_DATE.exec(value) : null;
+	if (!match || Number.isNaN(Date.parse(match[0]))) return false;
+	const month = Number(match[2]) - 1;
+	const day = Number(match[3]);
+	const date = new Date(Date.UTC(Number(match[1]), month, day));
+	return date.getUTCMonth() === month && date.getUTCDate() === day;
+}
+function checkMeta(report, entry) {
+	if (entry.id === void 0) report([], "The entry needs an \"id\"");
+	else if (typeof entry.id !== "string" || !isEntryId(entry.id)) report(["id"], "\"id\" has to be a string of letters, digits, \"_\" and \"-\"");
+	if (entry.status === void 0) report([], "The entry needs a \"status\"");
+	else if (!ENTRY_STATUSES.includes(entry.status)) report(["status"], `"status" has to be ${ENTRY_STATUSES.map(quote).join(" or ")}`);
+	for (const key of ["createdAt", "updatedAt"]) if (entry[key] === void 0) report([], `The entry needs ${quote(key)}`);
+	else if (!isDate(entry[key])) report([key], `${quote(key)} has to be an ISO 8601 date such as "2024-01-31T09:30:00Z"`);
+}
+function checkList(report, path, value, message, item) {
+	if (!Array.isArray(value)) return report(path, message);
+	value.forEach((entry, index) => item([...path, index], entry));
+}
+function checkId(report, path, label, collection, value) {
+	if (typeof value !== "string") report(path, `Field ${label} has to hold ids of ${quote(collection)} entries`);
+}
+function checkMedia(report, path, label, value) {
+	if (!isRecord(value)) return report(path, `Field ${label} has to be a media object such as { url: "/uploads/photo.jpg" }`);
+	if (value.url === void 0) report(path, `Field ${label} needs a "url"`);
+	for (const [option, item] of Object.entries(value)) {
+		const spec = MEDIA_OPTIONS[option];
+		if (spec === void 0) report([...path, option], `Field ${label} has no media option ${quote(option)}`);
+		else if (!spec[1](item)) report([...path, option], `${quote(option)} of field ${label} has to be ${spec[0]}`);
 	}
-	if (field.type !== "number") return;
-	if (finite(field.step) && field.step <= 0) report([...path, "step"], `"step" of field ${quote(label)} has to be greater than 0`);
-	if (finite(field.min) && finite(field.max) && field.min > field.max) report([...path, "min"], `"min" of field ${quote(label)} can't be greater than "max"`);
 }
-function checkField(context, path, collection, key, field) {
-	const { report } = context;
-	const label = `${collection}.${key}`;
-	if (RESERVED_FIELDS.includes(key)) report(path, `Field ${quote(label)} uses ${quote(key)}, which is reserved for entry metadata`);
-	if (!isRecord(field)) return report(path, `Field ${quote(label)} has to be an object`);
-	if (field.type === void 0) return report(path, `Field ${quote(label)} needs a type`);
-	if (!isFieldType(field.type)) return report([...path, "type"], `Field ${quote(label)} has unknown type ${quote(field.type)}; use one of ${fieldTypeNames.join(", ")}`);
-	const kinds = optionKinds(field.type);
-	for (const [option, value] of Object.entries(field)) {
-		const kind = kinds[option];
-		if (option === "type") continue;
-		if (kind) checkOption(context, [...path, option], label, option, kind, value);
-		else if (option === "index") report([...path, option], `Field ${quote(label)} can't be indexed; only ${INDEXABLE.slice(0, -1).join(", ")} and ${INDEXABLE.at(-1)} fields can`);
-		else report([...path, option], `Field ${quote(label)} has no option ${quote(option)}`);
+function checkBlock(report, path, label, field, value) {
+	if (!isRecord(value)) return report(path, `Field ${label} has to hold blocks such as { collection: "…", id: "…" }`);
+	if (typeof value.collection !== "string") report(value.collection === void 0 ? path : [...path, "collection"], `A block in field ${label} needs a "collection"`);
+	else if (!field.collections.includes(value.collection)) report([...path, "collection"], `Field ${label} can't hold ${quote(value.collection)} blocks; allowed are ${field.collections.join(", ") || "none"}`);
+	if (typeof value.id !== "string") report(value.id === void 0 ? path : [...path, "id"], `A block in field ${label} needs an "id"`);
+	for (const key of Object.keys(value)) if (!BLOCK_KEYS.has(key)) report([...path, key], `A block in field ${label} has no option ${quote(key)}`);
+}
+function checkPattern(report, path, label, field, value) {
+	const pattern = field.validation === void 0 ? void 0 : compilePattern(field.validation);
+	if (pattern instanceof RegExp && !pattern.test(value)) report(path, `Field ${label} has to match the pattern ${field.validation}`);
+}
+function checkRange(report, path, label, field, value) {
+	const { min, max, step } = field;
+	if (min !== void 0 && value < min) report(path, `Field ${label} has to be at least ${min}`);
+	if (max !== void 0 && value > max) report(path, `Field ${label} has to be at most ${max}`);
+	if (step === void 0 || step <= 0) return;
+	const base = min ?? 0;
+	const steps = (value - base) / step;
+	if (Math.abs(steps - Math.round(steps)) <= 1e-9 * Math.max(1, Math.abs(steps))) return;
+	const nearest = [Math.floor(steps), Math.ceil(steps)].map((count) => Number((base + count * step).toPrecision(12))).filter((candidate) => (min === void 0 || candidate >= min) && (max === void 0 || candidate <= max));
+	report(path, `Field ${label} has to be in steps of ${step}${base === 0 ? "" : ` from ${base}`}${nearest.length > 0 ? `, such as ${nearest.join(" or ")}` : ""}`);
+}
+function checkValue(report, path, label, field, value) {
+	switch (field.type) {
+		case "text":
+			if (typeof value !== "string") report(path, `Field ${label} has to be a string`);
+			else checkPattern(report, path, label, field, value);
+			return;
+		case "richtext":
+			if (typeof value !== "string") report(path, `Field ${label} has to be a string`);
+			return;
+		case "number":
+			if (typeof value !== "number" || !Number.isFinite(value)) report(path, `Field ${label} has to be a number`);
+			else checkRange(report, path, label, field, value);
+			return;
+		case "image":
+		case "video":
+			if (field.multiple) checkList(report, path, value, `Field ${label} has to be a list of media objects`, (at, item) => checkMedia(report, at, label, item));
+			else checkMedia(report, path, label, value);
+			return;
+		case "relation":
+			if (field.multiple) checkList(report, path, value, `Field ${label} has to be a list of ${quote(field.collection)} entry ids`, (at, item) => checkId(report, at, label, field.collection, item));
+			else checkId(report, path, label, field.collection, value);
+			return;
+		case "dynamic": checkList(report, path, value, `Field ${label} has to be a list of blocks`, (at, item) => checkBlock(report, at, label, field, item));
 	}
-	for (const [option, spec] of Object.entries(fieldTypes[field.type].options)) if ("required" in spec && field[option] === void 0) report(path, `Field ${quote(label)} needs ${quote(option)}`);
-	checkConstraints(report, path, label, field);
-	if (field.translate === true && context.locales.length === 0) report([...path, "translate"], `Field ${quote(label)} is translated, but the schema has no locales`);
 }
-function checkCollection(context, name, collection) {
-	const { report } = context;
-	const path = ["collections", name];
-	if (!isCollectionName(name)) report(path, `Collection ${quote(name)} has to start with a lowercase letter and contain only letters and digits`);
-	if (!isRecord(collection)) return report(path, `Collection ${quote(name)} has to be an object`);
-	for (const [key, value] of Object.entries(collection)) if (!COLLECTION_KEYS.has(key)) report([...path, key], `Collection ${quote(name)} has no option ${quote(key)}`);
-	else if (key !== "fields" && typeof value !== "string") report([...path, key], `${quote(key)} of collection ${quote(name)} has to be a string`);
-	if (!isRecord(collection.fields)) return report(collection.fields === void 0 ? path : [...path, "fields"], `Collection ${quote(name)} needs "fields" as an object`);
-	for (const [key, field] of Object.entries(collection.fields)) checkField(context, [
-		...path,
-		"fields",
-		key
-	], name, key, field);
+function checkTranslations(report, key, field, value, locales) {
+	if (!isRecord(value)) return report([key], `Field ${quote(key)} is translated and has to hold one value per locale, such as { ${locales[0]}: … }`);
+	for (const [locale, item] of Object.entries(value)) if (locales.includes(locale)) checkValue(report, [key, locale], `${quote(key)} (${locale})`, field, item);
+	else report([key, locale], `Field ${quote(key)} has no locale ${quote(locale)}; the schema has ${locales.join(", ")}`);
+	const missing = field.optional ? [] : locales.filter((locale) => value[locale] === void 0);
+	if (missing.length > 0) report([key], `Field ${quote(key)} is missing its ${missing.join(", ")} ${missing.length === 1 ? "translation" : "translations"}`);
 }
-function validateSchema(schema) {
+function validateEntry(schema, collection, entry) {
 	const issues = [];
 	const report = (path, message) => issues.push({
 		path,
 		message
 	});
-	if (!isRecord(schema)) {
-		report([], "The schema has to be an object");
+	const definition = schema.collections[collection];
+	const locales = schema.locales ?? [];
+	if (!isRecord(entry)) {
+		report([], "An entry has to be an object");
 		return issues;
 	}
-	for (const key of Object.keys(schema)) if (!SCHEMA_KEYS.has(key)) report([key], `The schema has no option ${quote(key)}`);
-	const locales = checkLocales(report, schema.locales);
-	if (!isRecord(schema.collections)) {
-		report(schema.collections === void 0 ? [] : ["collections"], "The schema needs \"collections\" as an object");
+	if (!definition) {
+		report([], `Collection ${quote(collection)} is not in the schema`);
 		return issues;
 	}
-	const context = {
-		report,
-		collections: new Set(Object.keys(schema.collections)),
-		locales
-	};
-	for (const [name, collection] of Object.entries(schema.collections)) checkCollection(context, name, collection);
+	checkMeta(report, entry);
+	for (const [key, value] of Object.entries(entry)) if (value !== void 0 && !META_KEYS.includes(key) && !Object.hasOwn(definition.fields, key)) report([key], `${quote(key)} is not a field of collection ${quote(collection)}`);
+	for (const [key, field] of Object.entries(definition.fields)) {
+		const value = entry[key];
+		if (value === void 0) {
+			if (!field.optional) report([], `Field ${quote(key)} is required`);
+		} else if (isTranslated(field, locales)) checkTranslations(report, key, field, value, locales);
+		else checkValue(report, [key], quote(key), field, value);
+	}
 	return issues;
 }
-export { ContentError, META_KEYS, compilePattern, formatIssue, parseModule, validateSchema };
+function byPosition(left, right) {
+	return left.line - right.line || left.column - right.column;
+}
+function parseContent(schemaFile, entryFiles) {
+	const parsedSchema = schemaFile ? parseSchemaFile(schemaFile) : { schema: { collections: {} } };
+	if ("issues" in parsedSchema) return {
+		issues: parsedSchema.issues,
+		schema: void 0,
+		content: {}
+	};
+	const { schema } = parsedSchema;
+	const issues = new Map(entryFiles.map((file) => [file.path, []]));
+	const sources = /* @__PURE__ */ new Map();
+	const content = {};
+	for (const file of entryFiles) {
+		const { collection, id, path } = file;
+		const found = issues.get(path);
+		const parsed = parseFile(file);
+		if (!("value" in parsed)) {
+			found.push(...parsed);
+			continue;
+		}
+		found.push(...validateEntry(schema, collection, parsed.value).map((issue) => located(path, parsed, issue)));
+		if (!isRecord(parsed.value)) continue;
+		if (typeof parsed.value.id === "string" && parsed.value.id !== id) found.push(located(path, parsed, {
+			path: ["id"],
+			message: `"id" is ${quote(parsed.value.id)}, but the file is named ${toEntryFile(id)}`
+		}));
+		content[collection] ??= {};
+		content[collection][id] = parsed.value;
+		sources.set(entryKey(collection, id), {
+			path,
+			parsed
+		});
+	}
+	for (const issue of validateReferences(schema, content)) {
+		const source = sources.get(entryKey(issue.collection, issue.id));
+		issues.get(source.path).push(located(source.path, source.parsed, issue));
+	}
+	return {
+		issues: [...issues.values()].flatMap((found) => found.sort(byPosition)),
+		schema,
+		content
+	};
+}
+async function entryFile(files, content, path) {
+	const entry = toEntryRef(content, path);
+	const text = entry && await files.read(path);
+	return entry && text !== void 0 ? [{
+		...entry,
+		path,
+		text
+	}] : [];
+}
+async function readContent(files, paths) {
+	const [schema, listed] = await Promise.all([files.read(paths.schema), files.list(paths.content)]);
+	const entries = await Promise.all(listed.sort().map((path) => entryFile(files, paths.content, path)));
+	return parseContent(schema === void 0 ? void 0 : {
+		path: paths.schema,
+		text: schema
+	}, entries.flat());
+}
+function createFileSource(files, paths) {
+	async function entry(collection, id) {
+		if (!isEntryId(id)) return void 0;
+		const path = paths.entry(collection, id);
+		const text = await files.read(path);
+		return text === void 0 ? void 0 : parseEntry(text, path);
+	}
+	return {
+		schema: async () => {
+			const text = await files.read(paths.schema);
+			return text === void 0 ? { collections: {} } : parseSchema(text, paths.schema);
+		},
+		list: async (collection) => {
+			const directory = paths.collection(collection);
+			const ids = (await files.list(directory)).map((path) => path.slice(directory.length + 1)).filter(isEntryFile).map(toEntryId);
+			const rows = await Promise.all(ids.map((id) => entry(collection, id)));
+			return sortByCreation(rows.filter((row) => row !== void 0));
+		},
+		entry
+	};
+}
+export { ContentError, createFileSource, formatIssue, readContent, validateSchema };

package/dist/_chunks/fetch.mjs

@@ -1,10 +1,10 @@
-import "./types.mjs";
+import { isPage } from "./response.mjs";
 function fetchReader(url) {
 	const base = url.replace(/\/+$/, "");
 	return async (path) => {
 		const location = `${base}/${path}`;
 		const response = await fetch(location, path === "index.json" ? { cache: "no-cache" } : {});
-		if (response.status === 404 || response.ok && response.headers.get("content-type")?.includes("text/html")) return void 0;
+		if (response.status === 404 || response.ok && isPage(response)) return void 0;
 		if (!response.ok) throw new Error(`[forgepress] could not load ${location}: ${response.status} ${response.statusText}`.trim());
 		return response.json();
 	};

package/dist/_chunks/files.mjs

@@ -0,0 +1,32 @@
+import { readFile, readdir } from "node:fs/promises";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { existsSync } from "node:fs";
+function toPosix(path) {
+	return path.split(sep).join("/");
+}
+function isInside(parent, child) {
+	const path = relative(parent, child);
+	return path !== "" && path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+}
+async function listFiles(folder) {
+	if (!existsSync(folder)) return [];
+	return (await readdir(folder, {
+		withFileTypes: true,
+		recursive: true
+	})).filter((item) => item.isFile()).map((item) => toPosix(relative(folder, join(item.parentPath, item.name))));
+}
+async function readText(file) {
+	try {
+		return await readFile(file, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return void 0;
+		throw error;
+	}
+}
+function diskFiles(root) {
+	return {
+		list: async (directory) => (await listFiles(join(root, directory))).map((path) => `${directory}/${path}`),
+		read: (path) => readText(join(root, path))
+	};
+}
+export { diskFiles, isInside, listFiles, readText, toPosix };