forgepress 0.0.0 → 0.0.2

package/dist/index.d.mts

@@ -0,0 +1,104 @@
+import { Entry, EntryMeta, EntryRef, EntryStatus, ForgePressConfig, ForgePressEntry, ForgePressOutput, ForgePressSchema, ForgePressSchemaRegistry, OutputConfig, OutputMeta, OutputOf, RegisteredSchema, SchemaLocale } from "./_chunks/types.mjs";
+import { OutputCollection, OutputEntry, OutputIndex, OutputManifest } from "./_chunks/types2.mjs";
+export declare function defineForgePressConfig(config: ForgePressConfig): ForgePressConfig;
+type Operator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains';
+type CollectionName<TSchema extends ForgePressSchema> = keyof TSchema['collections'] & string;
+type Fields<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = TSchema['collections'][TName]['fields'];
+type FieldName<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = keyof Fields<TSchema, TName> & string;
+type Simplify<TValue> = { [TKey in keyof TValue]: TValue[TKey]; } & {};
+type Kind<TField> = TField extends {
+  type: 'number';
+} ? 'number' : TField extends {
+  type: 'text' | 'richtext';
+} ? 'text' : TField extends {
+  type: 'relation';
+  multiple: true;
+} ? 'links' : TField extends {
+  type: 'relation';
+} ? 'link' : TField extends {
+  type: 'dynamic';
+} ? 'links' : 'none';
+type KindOf<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>, TKey> = TKey extends 'id' ? 'text' : TKey extends 'createdAt' | 'updatedAt' ? 'date' : TKey extends FieldName<TSchema, TName> ? Kind<Fields<TSchema, TName>[TKey]> : 'none';
+interface Operands {
+  text: {
+    eq: string;
+    ne: string;
+    in: readonly string[];
+    contains: string;
+  };
+  number: {
+    eq: number;
+    ne: number;
+    gt: number;
+    gte: number;
+    lt: number;
+    lte: number;
+    in: readonly number[];
+  };
+  date: {
+    eq: string;
+    ne: string;
+    gt: string;
+    gte: string;
+    lt: string;
+    lte: string;
+    in: readonly string[];
+  };
+  link: {
+    eq: string;
+    ne: string;
+    in: readonly string[];
+  };
+  links: {
+    contains: string;
+  };
+  none: Record<never, never>;
+}
+type Keys<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = 'id' | 'createdAt' | 'updatedAt' | FieldName<TSchema, TName>;
+type OperatorOf<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>, TKey> = keyof Operands[KindOf<TSchema, TName, TKey>] & Operator;
+type Operand<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>, TKey, TOperator> = TOperator extends keyof Operands[KindOf<TSchema, TName, TKey>] ? Operands[KindOf<TSchema, TName, TKey>][TOperator] : never;
+type Filterable<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = { [TKey in Keys<TSchema, TName>]: [OperatorOf<TSchema, TName, TKey>] extends [never] ? never : TKey; }[Keys<TSchema, TName>];
+type Comparable<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = { [TKey in Keys<TSchema, TName>]: 'eq' extends OperatorOf<TSchema, TName, TKey> ? TKey : never; }[Keys<TSchema, TName>];
+type Sortable<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = { [TKey in Keys<TSchema, TName>]: KindOf<TSchema, TName, TKey> extends 'text' | 'number' | 'date' | 'link' ? TKey : never; }[Keys<TSchema, TName>];
+type Linkable<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = { [TKey in FieldName<TSchema, TName>]: Fields<TSchema, TName>[TKey] extends {
+  type: 'relation' | 'dynamic';
+} ? TKey : never; }[FieldName<TSchema, TName>];
+type LinkedBlock<TSchema extends ForgePressSchema, TTarget> = TTarget extends CollectionName<TSchema> ? {
+  collection: TTarget;
+  id: string;
+  entry: OutputOf<TSchema, TTarget>;
+} : never;
+type Linked<TSchema extends ForgePressSchema, TField> = TField extends {
+  type: 'relation';
+  collection: infer TTarget extends CollectionName<TSchema>;
+} ? TField extends {
+  multiple: true;
+} ? OutputOf<TSchema, TTarget>[] : OutputOf<TSchema, TTarget> : TField extends {
+  type: 'dynamic';
+  collections: readonly (infer TTarget)[];
+} ? LinkedBlock<TSchema, TTarget>[] : never;
+type WithLinked<TResult, TKey extends keyof TResult, TValue> = Simplify<Omit<TResult, TKey> & (Record<never, never> extends Pick<TResult, TKey> ? { [TField in TKey]?: TValue; } : { [TField in TKey]: TValue; })>;
+type SiteLocale<TSchema extends ForgePressSchema> = [SchemaLocale<TSchema>] extends [never] ? string : SchemaLocale<TSchema>;
+interface QueryBuilder<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>, TResult> extends Promise<TResult[]> {
+  where: {
+    <TKey extends Comparable<TSchema, TName>>(field: TKey, value: Operand<TSchema, TName, TKey, 'eq'>): QueryBuilder<TSchema, TName, TResult>;
+    <TKey extends Filterable<TSchema, TName>, TOperator extends OperatorOf<TSchema, TName, TKey>>(field: TKey, operator: TOperator, value: Operand<TSchema, TName, TKey, TOperator>): QueryBuilder<TSchema, TName, TResult>;
+  };
+  sort: (field: Sortable<TSchema, TName>, direction?: 'asc' | 'desc') => QueryBuilder<TSchema, TName, TResult>;
+  limit: (count: number) => QueryBuilder<TSchema, TName, TResult>;
+  offset: (count: number) => QueryBuilder<TSchema, TName, TResult>;
+  locale: (locale: SiteLocale<TSchema>) => QueryBuilder<TSchema, TName, TResult>;
+  with: <TKey extends Linkable<TSchema, TName> & keyof TResult>(field: TKey) => QueryBuilder<TSchema, TName, WithLinked<TResult, TKey, Linked<TSchema, Fields<TSchema, TName>[TKey]>>>;
+  pick: <TKey extends keyof TResult & string>(...fields: TKey[]) => QueryBuilder<TSchema, TName, Simplify<Pick<TResult, TKey>>>;
+  first: () => Promise<TResult | undefined>;
+}
+type Query<TSchema extends ForgePressSchema> = <TName extends CollectionName<TSchema>>(collection: TName) => QueryBuilder<TSchema, TName, OutputOf<TSchema, TName>>;
+interface ClientOptions {
+  url?: string;
+}
+interface Client<TSchema extends ForgePressSchema = RegisteredSchema> {
+  query: Query<TSchema>;
+}
+export declare function createClient<TSchema extends ForgePressSchema = RegisteredSchema>(options?: ClientOptions): Client<TSchema>;
+export declare const query: Query<RegisteredSchema>;
+export type { Client, ClientOptions, Entry, EntryMeta, EntryRef, EntryStatus, ForgePressConfig, ForgePressEntry, ForgePressOutput, ForgePressSchema, ForgePressSchemaRegistry, LinkedBlock, Operator, OutputCollection, OutputConfig, OutputEntry, OutputIndex, OutputManifest, OutputMeta, QueryBuilder };

package/dist/index.mjs

@@ -0,0 +1,237 @@
+import { OUTPUT_META_KEYS, pick, quote } from "./_chunks/value.mjs";
+import { entryKey, isEntryRef } from "./_chunks/references.mjs";
+import { OUTPUT_INDEX } from "./_chunks/response.mjs";
+import { keyed } from "./_chunks/once.mjs";
+import { fetchReader } from "./_chunks/fetch.mjs";
+import { overlaid } from "./_chunks/overlay.mjs";
+import { reader } from "#content-reader";
+function defineForgePressConfig(config) {
+	return config;
+}
+function comparable(value) {
+	return isEntryRef(value) ? value.id : value;
+}
+function compare(left, right) {
+	const first = comparable(left);
+	const second = comparable(right);
+	if (first === second) return 0;
+	if (first === void 0 || first === null) return -1;
+	if (second === void 0 || second === null) return 1;
+	return first < second ? -1 : 1;
+}
+function ranged(actual, value, accept) {
+	return actual !== void 0 && actual !== null && accept(compare(actual, value));
+}
+function matches(entry, { field, op, value }) {
+	const actual = entry[field];
+	switch (op) {
+		case "eq": return comparable(actual) === value;
+		case "ne": return comparable(actual) !== value;
+		case "gt": return ranged(actual, value, (order) => order > 0);
+		case "gte": return ranged(actual, value, (order) => order >= 0);
+		case "lt": return ranged(actual, value, (order) => order < 0);
+		case "lte": return ranged(actual, value, (order) => order <= 0);
+		case "in": return Array.isArray(value) && value.includes(comparable(actual));
+		case "contains": return Array.isArray(actual) ? actual.some((item) => comparable(item) === value) : typeof actual === "string" && typeof value === "string" && actual.includes(value);
+	}
+}
+function evaluate(entries, plan) {
+	let result = plan.where.length > 0 ? entries.filter((entry) => plan.where.every((clause) => matches(entry, clause))) : [...entries];
+	if (plan.sort.length > 0) result.sort((left, right) => {
+		for (const { field, dir } of plan.sort) {
+			const order = compare(left[field], right[field]);
+			if (order !== 0) return dir === "asc" ? order : -order;
+		}
+		return 0;
+	});
+	if (plan.offset > 0) result = result.slice(plan.offset);
+	if (plan.limit !== void 0) result = result.slice(0, plan.limit);
+	return result;
+}
+function refsOf(value) {
+	return (Array.isArray(value) ? value : [value]).filter(isEntryRef);
+}
+function listing(names) {
+	return names.map(quote).join(", ");
+}
+var Builder = class {
+	loader;
+	collection;
+	plan = {
+		where: [],
+		sort: [],
+		offset: 0,
+		with: []
+	};
+	chosen;
+	constructor(loader, collection) {
+		this.loader = loader;
+		this.collection = collection;
+	}
+	where(field, operatorOrValue, value) {
+		this.plan.where.push(arguments.length >= 3 ? {
+			field,
+			op: operatorOrValue,
+			value
+		} : {
+			field,
+			op: "eq",
+			value: operatorOrValue
+		});
+		return this;
+	}
+	sort(field, direction = "asc") {
+		this.plan.sort.push({
+			field,
+			dir: direction
+		});
+		return this;
+	}
+	limit(count) {
+		this.plan.limit = count;
+		return this;
+	}
+	offset(count) {
+		this.plan.offset = count;
+		return this;
+	}
+	locale(locale) {
+		this.chosen = locale;
+		return this;
+	}
+	with(field) {
+		if (!this.plan.with.includes(field)) this.plan.with.push(field);
+		return this;
+	}
+	pick(...fields) {
+		this.plan.pick = fields;
+		return this;
+	}
+	needsLocale(snapshot, reason) {
+		const example = snapshot.index.locales[0] ?? "en";
+		return /* @__PURE__ */ new Error(`[forgepress] ${reason}, so query(${quote(this.collection)}) needs .locale(), such as .locale(${quote(example)})`);
+	}
+	async select(snapshot, limit) {
+		const { index } = snapshot;
+		const { collection, chosen: locale, plan } = this;
+		const found = index.collections[collection];
+		if (!found) throw new Error(`[forgepress] the content output has no collection ${quote(collection)}`);
+		if (locale !== void 0 && !index.locales.includes(locale)) throw new Error(`[forgepress] ${quote(locale)} is not a locale of this site; ${index.locales.length > 0 ? `use ${listing(index.locales)}` : "it has none"}`);
+		if (found.localized && locale === void 0) throw this.needsLocale(snapshot, `${quote(collection)} is translated`);
+		const manifest = await snapshot.manifest(collection, locale);
+		const unlinked = plan.with.filter((field) => manifest.links[field] === void 0);
+		if (unlinked.length > 0) throw new Error(`[forgepress] .with() loads relation and dynamic fields, and ${listing(unlinked)} ${unlinked.length === 1 ? "is not one" : "are not"} in ${quote(collection)}`);
+		const listed = /* @__PURE__ */ new Set([...OUTPUT_META_KEYS, ...manifest.indexed]);
+		const unindexed = [...new Set([...plan.where, ...plan.sort].map((clause) => clause.field))].filter((field) => !listed.has(field));
+		if (unindexed.length > 0 && index.dev) console.warn(`[forgepress] query(${quote(collection)}) filters or sorts by ${listing(unindexed)}, which ${unindexed.length === 1 ? "is" : "are"} not indexed, so every entry is loaded. Add index: true to ${unindexed.length === 1 ? "the field" : "the fields"} in the schema`);
+		const selected = evaluate(unindexed.length > 0 ? await snapshot.entries(collection, locale, manifest.entries.map((entry) => entry.id)) : manifest.entries, limit === void 0 ? plan : {
+			...plan,
+			limit: Math.min(plan.limit ?? limit, limit)
+		});
+		const listedOnly = plan.pick !== void 0 && [...plan.pick, ...plan.with].every((field) => listed.has(field));
+		const rows = unindexed.length > 0 || listedOnly ? selected : await snapshot.entries(collection, locale, selected.map((entry) => entry.id));
+		const linked = plan.with.length > 0 ? await this.link(snapshot, manifest, rows) : rows;
+		const fields = plan.pick;
+		const picked = fields === void 0 ? linked : linked.map((row) => pick(row, fields));
+		return structuredClone(picked);
+	}
+	async link(snapshot, manifest, rows) {
+		const { index } = snapshot;
+		const locale = this.chosen;
+		const wanted = /* @__PURE__ */ new Map();
+		for (const field of this.plan.with) for (const ref of rows.flatMap((row) => refsOf(row[field]))) {
+			if (index.collections[ref.collection]?.localized && locale === void 0) throw this.needsLocale(snapshot, `.with(${quote(field)}) loads ${quote(ref.collection)} entries, which are translated`);
+			wanted.set(ref.collection, (wanted.get(ref.collection) ?? /* @__PURE__ */ new Set()).add(ref.id));
+		}
+		const loaded = /* @__PURE__ */ new Map();
+		await Promise.all([...wanted].map(async ([collection, ids]) => {
+			for (const entry of await snapshot.entries(collection, locale, [...ids])) loaded.set(entryKey(collection, entry.id), entry);
+		}));
+		const find = (ref) => loaded.get(entryKey(ref.collection, ref.id));
+		return rows.map((row) => {
+			const next = { ...row };
+			for (const field of this.plan.with) {
+				const value = row[field];
+				if (value === void 0) continue;
+				if (manifest.links[field] === "dynamic") next[field] = refsOf(value).flatMap((ref) => [find(ref)].flatMap((entry) => entry ? [{
+					collection: ref.collection,
+					id: ref.id,
+					entry
+				}] : []));
+				else if (Array.isArray(value)) next[field] = refsOf(value).flatMap((ref) => find(ref) ?? []);
+				else next[field] = refsOf(value).map(find)[0];
+			}
+			return next;
+		});
+	}
+	execute(limit) {
+		return this.loader.run((snapshot) => this.select(snapshot, limit));
+	}
+	async first() {
+		return (await this.execute(1))[0];
+	}
+	then(onFulfilled, onRejected) {
+		return this.execute().then(onFulfilled, onRejected);
+	}
+	catch(onRejected) {
+		return this.execute().catch(onRejected);
+	}
+	finally(onFinally) {
+		return this.execute().finally(onFinally);
+	}
+	get [Symbol.toStringTag]() {
+		return "ForgePressQuery";
+	}
+};
+var MissingFile = class extends Error {};
+function manifestPath(index, collection, locale) {
+	const found = index.collections[collection];
+	if (!found) throw new Error(`[forgepress] the content output has no collection ${quote(collection)}`);
+	if (!found.localized) return found.manifest;
+	const path = locale === void 0 ? void 0 : found.manifests[locale];
+	if (path === void 0) throw new Error(`[forgepress] the content output has no ${quote(collection)} entries in locale ${quote(locale)}`);
+	return path;
+}
+function createLoader(read) {
+	const files = keyed();
+	function file(path) {
+		return files(path, () => read(path).then((value) => {
+			if (value === void 0) throw new MissingFile(path);
+			return value;
+		}));
+	}
+	async function snapshot() {
+		const index = await read(OUTPUT_INDEX);
+		if (index === void 0) throw new Error(`[forgepress] there is no content output yet: ${OUTPUT_INDEX} is missing. Run forgepress build, or start the dev server with the forgepress plugin`);
+		if (index.version !== 1) throw new Error(`[forgepress] the content output has format version ${quote(index.version)}, but this version of forgepress reads version 1`);
+		const manifest = (collection, locale) => file(manifestPath(index, collection, locale));
+		return {
+			index,
+			manifest,
+			entries: async (collection, locale, ids) => {
+				const { files: paths } = await manifest(collection, locale);
+				return Promise.all(ids.flatMap((id) => paths[id] === void 0 ? [] : [file(paths[id])]));
+			}
+		};
+	}
+	return { async run(task) {
+		try {
+			return await task(await snapshot());
+		} catch (error) {
+			if (!(error instanceof MissingFile)) throw error;
+		}
+		try {
+			return await task(await snapshot());
+		} catch (error) {
+			if (error instanceof MissingFile) throw new Error(`[forgepress] the content output links ${error.message}, but the file doesn't exist`);
+			throw error;
+		}
+	} };
+}
+function createClient(options = {}) {
+	const loader = createLoader(overlaid(options.url === void 0 ? reader : fetchReader(options.url)));
+	const query = (collection) => new Builder(loader, collection);
+	return { query };
+}
+const query = createClient().query;
+export { createClient, defineForgePressConfig, query };

package/dist/next/preview.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/next/preview.mjs

@@ -0,0 +1,3 @@
+import { enablePreview } from "../_chunks/preview.mjs";
+enablePreview();
+export {};

package/dist/next/reload.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/next/reload.mjs

@@ -0,0 +1,20 @@
+import { EVENTS } from "../_chunks/routes.mjs";
+import { settings_default } from "../_chunks/settings2.mjs";
+const RETRY = 1e3;
+const LONGEST_RETRY = 3e4;
+function connect(delay) {
+	const socket = new WebSocket(`${settings_default.devServer.replace(/^http/, "ws")}${EVENTS}`);
+	let opened = false;
+	socket.addEventListener("open", () => {
+		opened = true;
+	});
+	socket.addEventListener("message", (event) => {
+		if (event.data === "reload") location.reload();
+	});
+	socket.addEventListener("close", () => {
+		const next = opened ? RETRY : Math.min(delay * 2, LONGEST_RETRY);
+		setTimeout(connect, next, next);
+	});
+}
+connect(RETRY);
+export {};

package/dist/next/settings.d.mts

@@ -0,0 +1,12 @@
+import { ContentConfig, ProviderConfig, ResolvedMedia } from "../_chunks/types.mjs";
+import "../_chunks/resolve.mjs";
+interface EditorSettings {
+  local: boolean;
+  devServer: string;
+  provider?: ProviderConfig | undefined;
+  format?: ContentConfig | undefined;
+  contentPath: string;
+  media: ResolvedMedia;
+}
+declare const _default: EditorSettings;
+export { _default as default };

package/dist/next/settings.mjs

@@ -0,0 +1,2 @@
+import { settings_default } from "../_chunks/settings2.mjs";
+export { settings_default as default };

package/dist/plugin/next.d.mts

@@ -0,0 +1,11 @@
+import { Options } from "../_chunks/project.mjs";
+import { NextConfig } from "next";
+export interface NextOptions extends Options {
+  preview?: boolean;
+}
+export type NextConfigFunction = (phase: string, context: {
+  defaultConfig: NextConfig;
+}) => NextConfig | Promise<NextConfig>;
+export declare function withForgePress(nextConfig: NextConfig | NextConfigFunction, options?: NextOptions): (phase: string, context: {
+  defaultConfig: NextConfig;
+}) => Promise<NextConfig>;

package/dist/plugin/next.mjs

@@ -0,0 +1,213 @@
+import { isRecord } from "../_chunks/value.mjs";
+import { keyed } from "../_chunks/once.mjs";
+import { errorMessage } from "../_chunks/error.mjs";
+import { buildOutput } from "../_chunks/output.mjs";
+import { toPosix } from "../_chunks/files.mjs";
+import { EVENTS } from "../_chunks/routes.mjs";
+import { SETTINGS_ID, createDevContent, editorSettings, loadProject, syncTypes } from "../_chunks/settings.mjs";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import process from "node:process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { createServer } from "node:http";
+import { Worker, isMainThread } from "node:worker_threads";
+import { applyEdits, modify, parse } from "jsonc-parser";
+import { WebSocketServer } from "ws";
+const DEVELOPMENT = "phase-development-server";
+const BUILD = "phase-production-build";
+const SETTINGS_MODULE = "forgepress/next/settings";
+const SETTINGS_VARIABLE = "__FORGEPRESS_SETTINGS__";
+const PREVIEW_MODULE = "forgepress/next/preview";
+const RELOAD_MODULE = "forgepress/next/reload";
+const VUE_FLAGS = {
+	__VUE_OPTIONS_API__: true,
+	__VUE_PROD_DEVTOOLS__: false,
+	__VUE_PROD_HYDRATION_MISMATCH_DETAILS__: false
+};
+const SERVERS = Symbol.for("forgepress:next:servers");
+const LOCAL_ORIGIN = /^https?:\/\/(?:(?:[^/:]+\.)?localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/;
+const PREFLIGHT = {
+	"access-control-allow-methods": "GET, POST, DELETE",
+	"access-control-allow-headers": "content-type",
+	"access-control-max-age": "600"
+};
+const INDENT = /^[ \t]+(?=\S)/m;
+const DIST = `${dirname(dirname(fileURLToPath(import.meta.url)))}${sep}`;
+const WATCHER = new URL(`./watcher${extname(fileURLToPath(import.meta.url))}`, import.meta.url);
+function dynamicConfigImport(warning) {
+	return Boolean(warning.module?.resource?.startsWith(DIST) && warning.message?.includes("the request of a dependency is an expression"));
+}
+const logger = {
+	info: (message) => process.stdout.write(`${message}\n`),
+	warn: (message) => console.warn(message),
+	error: (message) => console.error(message)
+};
+function localPage(request) {
+	const { origin } = request.headers;
+	const site = request.headers["sec-fetch-site"];
+	if (origin !== void 0) return LOCAL_ORIGIN.test(origin);
+	return site === void 0 || site === "none" || site === "same-origin";
+}
+const LOCAL_PAGES = {
+	accepts: localPage,
+	refusal: "the dev endpoint only accepts requests from pages opened on localhost"
+};
+function end(response, status, text) {
+	response.statusCode = status;
+	response.end(text);
+}
+function servers() {
+	const scope = globalThis;
+	scope[SERVERS] ??= keyed();
+	return scope[SERVERS];
+}
+function formatting(text) {
+	const indent = INDENT.exec(text)?.[0] ?? "  ";
+	return {
+		insertSpaces: !indent.startsWith("	"),
+		tabSize: indent.length,
+		eol: text.includes("\r\n") ? "\r\n" : "\n"
+	};
+}
+function includeContent(root, config, tsconfig) {
+	const file = resolve(root, tsconfig);
+	if (!existsSync(file)) return;
+	const folder = toPosix(relative(dirname(file), join(root, config.paths.dir)));
+	const pattern = `${folder}/**/*.ts`;
+	if (!folder.split("/").some((segment) => segment.startsWith("."))) return;
+	const text = readFileSync(file, "utf8");
+	const errors = [];
+	const parsed = parse(text, errors, { allowTrailingComma: true });
+	if (errors.length > 0 || !isRecord(parsed) || !Array.isArray(parsed.include)) {
+		logger.warn(`[forgepress] add ${JSON.stringify(pattern)} to "include" in ${basename(file)}, so TypeScript knows the schema`);
+		return;
+	}
+	if (parsed.include.includes(pattern)) return;
+	writeFileSync(file, applyEdits(text, modify(text, ["include", parsed.include.length], pattern, {
+		isArrayInsertion: true,
+		formattingOptions: formatting(text)
+	})));
+	logger.info(`[forgepress] added ${JSON.stringify(pattern)} to "include" in ${basename(file)}, so TypeScript knows the schema`);
+}
+function watchContent(dir, schema, changed) {
+	const watcher = new Worker(WATCHER, { workerData: {
+		dir,
+		schema
+	} });
+	let watching = false;
+	return new Promise((ready, fail) => {
+		watcher.on("message", (file) => {
+			if (file !== null) return changed(file);
+			watching = true;
+			watcher.unref();
+			ready();
+		});
+		watcher.on("error", (error) => {
+			if (watching) logger.error(`[forgepress] stopped watching the content folder: ${errorMessage(error)}`);
+			else fail(error);
+		});
+	});
+}
+function listen(server) {
+	return new Promise((done, fail) => {
+		server.once("error", fail);
+		server.listen(0, "127.0.0.1", () => done(`127.0.0.1:${server.address().port}`));
+	});
+}
+async function startDevServer(root, config, write) {
+	const pages = new WebSocketServer({ noServer: true });
+	const dev = createDevContent(root, config, logger, () => {
+		for (const page of pages.clients) page.send("reload");
+	}, LOCAL_PAGES);
+	await watchContent(join(root, config.paths.dir), join(root, config.paths.schema), dev.changed);
+	await dev.refresh();
+	const server = createServer();
+	const host = await listen(server);
+	server.on("request", (request, response) => {
+		const { origin } = request.headers;
+		if (request.headers.host !== host) return end(response, 403);
+		if (origin !== void 0) {
+			response.setHeader("access-control-allow-origin", origin);
+			response.setHeader("vary", "origin");
+		}
+		if (request.method === "OPTIONS") {
+			if (!LOCAL_PAGES.accepts(request)) return end(response, 403, LOCAL_PAGES.refusal);
+			for (const [name, value] of Object.entries(PREFLIGHT)) response.setHeader(name, value);
+			return end(response, 204);
+		}
+		if (!write) return end(response, 404);
+		dev.endpoint(request, response, () => end(response, 404));
+	});
+	server.on("upgrade", (request, socket, head) => {
+		if (request.headers.host !== host || request.url !== EVENTS || !LOCAL_PAGES.accepts(request)) {
+			socket.destroy();
+			return;
+		}
+		socket.unref();
+		pages.handleUpgrade(request, socket, head, (page) => page.on("error", () => page.terminate()));
+	});
+	server.unref();
+	return `http://${host}`;
+}
+function devServer(root, config, write) {
+	return servers()(root, () => startDevServer(root, config, write));
+}
+async function prepare(phase, next, options) {
+	const project = await loadProject(process.cwd(), options);
+	const { root, config } = project;
+	const serving = phase === DEVELOPMENT && isMainThread;
+	if (isMainThread && (phase === DEVELOPMENT || phase === BUILD)) {
+		syncTypes(root, config);
+		includeContent(root, config, next.typescript?.tsconfigPath ?? "tsconfig.json");
+	}
+	return {
+		...project,
+		local: phase === DEVELOPMENT && options.write !== false,
+		server: serving ? await devServer(root, config, options.write !== false) : void 0
+	};
+}
+function extend(next, project, options) {
+	const extended = {
+		compiler: {
+			...next.compiler,
+			define: {
+				...VUE_FLAGS,
+				...next.compiler?.define,
+				[SETTINGS_VARIABLE]: JSON.stringify(editorSettings(project.local, project.config, project.server))
+			},
+			runAfterProductionCompile: async (metadata) => {
+				await buildOutput(project.root, project.config);
+				await next.compiler?.runAfterProductionCompile?.(metadata);
+			}
+		},
+		turbopack: {
+			...next.turbopack,
+			resolveAlias: {
+				...next.turbopack?.resolveAlias,
+				[SETTINGS_ID]: SETTINGS_MODULE
+			}
+		},
+		webpack: (config, context) => {
+			const result = next.webpack ? next.webpack(config, context) : config;
+			result.plugins = [...result.plugins ?? [], new context.webpack.NormalModuleReplacementPlugin(/^virtual:forgepress\/settings$/, SETTINGS_MODULE)];
+			result.ignoreWarnings = [...result.ignoreWarnings ?? [], dynamicConfigImport];
+			return result;
+		},
+		instrumentationClientInject: [
+			...next.instrumentationClientInject ?? [],
+			...options.preview === false ? [] : [PREVIEW_MODULE],
+			...project.server ? [RELOAD_MODULE] : []
+		]
+	};
+	return {
+		...next,
+		...extended
+	};
+}
+function withForgePress(nextConfig, options = {}) {
+	return async (phase, context) => {
+		const found = typeof nextConfig === "function" ? await nextConfig(phase, context) : nextConfig;
+		return extend(found, await prepare(phase, found, options), options);
+	};
+}
+export { withForgePress };

package/dist/plugin/nuxt.d.mts

@@ -0,0 +1,7 @@
+import { Options } from "../_chunks/project.mjs";
+import { NuxtModule } from "@nuxt/schema";
+export interface ModuleOptions extends Options {
+  preview?: boolean;
+}
+declare const forgepress: NuxtModule<ModuleOptions>;
+export { forgepress as default };

package/dist/plugin/nuxt.mjs

@@ -0,0 +1,52 @@
+import { toPosix } from "../_chunks/files.mjs";
+import { loadProject } from "../_chunks/settings.mjs";
+import { configFile } from "../_chunks/config.mjs";
+import { vitePlugin } from "../_chunks/plugin.mjs";
+import { join, relative } from "node:path";
+import { addPluginTemplate, addVitePlugin, defineNuxtModule } from "@nuxt/kit";
+const PREVIEW_PLUGIN = `import { defineNuxtPlugin, refreshNuxtData, usePreviewMode } from '#app'
+import { enablePreview, onPreviewChange, previewing } from 'forgepress/preview'
+
+export default defineNuxtPlugin({
+  name: 'forgepress:preview',
+  setup(nuxtApp) {
+    enablePreview()
+
+    const { enabled } = usePreviewMode({ shouldEnable: previewing })
+
+    onPreviewChange(() => nuxtApp.runWithContext(() => {
+      enabled.value = previewing()
+
+      return refreshNuxtData()
+    }))
+  },
+})
+`;
+const forgepress = defineNuxtModule({
+	meta: {
+		name: "forgepress",
+		configKey: "forgepress"
+	},
+	async setup(options, nuxt) {
+		const { root, config } = await loadProject(nuxt.options.rootDir, options);
+		addVitePlugin(vitePlugin({
+			...options,
+			root
+		}));
+		nuxt.hook("prepare:types", ({ tsConfig, nodeTsConfig }) => {
+			tsConfig.include ??= [];
+			tsConfig.include.push(toPosix(relative(nuxt.options.buildDir, join(root, config.paths.dir, "**/*.ts"))));
+			const file = configFile(root);
+			if (file) {
+				nodeTsConfig.include ??= [];
+				nodeTsConfig.include.push(toPosix(relative(nuxt.options.buildDir, join(root, file))));
+			}
+		});
+		if (options.preview !== false) addPluginTemplate({
+			filename: "forgepress/preview.client.mjs",
+			getContents: () => PREVIEW_PLUGIN,
+			mode: "client"
+		});
+	}
+});
+export { forgepress as default };