@junejs/server 0.1.0-dev.4 → 0.1.0-dev.7

package/dist/config-loader.d.ts

@@ -0,0 +1,9 @@
+import { JuneConfig } from "@junejs/core/config";
+//#region src/config-loader.d.ts
+/** The config file loadJuneConfig would import, or null. Exported so callers that need a FRESH
+ *  load (a subprocess probe — see generateContent's bootstrap retry) target the same file the
+ *  in-process loader would. */
+declare function findJuneConfigPath(appDir: string): string | null;
+declare function loadJuneConfig(appDir: string): Promise<JuneConfig>;
+//#endregion
+export { findJuneConfigPath, loadJuneConfig };

package/dist/config-loader.js

@@ -0,0 +1,25 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/config-loader.ts
+/** The config file loadJuneConfig would import, or null. Exported so callers that need a FRESH
+*  load (a subprocess probe — see generateContent's bootstrap retry) target the same file the
+*  in-process loader would. */
+function findJuneConfigPath(appDir) {
+	for (const dir of [appDir, join(appDir, "..")]) for (const name of [
+		"june.config.ts",
+		"june.config.js",
+		".june/config.ts"
+	]) {
+		const path = join(dir, name);
+		if (existsSync(path)) return path;
+	}
+	return null;
+}
+async function loadJuneConfig(appDir) {
+	const path = findJuneConfigPath(appDir);
+	if (!path) return {};
+	return (await import(pathToFileURL(path).href)).default ?? {};
+}
+//#endregion
+export { findJuneConfigPath, loadJuneConfig };

package/dist/content.d.ts

@@ -0,0 +1,39 @@
+import { ContentSource } from "@junejs/core/config";
+//#region src/content.d.ts
+type ContentEntry = {
+  slug: string;
+  file: string;
+  /** Parsed frontmatter (string values; `tags`-style lists become string[]). */
+  data: Record<string, string | string[]>;
+  /** The markdown body (frontmatter stripped). */
+  body: string;
+  /** The authored file, verbatim — the agent-facing .md projection. */
+  original: string;
+  /** The body rendered to HTML (CommonMark + GFM, via @momiji-rs/sparkdown/gfm wasm). */
+  html: string;
+  /** The locale this entry was authored in — set for files under a `<locale>/`
+   *  subdir, undefined for the flat (default-locale) files. */
+  locale?: string;
+};
+type ScannedCollection = {
+  default: ContentEntry[];
+  byLocale: Record<string, ContentEntry[]>;
+};
+declare function scanCollection(dir: string, knownLocales?: readonly string[]): ScannedCollection;
+/** All entries in a content directory, newest-first by `date` (then slug). With
+ *  a `locale`, each entry is its locale variant when present, else the default
+ *  (so a reader sees the whole collection, localized where available). */
+declare function collection(dir: string, locale?: string): ContentEntry[];
+/** One entry by slug, or null. With a `locale`, prefer `<dir>/<locale>/<slug>`,
+ *  falling back to the flat default (a dev-warn flags a partial translation).
+ *  `fallback: false` is STRICT — a missing variant returns null (so a route can
+ *  404 rather than serve default-language content). */
+declare function entry(dir: string, slug: string, locale?: string, opts?: {
+  fallback?: boolean;
+}): ContentEntry | null;
+declare function generateContentModule(contentDir: string, knownLocales?: readonly string[], sources?: readonly ContentSource[]): {
+  code: string;
+  names: string[];
+};
+//#endregion
+export { ContentEntry, ScannedCollection, collection, entry, generateContentModule, scanCollection };

package/dist/content.js

@@ -0,0 +1,201 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { initSync, toHtmlSync } from "@momiji-rs/sparkdown/gfm";
+//#region src/content.ts
+let wasmReady = false;
+const ensureWasm = () => {
+	if (!wasmReady) {
+		initSync();
+		wasmReady = true;
+	}
+};
+function parseFrontmatter(raw) {
+	if (!raw.startsWith("---")) return {
+		data: {},
+		body: raw
+	};
+	const end = raw.indexOf("\n---", 3);
+	if (end === -1) return {
+		data: {},
+		body: raw
+	};
+	const data = {};
+	for (const line of raw.slice(3, end).split("\n")) {
+		const i = line.indexOf(":");
+		if (i === -1) continue;
+		const key = line.slice(0, i).trim();
+		const value = line.slice(i + 1).trim();
+		if (!key) continue;
+		if (value.startsWith("[") && value.endsWith("]")) data[key] = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+		else data[key] = value.replace(/^["']|["']$/g, "");
+	}
+	return {
+		data,
+		body: raw.slice(end + 4).replace(/^\n+/, "")
+	};
+}
+const memo = /* @__PURE__ */ new Map();
+const memoKey = (file, slug, locale) => `${file}\u0000${slug}\u0000${locale ?? ""}`;
+function loadEntry(file, slug, locale) {
+	const mtime = statSync(file).mtimeMs;
+	const key = memoKey(file, slug, locale);
+	const hit = memo.get(key);
+	if (hit && hit.mtime === mtime) return hit.entry;
+	const original = readFileSync(file, "utf8");
+	const { data, body } = parseFrontmatter(original);
+	if (data.title === void 0) {
+		const h1 = body.match(/^#[ \t]+(.+?)[ \t]*$/m);
+		if (h1?.[1]) data.title = h1[1];
+	}
+	ensureWasm();
+	const entry = {
+		slug,
+		file,
+		data,
+		body,
+		original,
+		html: toHtmlSync(body),
+		...locale ? { locale } : {}
+	};
+	memo.set(key, {
+		mtime,
+		entry
+	});
+	return entry;
+}
+const isMd = (f) => f.endsWith(".md") || f.endsWith(".mdx");
+const slugOf = (f) => f.replace(/\.(md|mdx)$/, "").replace(/(^|\/)(index|README)$/i, "");
+const byDate = (a, b) => String(b.data.date ?? "").localeCompare(String(a.data.date ?? "")) || a.slug.localeCompare(b.slug);
+const LOCALE_DIR = /^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
+function isLocaleDir(name, known) {
+	return known ? known.includes(name) : LOCALE_DIR.test(name);
+}
+function collectMd(root, knownLocales, skipTopLocales, sub = "") {
+	const out = [];
+	for (const ent of readdirSync(join(root, sub), { withFileTypes: true })) {
+		const rel = sub ? `${sub}/${ent.name}` : ent.name;
+		if (ent.isDirectory()) {
+			if (skipTopLocales && sub === "" && isLocaleDir(ent.name, knownLocales)) continue;
+			out.push(...collectMd(root, knownLocales, skipTopLocales, rel));
+		} else if (isMd(ent.name)) out.push({
+			file: join(root, rel),
+			slug: slugOf(rel)
+		});
+	}
+	return out;
+}
+function scanCollection(dir, knownLocales) {
+	const def = collectMd(dir, knownLocales, true).map(({ file, slug }) => loadEntry(file, slug)).sort(byDate);
+	const byLocale = {};
+	for (const ent of readdirSync(dir, { withFileTypes: true })) if (ent.isDirectory() && isLocaleDir(ent.name, knownLocales)) {
+		const locale = ent.name;
+		byLocale[locale] = collectMd(join(dir, locale), knownLocales, false).map(({ file, slug }) => loadEntry(file, slug, locale)).sort(byDate);
+	}
+	return {
+		default: def,
+		byLocale
+	};
+}
+/** All entries in a content directory, newest-first by `date` (then slug). With
+*  a `locale`, each entry is its locale variant when present, else the default
+*  (so a reader sees the whole collection, localized where available). */
+function collection(dir, locale) {
+	const { default: def, byLocale } = scanCollection(dir);
+	if (!locale || !byLocale[locale]) return def;
+	const variants = new Map(byLocale[locale].map((e) => [e.slug, e]));
+	return def.map((e) => variants.get(e.slug) ?? e).sort(byDate);
+}
+function probe(dir, slug, locale) {
+	for (const ext of [".md", ".mdx"]) try {
+		return loadEntry(join(dir, slug + ext), slug, locale);
+	} catch {}
+	return null;
+}
+/** One entry by slug, or null. With a `locale`, prefer `<dir>/<locale>/<slug>`,
+*  falling back to the flat default (a dev-warn flags a partial translation).
+*  `fallback: false` is STRICT — a missing variant returns null (so a route can
+*  404 rather than serve default-language content). */
+function entry(dir, slug, locale, opts) {
+	if (!/^[A-Za-z0-9._-]+(\/[A-Za-z0-9._-]+)*$/.test(slug) || slug.includes("..")) return null;
+	if (!locale) return probe(dir, slug);
+	const variant = probe(join(dir, locale), slug, locale);
+	if (variant) return variant;
+	if (opts?.fallback === false) return null;
+	const fallback = probe(dir, slug);
+	if (fallback && existsSync(join(dir, locale))) console.warn(`[june content] ${slug}: no "${locale}" variant — served default`);
+	return fallback;
+}
+function mountScanned(s, mount) {
+	if (!mount) return s;
+	const re = (e) => ({
+		...e,
+		slug: e.slug ? `${mount}/${e.slug}` : mount
+	});
+	return {
+		default: s.default.map(re),
+		byLocale: Object.fromEntries(Object.entries(s.byLocale).map(([l, es]) => [l, es.map(re)]))
+	};
+}
+function mergeScanned(into, add, label) {
+	const mergeEntries = (a, b, bucket) => {
+		const seen = new Map(a.map((e) => [e.slug, e.file]));
+		for (const e of b) {
+			const other = seen.get(e.slug);
+			if (other !== void 0) throw new Error(`[june content] slug collision in collection "${label}"${bucket ? ` (${bucket})` : ""}: "${e.slug}" is authored by both\n  ${other}\n  ${e.file}\nGive the source a distinct mount, or rename one file.`);
+			seen.set(e.slug, e.file);
+		}
+		return [...a, ...b].sort(byDate);
+	};
+	const byLocale = { ...into.byLocale };
+	for (const [locale, entries] of Object.entries(add.byLocale)) byLocale[locale] = mergeEntries(byLocale[locale] ?? [], entries, locale);
+	return {
+		default: mergeEntries(into.default, add.default, ""),
+		byLocale
+	};
+}
+function generateContentModule(contentDir, knownLocales, sources) {
+	const strip = (e) => ({
+		slug: e.slug,
+		data: e.data,
+		body: e.body,
+		original: e.original,
+		html: e.html,
+		...e.locale ? { locale: e.locale } : {}
+	});
+	const collections = /* @__PURE__ */ new Map();
+	if (existsSync(contentDir)) {
+		for (const d of readdirSync(contentDir, { withFileTypes: true })) if (d.isDirectory()) collections.set(d.name, scanCollection(join(contentDir, d.name), knownLocales));
+	}
+	for (const s of sources ?? []) {
+		if (!existsSync(s.dir)) throw new Error(`[june content] content source "${s.dir}" (collection "${s.collection}") does not exist`);
+		const scanned = mountScanned(scanCollection(s.dir, knownLocales), s.mount);
+		const base = collections.get(s.collection);
+		collections.set(s.collection, base ? mergeScanned(base, scanned, s.collection) : scanned);
+	}
+	const names = [];
+	let anyLocale = false;
+	let body = "";
+	for (const [name, { default: def, byLocale }] of collections) {
+		const CONST = name.replace(/[^A-Za-z0-9]/g, "_").toUpperCase();
+		const finder = name.endsWith("s") ? name.slice(0, -1) : `${name}Entry`;
+		body += `export const ${CONST}: ContentEntry[] = ${JSON.stringify(def.map(strip), null, 2)};\n`;
+		if (Object.keys(byLocale).length === 0) {
+			body += `export const ${finder} = (slug: string): ContentEntry | null => ${CONST}.find((p) => p.slug === slug) ?? null;\n`;
+			body += `export const ${name} = (_locale?: string): ContentEntry[] => ${CONST};\n`;
+		} else {
+			anyLocale = true;
+			const map = {};
+			for (const [loc, entries] of Object.entries(byLocale)) for (const e of entries) (map[loc] ??= {})[e.slug] = strip(e);
+			body += `const ${CONST}_L: Record<string, Record<string, ContentEntry>> = ${JSON.stringify(map, null, 2)};\n`;
+			body += `export const ${finder} = (slug: string, locale?: string, opts?: { fallback?: boolean }): ContentEntry | null => {\n  const v = locale ? ${CONST}_L[locale]?.[slug] : undefined;\n  if (v) return v;\n  if (opts?.fallback === false) return null;\n  const d = ${CONST}.find((p) => p.slug === slug) ?? null;\n  if (process.env.NODE_ENV !== "production" && locale && ${CONST}_L[locale] && d) console.warn(\`[june content] ${name}/\${slug}: no "\${locale}" variant — served default\`);\n  return d;\n};\n`;
+			body += `export const ${name} = (locale?: string): ContentEntry[] => locale && ${CONST}_L[locale] ? ${CONST}.map((p) => ${CONST}_L[locale]![p.slug] ?? p) : ${CONST};\n`;
+		}
+		names.push(name);
+	}
+	return {
+		code: "// AUTO-GENERATED by `june build` — edit content/**/*.md, not this file.\n" + (anyLocale ? "export type ContentEntry = { slug: string; data: Record<string, string | string[]>; body: string; original: string; html: string; locale?: string };\n" : "export type ContentEntry = { slug: string; data: Record<string, string | string[]>; body: string; original: string; html: string };\n") + body,
+		names
+	};
+}
+//#endregion
+export { collection, entry, generateContentModule, scanCollection };

package/dist/css-modules-ambient.d.ts

@@ -0,0 +1,10 @@
+//#region src/css-modules-ambient.d.ts
+// Ambient types for CSS Modules: `import styles from "./X.module.css"` resolves
+// to a map of local class name → scoped name. June ships this so app code (and
+// these tests/fixtures) typecheck; the create-june template references an
+// equivalent june-env.d.ts. (No top-level import/export → this is a GLOBAL
+// declaration, so the ambient module applies everywhere.)
+declare module "*.module.css" {
+  const classes: Record<string, string>;
+  export default classes;
+}

package/dist/css-modules.d.ts

@@ -0,0 +1,24 @@
+//#region src/css-modules.d.ts
+declare const MODULE_STYLES_URL = "/_june/modules.css";
+declare const isModuleCss: (id: string) => boolean;
+declare function stableKey(appRoot: string, file: string): string;
+declare function transformCssModule(file: string, appRoot: string): Promise<{
+  map: Record<string, string>;
+  css: string;
+}>;
+declare const moduleJs: (map: Record<string, string>) => string;
+type ModuleMaps = Record<string, Record<string, string>>;
+declare function buildModuleCss(appDir: string, appRoot: string): Promise<{
+  maps: ModuleMaps;
+  css: string | null;
+}>;
+declare function rolldownCssModulesPlugin(maps: ModuleMaps): {
+  name: string;
+  load(id: string): {
+    code: string;
+    moduleType: "js";
+  } | null;
+};
+declare function registerCssModules(maps: ModuleMaps): Promise<void>;
+//#endregion
+export { MODULE_STYLES_URL, ModuleMaps, buildModuleCss, isModuleCss, moduleJs, registerCssModules, rolldownCssModulesPlugin, stableKey, transformCssModule };

package/dist/css-modules.js

@@ -0,0 +1,127 @@
+import { readFile, readdir } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+//#region src/css-modules.ts
+const MODULE_STYLES_URL = "/_june/modules.css";
+const isModuleCss = (id) => id.endsWith(".module.css");
+function stableKey(appRoot, file) {
+	return relative(appRoot, file).split(sep).join("/");
+}
+async function transformOne(file, appRoot) {
+	const { transform } = await import("lightningcss");
+	const { code, exports } = transform({
+		filename: stableKey(appRoot, file),
+		code: Buffer.from(await readFile(file, "utf8")),
+		cssModules: { pattern: "[local]_[hash]" }
+	});
+	return {
+		css: code.toString(),
+		exports: exports ?? {}
+	};
+}
+async function transformGraph(entry, appRoot, all = {}) {
+	if (all[entry]) return all;
+	const t = await transformOne(entry, appRoot);
+	all[entry] = t;
+	for (const exp of Object.values(t.exports)) for (const c of exp.composes) if (c.type === "dependency") await transformGraph(resolve(dirname(entry), c.specifier), appRoot, all);
+	return all;
+}
+function resolveName(file, local, all, seen = /* @__PURE__ */ new Set()) {
+	const exp = all[file]?.[local];
+	if (!exp) return local;
+	const parts = [exp.name];
+	for (const c of exp.composes) if (c.type === "dependency") {
+		const target = resolve(dirname(file), c.specifier);
+		const k = `${target}::${c.name}`;
+		if (seen.has(k)) continue;
+		seen.add(k);
+		parts.push(resolveName(target, c.name, all, seen));
+	} else parts.push(c.name);
+	return parts.join(" ");
+}
+const exportsOnly = (all) => Object.fromEntries(Object.entries(all).map(([f, t]) => [f, t.exports]));
+async function transformCssModule(file, appRoot) {
+	const all = await transformGraph(file, appRoot);
+	const exports = exportsOnly(all);
+	const map = {};
+	for (const local of Object.keys(all[file].exports)) map[local] = resolveName(file, local, exports);
+	return {
+		map,
+		css: all[file].css
+	};
+}
+const moduleJs = (map) => `export default ${JSON.stringify(map)};`;
+async function findModuleCss(dir) {
+	const out = [];
+	const walk = async (d) => {
+		let entries;
+		try {
+			entries = await readdir(d, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const e of entries) {
+			const full = join(d, e.name);
+			if (e.isDirectory()) await walk(full);
+			else if (e.name.endsWith(".module.css")) out.push(full);
+		}
+	};
+	await walk(dir);
+	return out.sort();
+}
+async function buildModuleCss(appDir, appRoot) {
+	const files = await findModuleCss(appDir);
+	if (!files.length) return {
+		maps: {},
+		css: null
+	};
+	const all = {};
+	for (const file of files) await transformGraph(file, appRoot, all);
+	const exports = exportsOnly(all);
+	const maps = {};
+	for (const file of files) {
+		maps[file] = {};
+		for (const local of Object.keys(all[file].exports)) maps[file][local] = resolveName(file, local, exports);
+	}
+	return {
+		maps,
+		css: Object.keys(all).sort().map((f) => all[f].css).join("\n")
+	};
+}
+function rolldownCssModulesPlugin(maps) {
+	return {
+		name: "june-css-modules",
+		load(id) {
+			if (!isModuleCss(id)) return null;
+			return {
+				code: moduleJs(maps[id] ?? {}),
+				moduleType: "js"
+			};
+		}
+	};
+}
+let activeMaps = {};
+let runtimeRegistered = false;
+function registerBunCssModules() {
+	globalThis.Bun.plugin({
+		name: "june-css-modules",
+		setup(build) {
+			build.onLoad({ filter: /\.module\.css$/ }, (args) => ({
+				loader: "js",
+				contents: moduleJs(activeMaps[args.path] ?? {})
+			}));
+		}
+	});
+}
+async function registerNodeCssModules(maps) {
+	const { register } = await import("node:module");
+	register(new URL("./css-modules-loader.mjs", import.meta.url), { data: { maps } });
+}
+async function registerCssModules(maps) {
+	activeMaps = maps;
+	if (runtimeRegistered || !Object.keys(maps).length) return;
+	runtimeRegistered = true;
+	if (typeof globalThis.Bun !== "undefined") registerBunCssModules();
+	else await registerNodeCssModules(maps);
+}
+//#endregion
+export { MODULE_STYLES_URL, buildModuleCss, isModuleCss, moduleJs, registerCssModules, rolldownCssModulesPlugin, stableKey, transformCssModule };

package/dist/css.d.ts

@@ -0,0 +1,14 @@
+import { Targets } from "lightningcss";
+//#region src/css.d.ts
+declare const STYLES_URL = "/_june/global.css";
+declare function findGlobalCss(appDir: string): string | null;
+declare function globalCssUsesTailwind(appDir: string): boolean;
+declare function cssTargets(appDir: string): Promise<Targets>;
+declare function processCssCached(appDir: string): Promise<string | null>;
+declare function invalidateCss(): void;
+declare function minifyCss(css: string, filename?: string, targets?: Targets): Promise<string>;
+declare function processCss(appDir: string, opts?: {
+  minify?: boolean;
+}): Promise<string | null>;
+//#endregion
+export { STYLES_URL, cssTargets, findGlobalCss, globalCssUsesTailwind, invalidateCss, minifyCss, processCss, processCssCached };

package/dist/css.js

@@ -0,0 +1,114 @@
+import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
+//#region src/css.ts
+const STYLES_URL = "/_june/global.css";
+const GLOBAL_CSS = "global.css";
+function findGlobalCss(appDir) {
+	const p = join(appDir, GLOBAL_CSS);
+	return existsSync(p) ? p : null;
+}
+const usesTailwind = (css) => /@import\s+["']tailwindcss["']|@tailwind\b/.test(css);
+function globalCssUsesTailwind(appDir) {
+	const p = join(appDir, GLOBAL_CSS);
+	try {
+		return existsSync(p) && usesTailwind(readFileSync(p, "utf8"));
+	} catch {
+		return false;
+	}
+}
+function resolveFromApp(specifier, appDir) {
+	try {
+		return createRequire(pathToFileURL(join(appDir, "package.json"))).resolve(specifier);
+	} catch {
+		return null;
+	}
+}
+const v = (major, minor = 0) => major << 16 | minor << 8;
+const DEFAULT_TARGETS = {
+	chrome: v(107),
+	edge: v(107),
+	firefox: v(104),
+	safari: v(16)
+};
+let targetsCache = null;
+async function cssTargets(appDir) {
+	if (targetsCache?.appDir === appDir) return targetsCache.targets;
+	let targets = DEFAULT_TARGETS;
+	const blPath = resolveFromApp("browserslist", appDir);
+	if (blPath) try {
+		const browserslist = (await import(blPath)).default;
+		const { browserslistToTargets } = await import("lightningcss");
+		targets = browserslistToTargets(browserslist(void 0, { path: appDir }));
+	} catch {}
+	targetsCache = {
+		appDir,
+		targets
+	};
+	return targets;
+}
+async function compileTailwind(css, file, appDir, minify) {
+	const nodePath = resolveFromApp("@tailwindcss/node", appDir);
+	const oxidePath = resolveFromApp("@tailwindcss/oxide", appDir);
+	if (!nodePath || !oxidePath) return null;
+	const { compile, optimize, Features } = await import(nodePath);
+	const { Scanner } = await import(oxidePath);
+	const compiler = await compile(css, {
+		base: dirname(file),
+		onDependency: () => {}
+	});
+	const sources = [{
+		base: dirname(appDir),
+		pattern: "**/*",
+		negated: false
+	}, ...compiler.sources];
+	const candidates = compiler.features & Features.Utilities ? new Scanner({ sources }).scan() : [];
+	const out = compiler.build(candidates);
+	return minify ? optimize(out, { minify: true }).code : out;
+}
+let devCache = null;
+async function processCssCached(appDir) {
+	if (devCache?.appDir === appDir) return devCache.css;
+	const css = await processCss(appDir);
+	devCache = {
+		appDir,
+		css
+	};
+	return css;
+}
+function invalidateCss() {
+	devCache = null;
+}
+async function minifyCss(css, filename = "input.css", targets) {
+	try {
+		const { transform } = await import("lightningcss");
+		const { code } = transform({
+			filename,
+			code: Buffer.from(css),
+			minify: true,
+			targets
+		});
+		return code.toString();
+	} catch (e) {
+		console.warn("[june] CSS minify failed; emitting unminified:", e);
+		return css;
+	}
+}
+async function processCss(appDir, opts = {}) {
+	const file = findGlobalCss(appDir);
+	if (!file) return null;
+	const css = await readFile(file, "utf8");
+	if (usesTailwind(css)) {
+		const compiled = await compileTailwind(css, file, appDir, !!opts.minify).catch((e) => {
+			console.warn("[june] Tailwind compile failed; serving raw CSS:", e);
+			return null;
+		});
+		if (compiled !== null) return compiled;
+		console.warn("[june] global.css uses Tailwind but @tailwindcss/node + @tailwindcss/oxide aren't installed — serving raw CSS.");
+	}
+	return opts.minify ? await minifyCss(css, file, await cssTargets(appDir)) : css;
+}
+//#endregion
+export { STYLES_URL, cssTargets, findGlobalCss, globalCssUsesTailwind, invalidateCss, minifyCss, processCss, processCssCached };

package/dist/d1-BkdUg9kg.d.ts

@@ -0,0 +1,24 @@
+import { DbFactory } from "@junejs/core/resources";
+//#region src/d1.d.ts
+type D1Result<T> = {
+  results: T[];
+};
+type D1Meta = {
+  changes?: number;
+  last_row_id?: number;
+};
+interface D1PreparedStatement {
+  bind(...values: unknown[]): D1PreparedStatement;
+  all<T = unknown>(): Promise<D1Result<T>>;
+  first<T = unknown>(): Promise<T | null>;
+  run(): Promise<{
+    meta: D1Meta;
+  }>;
+}
+interface D1Database {
+  prepare(sql: string): D1PreparedStatement;
+  exec(sql: string): Promise<unknown>;
+}
+declare function d1(binding: D1Database): DbFactory;
+//#endregion
+export { d1 as n, D1Database as t };

package/dist/d1-migrate.d.ts

@@ -0,0 +1,31 @@
+import { n as MigrateResult } from "./migrate-BbWt-PuB.js";
+import { JuneDb } from "@junejs/core/resources";
+//#region src/d1-migrate.d.ts
+type D1Exec = (req: {
+  sql: string;
+  mode: "command" | "file";
+  json: boolean;
+}) => Promise<{
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}>;
+declare function inlineParams(sql: string, params: readonly unknown[]): string;
+declare function wranglerD1(opts: {
+  database: string;
+  configPath: string;
+  cwd: string;
+  wranglerVersion?: string;
+  exec?: D1Exec;
+}): JuneDb;
+declare function resolveD1Database(appRoot: string, configPath: string): Promise<string | null>;
+declare function migrateD1(opts: {
+  appRoot: string;
+  database: string;
+  configPath: string;
+  allowDestructive?: boolean;
+  exec?: D1Exec;
+  now?: string;
+}): Promise<MigrateResult>;
+//#endregion
+export { D1Exec, inlineParams, migrateD1, resolveD1Database, wranglerD1 };