forgepress 0.0.1 → 0.0.2

package/dist/_chunks/serialize.mjs

@@ -0,0 +1,82 @@
+import { META_KEYS } from "./value.mjs";
+const IDENTIFIER = /^[A-Z_$][\w$]*$/i;
+const WIDTH = 80;
+const ESCAPES = {
+	"\\": "\\\\",
+	"'": "\\'",
+	"\n": "\\n",
+	"\r": "\\r",
+	"	": "\\t"
+};
+function style(config) {
+	return {
+		indent: " ".repeat(config?.indent ?? 2),
+		semi: config?.semi ? ";" : ""
+	};
+}
+function unsafe(code) {
+	return code < 32 || code >= 127 && code <= 159 || code === 8232 || code === 8233;
+}
+function string(value) {
+	let out = "";
+	for (const char of value) {
+		const escaped = ESCAPES[char];
+		const code = char.charCodeAt(0);
+		if (escaped !== void 0) out += escaped;
+		else if (unsafe(code)) out += `\\u${code.toString(16).padStart(4, "0")}`;
+		else out += char;
+	}
+	return `'${out}'`;
+}
+function key(value) {
+	return IDENTIFIER.test(value) ? value : string(value);
+}
+function storable(input) {
+	return input !== void 0 && input !== null && !(typeof input === "number" && !Number.isFinite(input));
+}
+function value(input, style, depth) {
+	if (typeof input === "string") return string(input);
+	if (typeof input === "number") return String(input);
+	if (typeof input === "boolean") return String(input);
+	const pad = style.indent.repeat(depth + 1);
+	const close = style.indent.repeat(depth);
+	if (Array.isArray(input)) {
+		const kept = input.filter(storable);
+		if (kept.length === 0) return "[]";
+		const items = kept.map((item) => value(item, style, depth + 1));
+		const inline = `[${items.join(", ")}]`;
+		if (kept.every((item) => typeof item !== "object") && close.length + inline.length <= WIDTH) return inline;
+		return `[\n${items.map((item) => `${pad}${item},`).join("\n")}\n${close}]`;
+	}
+	const entries = Object.entries(input).filter(([, item]) => storable(item));
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map(([name, item]) => `${pad}${key(name)}: ${value(item, style, depth + 1)},`).join("\n")}\n${close}}`;
+}
+function serializeSchema(schema, config) {
+	const current = style(config);
+	return [
+		`import type { ForgePressSchema } from 'forgepress'${current.semi}`,
+		"",
+		`export default ${value(schema, current, 0)} as const satisfies ForgePressSchema${current.semi}`,
+		""
+	].join("\n");
+}
+function ordered(row) {
+	const entries = Object.entries(row).filter(([, item]) => storable(item));
+	const rank = (name) => {
+		const index = META_KEYS.indexOf(name);
+		return index === -1 ? META_KEYS.length : index;
+	};
+	return entries.sort(([left], [right]) => rank(left) - rank(right));
+}
+function serializeEntry(collection, row, config) {
+	const current = style(config);
+	const body = ordered(row).map(([name, item]) => `${current.indent}${key(name)}: ${value(item, current, 1)},`).join("\n");
+	return [
+		`import type { ForgePressEntry } from 'forgepress'${current.semi}`,
+		"",
+		`export default {\n${body}\n} satisfies ForgePressEntry<${string(collection)}>${current.semi}`,
+		""
+	].join("\n");
+}
+export { serializeEntry, serializeSchema };

package/dist/_chunks/settings.mjs

@@ -0,0 +1,328 @@
+import { isRecord } from "./value.mjs";
+import { errorMessage } from "./error.mjs";
+import { assetName, checkUpload, defaultPaths, isAssetName, isCollectionName, isEntryFile, isEntryId, isMediaFile, mediaType, resolveMedia, sortAssets, storedAsset, toEntryId } from "./media.mjs";
+import { ContentError, createFileSource, validateSchema } from "./content.mjs";
+import { buildOutput, outputDir } from "./output.mjs";
+import { diskFiles, listFiles } from "./files.mjs";
+import { ENDPOINT, ROUTES } from "./routes.mjs";
+import { serializeEntry, serializeSchema } from "./serialize.mjs";
+import { findRoot, loadConfig, resolveConfig } from "./config.mjs";
+import { OUTPUT_VARIABLE } from "./reader.mjs";
+import { mkdir, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+import process from "node:process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { debounce } from "perfect-debounce";
+import { Buffer } from "node:buffer";
+function createMediaStore(root, config) {
+	const media = resolveMedia(config);
+	const dir = join(root, media.dir);
+	async function describe(name) {
+		const info = await stat(join(dir, name));
+		return {
+			...storedAsset(name, media.url),
+			size: info.size,
+			modifiedAt: info.mtime.toISOString()
+		};
+	}
+	return {
+		async list() {
+			if (!existsSync(dir)) return [];
+			const files = (await readdir(dir)).filter(isMediaFile);
+			return sortAssets(await Promise.all(files.map(describe)));
+		},
+		async write({ name, data }) {
+			checkUpload(name, data.byteLength, media.maxSize);
+			const file = await assetName(name, data);
+			await mkdir(dir, { recursive: true });
+			await writeFile(join(dir, file), data);
+			return describe(file);
+		},
+		async remove(name) {
+			if (!isAssetName(name)) throw new Error(`[forgepress] "${name}" is not a valid asset name`);
+			await rm(join(dir, name), { force: true });
+		}
+	};
+}
+function collectionName$1(collection) {
+	if (!isCollectionName(collection)) throw new Error(`[forgepress] ${JSON.stringify(collection)} is not a collection name`);
+	return collection;
+}
+function entryId$1(id) {
+	if (typeof id !== "string" || !isEntryId(id)) throw new Error(`[forgepress] ${JSON.stringify(id)} is not an entry id`);
+	return id;
+}
+function createWriter(root, paths = defaultPaths, config) {
+	const directory = (collection) => join(root, paths.collection(collectionName$1(collection)));
+	const file = (collection, id) => join(root, paths.entry(collectionName$1(collection), entryId$1(id)));
+	return {
+		async writeSchema(schema) {
+			await mkdir(join(root, paths.dir), { recursive: true });
+			await writeFile(join(root, paths.schema), serializeSchema(schema, config));
+		},
+		async writeEntry(collection, row) {
+			const target = file(collection, row.id);
+			await mkdir(directory(collection), { recursive: true });
+			await writeFile(target, serializeEntry(collection, row, config));
+		},
+		async removeEntry(collection, id) {
+			await rm(file(collection, id), { force: true });
+		},
+		async writeContent(collection, rows) {
+			const targets = rows.map((row) => [file(collection, row.id), serializeEntry(collection, row, config)]);
+			const kept = new Set(rows.map((row) => row.id));
+			await mkdir(directory(collection), { recursive: true });
+			const stale = (await listFiles(directory(collection))).filter(isEntryFile).map(toEntryId).filter((id) => !kept.has(id));
+			await Promise.all(stale.map((id) => rm(file(collection, id), { force: true })));
+			await Promise.all(targets.map(([target, text]) => writeFile(target, text)));
+		},
+		async removeCollection(collection) {
+			await rm(directory(collection), {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+var EndpointError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.name = "EndpointError";
+		this.status = status;
+	}
+};
+function sameOrigin(request) {
+	const site = request.headers["sec-fetch-site"];
+	if (site !== void 0) return site === "same-origin" || site === "none";
+	const { origin, host } = request.headers;
+	if (origin === void 0) return true;
+	try {
+		return new URL(origin).host === host;
+	} catch {
+		return false;
+	}
+}
+const SAME_ORIGIN = {
+	accepts: sameOrigin,
+	refusal: "the dev endpoint only accepts requests from pages on its own origin"
+};
+function missing(path) {
+	return new EndpointError(404, `there is no endpoint ${JSON.stringify(path)}`);
+}
+async function bytes(request) {
+	const chunks = [];
+	for await (const chunk of request) chunks.push(chunk);
+	return Buffer.concat(chunks);
+}
+async function body(request) {
+	const text = (await bytes(request)).toString("utf8");
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new EndpointError(400, "the request body is not valid JSON");
+	}
+}
+function json(response, payload) {
+	response.statusCode = 200;
+	response.setHeader("content-type", "application/json");
+	response.end(JSON.stringify(payload));
+}
+function done(response) {
+	response.statusCode = 204;
+	response.end();
+}
+function decode(value, path) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		throw new EndpointError(400, `${JSON.stringify(path)} is not a valid path`);
+	}
+}
+function under(path, route) {
+	return path.startsWith(`${route}/`);
+}
+function segments(path, route, count) {
+	const found = path.slice(route.length + 1).split("/").filter(Boolean).map((segment) => decode(segment, path));
+	if (found.length > count) throw missing(path);
+	return found;
+}
+function collectionName(name) {
+	if (name === void 0 || !isCollectionName(name)) throw new EndpointError(400, `${JSON.stringify(name ?? "")} is not a collection name`);
+	return name;
+}
+function entryId(id) {
+	if (typeof id !== "string" || !isEntryId(id)) throw new EndpointError(400, `${JSON.stringify(id ?? "")} is not an entry id`);
+	return id;
+}
+function entry(value) {
+	if (!isRecord(value)) throw new EndpointError(400, "an entry has to be an object");
+	entryId(value.id);
+	return value;
+}
+async function media(config, root, path, request, response) {
+	const store = createMediaStore(root, config.media);
+	if (request.method === "GET") return json(response, await store.list());
+	const name = decode(path.slice(ROUTES.media.length + 1), path);
+	if (request.method === "DELETE") {
+		if (!isAssetName(name)) throw new EndpointError(400, `${JSON.stringify(name)} is not an asset name`);
+		await store.remove(name);
+		return done(response);
+	}
+	if (!mediaType(name)) throw new EndpointError(400, `${JSON.stringify(name)} is not a supported media file`);
+	return json(response, await store.write({
+		name,
+		data: await bytes(request)
+	}));
+}
+async function read(config, root, path, response) {
+	const source = createFileSource(diskFiles(root), config.paths);
+	if (path === ROUTES.schema) return json(response, await source.schema());
+	if (under(path, ROUTES.content)) {
+		const [collection = ""] = segments(path, ROUTES.content, 1);
+		const schema = await source.schema();
+		return json(response, Object.hasOwn(schema.collections, collection) ? await source.list(collection) : []);
+	}
+	if (!under(path, ROUTES.entry)) throw missing(path);
+	const [collection = "", id = ""] = segments(path, ROUTES.entry, 2);
+	const schema = await source.schema();
+	const row = Object.hasOwn(schema.collections, collection) && isEntryId(id) ? await source.entry(collection, id) : void 0;
+	if (row) return json(response, row);
+	response.statusCode = 404;
+	response.end();
+}
+async function write(config, root, path, request, response) {
+	const writer = createWriter(root, config.paths, config.content);
+	const removing = request.method === "DELETE";
+	if (path === ROUTES.schema && !removing) {
+		const schema = await body(request);
+		const issues = validateSchema(schema);
+		if (issues.length > 0) throw new EndpointError(400, `the schema is not valid:\n${issues.map((issue) => issue.message).join("\n")}`);
+		await writer.writeSchema(schema);
+	} else if (under(path, ROUTES.entry)) {
+		const [name, id] = segments(path, ROUTES.entry, 2);
+		const collection = collectionName(name);
+		if (removing) await writer.removeEntry(collection, entryId(id));
+		else {
+			const row = entry(await body(request));
+			if (row.id !== entryId(id)) throw new EndpointError(400, `the entry id ${JSON.stringify(row.id)} doesn't match the path`);
+			await writer.writeEntry(collection, row);
+		}
+	} else if (under(path, ROUTES.content)) {
+		const [name] = segments(path, ROUTES.content, 1);
+		const collection = collectionName(name);
+		if (removing) await writer.removeCollection(collection);
+		else {
+			const rows = await body(request);
+			if (!Array.isArray(rows)) throw new EndpointError(400, "the entries have to be a list");
+			await writer.writeContent(collection, rows.map(entry));
+		}
+	} else throw missing(path);
+	done(response);
+}
+async function handle(config, root, request, response, origins = SAME_ORIGIN) {
+	if (!origins.accepts(request)) throw new EndpointError(403, origins.refusal);
+	const path = (request.url ?? "").slice(ENDPOINT.length);
+	if (path === ROUTES.media || under(path, ROUTES.media)) return media(config, root, path, request, response);
+	if (request.method === "GET") return read(config, root, path, response);
+	return write(config, root, path, request, response);
+}
+const TYPES = `// Generated by ForgePress. Do not edit.
+import type schema from './schema'
+
+declare module 'forgepress' {
+  interface ForgePressSchemaRegistry {
+    schema: typeof schema
+  }
+}
+
+export {}
+`;
+async function loadProject(base, options) {
+	const root = options?.root ? resolve(base, options.root) : findRoot(base);
+	const loaded = await loadConfig(root);
+	const config = resolveConfig({
+		...loaded,
+		media: {
+			...loaded?.media,
+			...options?.media
+		}
+	});
+	const output = outputDir(root, config);
+	process.env[OUTPUT_VARIABLE] = output;
+	return {
+		root,
+		config,
+		output
+	};
+}
+function syncTypes(root, config) {
+	const path = join(root, config.paths.types);
+	if (!existsSync(join(root, config.paths.schema))) {
+		rmSync(path, { force: true });
+		return;
+	}
+	if (existsSync(path) && readFileSync(path, "utf8") === TYPES) return;
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, TYPES);
+}
+function createDevContent(root, config, logger, reload, origins = SAME_ORIGIN) {
+	const schemaFile = join(root, config.paths.schema);
+	const contentDir = join(root, config.paths.content);
+	let reported = "";
+	function report(issues) {
+		const message = issues.length > 0 ? new ContentError(issues).message : "";
+		if (message === reported) return;
+		if (message) logger.warn(`${message}\n[forgepress] the build fails until ${issues.length === 1 ? "this problem is" : "these problems are"} fixed`);
+		else logger.info("[forgepress] content problems are fixed");
+		reported = message;
+	}
+	async function write() {
+		syncTypes(root, config);
+		try {
+			report((await buildOutput(root, config, { dev: true })).issues);
+		} catch (error) {
+			if (!(error instanceof ContentError)) throw error;
+			report(error.issues);
+		}
+	}
+	const rebuild = debounce(async (after) => {
+		await write().catch((error) => logger.error(`[forgepress] could not write the content output: ${errorMessage(error)}`));
+		after?.();
+	}, 100);
+	return {
+		watched: [schemaFile, contentDir],
+		changed: (file) => {
+			if (file === schemaFile || file.startsWith(`${contentDir}${sep}`)) rebuild(reload);
+		},
+		refresh: () => rebuild(),
+		endpoint: (request, response, next) => {
+			const method = request.method ?? "";
+			if (!(method === "POST" || method === "DELETE" || method === "GET") || !request.url?.startsWith(`/__forgepress/`)) return next();
+			handle(config, root, request, response, origins).then(() => {
+				if (method !== "GET") rebuild(reload);
+			}).catch((error) => {
+				response.statusCode = error instanceof EndpointError ? error.status : 500;
+				response.end(errorMessage(error));
+			});
+		}
+	};
+}
+function editorSettings(local, config, devServer = "") {
+	return {
+		local,
+		devServer,
+		provider: config.provider,
+		format: config.content,
+		contentPath: config.paths.dir,
+		media: config.media
+	};
+}
+const SETTINGS_ID = "virtual:forgepress/settings";
+function resolved(id) {
+	return `\0${id}`;
+}
+function generateSettings(local, config) {
+	return `export default ${JSON.stringify(editorSettings(local, config))}\n`;
+}
+export { SETTINGS_ID, createDevContent, editorSettings, generateSettings, loadProject, resolved, syncTypes };

package/dist/_chunks/settings2.mjs

@@ -0,0 +1,2 @@
+var settings_default = JSON.parse(__FORGEPRESS_SETTINGS__);
+export { settings_default };

package/dist/_chunks/types.d.mts

@@ -1,25 +1,230 @@
-import { OutputMeta } from "./entry.mjs";
-type LinkKind = 'relation' | 'dynamic';
-export interface OutputEntry extends OutputMeta {
-  [field: string]: unknown;
+interface FieldBase {
+  label?: string;
+  description?: string;
+  optional?: boolean;
+  translate?: boolean;
+}
+type FieldOptionType = 'text' | 'number' | 'boolean' | 'collection' | 'collections';
+interface FieldOption {
+  label: string;
+  type: FieldOptionType;
+  description?: string;
+  required?: true;
+}
+interface FieldTypeDefinition {
+  type: string;
+  label: string;
+  options: Record<string, FieldOption>;
+}
+type OptionContent<TOption extends FieldOption> = TOption['type'] extends 'number' ? number : TOption['type'] extends 'boolean' ? boolean : TOption['type'] extends 'collections' ? readonly string[] : string;
+type RequiredOptions<TOptions> = { [TKey in keyof TOptions]: TOptions[TKey] extends {
+  required: true;
+} ? TKey : never; }[keyof TOptions];
+type FieldOf<TDefinition extends FieldTypeDefinition> = TDefinition extends FieldTypeDefinition ? FieldBase & {
+  type: TDefinition['type'];
+} & { [TKey in RequiredOptions<TDefinition['options']>]: OptionContent<TDefinition['options'][TKey]>; } & { [TKey in Exclude<keyof TDefinition['options'], RequiredOptions<TDefinition['options']>>]?: OptionContent<TDefinition['options'][TKey]>; } : never;
+declare const dynamic: {
+  readonly type: "dynamic";
+  readonly label: "Dynamic";
+  readonly options: {
+    readonly collections: {
+      readonly label: "Collections";
+      readonly type: "collections";
+      readonly required: true;
+    };
+  };
+};
+type DynamicField = FieldOf<typeof dynamic>;
+interface DynamicBlock<TCollectionName extends string = string> {
+  collection: TCollectionName;
+  id: string;
+}
+type DynamicFieldContent<TField extends DynamicField> = DynamicBlock<TField['collections'][number]>[];
+type ProviderType = 'github' | 'gitlab' | 'forgejo';
+interface ProviderRepository {
+  owner: string;
+  name: string;
+  branch?: string;
+}
+export interface ProviderConfig {
+  type: ProviderType;
+  repository: ProviderRepository;
+  base?: string;
+  url?: string;
+  clientId?: string;
+  scopes?: readonly string[];
+  redirectUri?: string;
+  commitMessage?: string;
 }
-export interface OutputManifest {
-  indexed: string[];
-  links: Record<string, LinkKind>;
-  entries: OutputEntry[];
-  files: Record<string, string>;
-}
-export type OutputCollection = {
-  localized: false;
-  manifest: string;
-} | {
-  localized: true;
-  manifests: Record<string, string>;
-};
-export interface OutputIndex {
-  version: number;
-  commit: string | null;
-  dev?: true;
-  locales: string[];
-  collections: Record<string, OutputCollection>;
-}
+export interface ContentConfig {
+  indent?: number;
+  semi?: boolean;
+}
+export interface MediaConfig {
+  dir?: string;
+  url?: string;
+  maxSize?: number;
+}
+export interface OutputConfig {
+  dir?: string;
+}
+export interface ForgePressConfig {
+  path?: string;
+  provider?: ProviderConfig;
+  content?: ContentConfig;
+  media?: MediaConfig;
+  output?: OutputConfig;
+}
+interface MediaContent {
+  url: string;
+  alt?: string;
+  width?: number;
+  height?: number;
+}
+export type ResolvedMedia = Required<MediaConfig>;
+declare const image: {
+  readonly type: "image";
+  readonly label: "Image";
+  readonly options: {
+    readonly multiple: {
+      readonly label: "Multiple";
+      readonly type: "boolean";
+    };
+  };
+};
+type ImageField = FieldOf<typeof image>;
+type ImageFieldContent<TField extends ImageField> = TField['multiple'] extends true ? MediaContent[] : MediaContent;
+declare const number: {
+  readonly type: "number";
+  readonly label: "Number";
+  readonly options: {
+    readonly min: {
+      readonly label: "Minimum";
+      readonly type: "number";
+    };
+    readonly max: {
+      readonly label: "Maximum";
+      readonly type: "number";
+    };
+    readonly step: {
+      readonly label: "Step";
+      readonly type: "number";
+    };
+    readonly index: {
+      readonly label: "Indexed";
+      readonly type: "boolean";
+      readonly description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry.";
+    };
+  };
+};
+type NumberField = FieldOf<typeof number>;
+type NumberFieldContent = number;
+declare const relation: {
+  readonly type: "relation";
+  readonly label: "Relation";
+  readonly options: {
+    readonly collection: {
+      readonly label: "Collection";
+      readonly type: "collection";
+      readonly required: true;
+    };
+    readonly multiple: {
+      readonly label: "Multiple";
+      readonly type: "boolean";
+    };
+    readonly index: {
+      readonly label: "Indexed";
+      readonly type: "boolean";
+      readonly description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry.";
+    };
+  };
+};
+type RelationField = FieldOf<typeof relation>;
+type RelationFieldContent<TField extends RelationField> = TField['multiple'] extends true ? string[] : string;
+declare const richtext: {
+  readonly type: "richtext";
+  readonly label: "Rich Text";
+  readonly options: {};
+};
+type RichTextField = FieldOf<typeof richtext>;
+type RichTextFieldContent = string;
+declare const text: {
+  readonly type: "text";
+  readonly label: "Text";
+  readonly options: {
+    readonly validation: {
+      readonly label: "Validation Pattern";
+      readonly type: "text";
+    };
+    readonly index: {
+      readonly label: "Indexed";
+      readonly type: "boolean";
+      readonly description: "Listed in the collection manifest, so queries can filter and sort on it without loading every entry.";
+    };
+  };
+};
+type TextField = FieldOf<typeof text>;
+type TextFieldContent = string;
+declare const video: {
+  readonly type: "video";
+  readonly label: "Video";
+  readonly options: {
+    readonly multiple: {
+      readonly label: "Multiple";
+      readonly type: "boolean";
+    };
+  };
+};
+type VideoField = FieldOf<typeof video>;
+type VideoFieldContent<TField extends VideoField> = TField['multiple'] extends true ? MediaContent[] : MediaContent;
+type Field = TextField | RichTextField | NumberField | ImageField | VideoField | RelationField | DynamicField;
+type FieldContent<TField extends Field> = TField extends DynamicField ? DynamicFieldContent<TField> : TField extends RelationField ? RelationFieldContent<TField> : TField extends ImageField ? ImageFieldContent<TField> : TField extends VideoField ? VideoFieldContent<TField> : TField extends TextField ? TextFieldContent : TField extends NumberField ? NumberFieldContent : TField extends RichTextField ? RichTextFieldContent : never;
+interface Collection {
+  label?: string;
+  description?: string;
+  fields: Record<string, Field>;
+}
+export interface ForgePressSchema {
+  collections: Record<string, Collection>;
+  locales?: readonly string[];
+}
+export type SchemaLocale<TSchema extends ForgePressSchema> = TSchema['locales'] extends readonly string[] ? TSchema['locales'][number] : never;
+export interface ForgePressSchemaRegistry {}
+export type RegisteredSchema = ForgePressSchemaRegistry extends {
+  schema: infer TSchema extends ForgePressSchema;
+} ? TSchema : ForgePressSchema;
+export type EntryStatus = 'published' | 'unpublished';
+export interface EntryMeta {
+  id: string;
+  status: EntryStatus;
+  createdAt: string;
+  updatedAt: string;
+}
+export interface EntryRef<TCollectionName extends string = string> {
+  collection: TCollectionName;
+  id: string;
+}
+export interface OutputMeta {
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+}
+export type Entry = EntryMeta & {
+  [field: string]: unknown;
+};
+type Translated<TSchema extends ForgePressSchema, TContent> = [SchemaLocale<TSchema>] extends [never] ? TContent : Record<SchemaLocale<TSchema>, TContent>;
+type PartiallyTranslated<TSchema extends ForgePressSchema, TContent> = [SchemaLocale<TSchema>] extends [never] ? TContent : Partial<Record<SchemaLocale<TSchema>, TContent>>;
+type FieldValue<TSchema extends ForgePressSchema, TField extends Field, TOptional extends boolean> = TField extends {
+  translate: true;
+} ? TOptional extends true ? PartiallyTranslated<TSchema, FieldContent<TField>> : Translated<TSchema, FieldContent<TField>> : FieldContent<TField>;
+type OptionalKeys<TCollection extends Collection> = { [TKey in keyof TCollection['fields']]-?: TCollection['fields'][TKey] extends {
+  optional: true;
+} ? TKey : never; }[keyof TCollection['fields']];
+type RequiredKeys<TCollection extends Collection> = Exclude<keyof TCollection['fields'], OptionalKeys<TCollection>>;
+type CollectionContent<TSchema extends ForgePressSchema, TCollection extends Collection> = EntryMeta & { [TKey in RequiredKeys<TCollection>]: FieldValue<TSchema, TCollection['fields'][TKey], false>; } & { [TKey in OptionalKeys<TCollection>]?: FieldValue<TSchema, TCollection['fields'][TKey], true>; };
+type EntryOf<TSchema extends ForgePressSchema, TCollectionName extends keyof TSchema['collections']> = CollectionContent<TSchema, TSchema['collections'][TCollectionName]>;
+export type ForgePressEntry<TCollectionName extends keyof RegisteredSchema['collections']> = EntryOf<RegisteredSchema, TCollectionName>;
+type OutputValue<TField extends Field> = TField extends RelationField ? TField['multiple'] extends true ? EntryRef<TField['collection']>[] : EntryRef<TField['collection']> : FieldContent<TField>;
+type CollectionOutput<TCollection extends Collection> = OutputMeta & { [TKey in RequiredKeys<TCollection>]: OutputValue<TCollection['fields'][TKey]>; } & { [TKey in OptionalKeys<TCollection>]?: OutputValue<TCollection['fields'][TKey]>; };
+export type OutputOf<TSchema extends ForgePressSchema, TCollectionName extends keyof TSchema['collections']> = CollectionOutput<TSchema['collections'][TCollectionName]>;
+export type ForgePressOutput<TCollectionName extends keyof RegisteredSchema['collections']> = OutputOf<RegisteredSchema, TCollectionName>;

package/dist/_chunks/types2.d.mts

@@ -0,0 +1,25 @@
+import { OutputMeta } from "./types.mjs";
+type LinkKind = 'relation' | 'dynamic';
+export interface OutputEntry extends OutputMeta {
+  [field: string]: unknown;
+}
+export interface OutputManifest {
+  indexed: string[];
+  links: Record<string, LinkKind>;
+  entries: OutputEntry[];
+  files: Record<string, string>;
+}
+export type OutputCollection = {
+  localized: false;
+  manifest: string;
+} | {
+  localized: true;
+  manifests: Record<string, string>;
+};
+export interface OutputIndex {
+  version: number;
+  commit: string | null;
+  dev?: true;
+  locales: string[];
+  collections: Record<string, OutputCollection>;
+}