@junejs/server 0.1.2 → 0.2.0

package/dist/config-freeze.js

@@ -0,0 +1,54 @@
+import { deno, staticSite, vercel, workers } from "./adapter.js";
+import { CLIENT_SCRIPT_URL, findClientEntry } from "./client-bundle.js";
+import { STYLES_URL, findGlobalCss, globalCssUsesTailwind } from "./css.js";
+import { publicFileCheck, resolveIcons } from "./favicon.js";
+import { loadJuneConfig } from "./config-loader.js";
+import { join } from "node:path";
+import { deployOrigin, resolveAgent, resolveClientRouter, resolveSpeculationRules } from "@junejs/core/config";
+//#region src/config-freeze.ts
+function resolveDeployAdapter(deploy) {
+	if (deploy?.adapter) return deploy.adapter;
+	switch (deploy?.target) {
+		case "static": return staticSite();
+		case "vercel": return vercel();
+		case "deno": return deno();
+		default: return workers({
+			name: deploy?.name,
+			domain: deploy?.domain
+		});
+	}
+}
+async function freezeConfig(appRoot) {
+	const cfg = await loadJuneConfig(appRoot);
+	const hasClient = findClientEntry(join(appRoot, "app")) !== void 0 || findClientEntry(join(appRoot, ".june", "routes")) !== void 0;
+	const hasCss = findGlobalCss(join(appRoot, "app")) !== null;
+	return {
+		document: {
+			site: cfg.site ?? {},
+			deployOrigin: deployOrigin(cfg),
+			speculationRules: resolveSpeculationRules(cfg.speculation ?? void 0),
+			speculationDelivery: "inline",
+			viewTransitions: cfg.viewTransitions ?? true,
+			cssReset: cfg.cssReset ?? !globalCssUsesTailwind(join(appRoot, "app")),
+			clientRouter: resolveClientRouter(cfg.clientRouter),
+			clientScript: hasClient ? CLIENT_SCRIPT_URL : null,
+			styles: hasCss ? STYLES_URL : null,
+			basePath: normalizeBase(cfg.basePath),
+			icons: resolveIcons(cfg.site ?? {}, publicFileCheck(join(appRoot, "public"))).icons
+		},
+		agent: resolveAgent(cfg.agent),
+		i18n: cfg.i18n,
+		earlyHints: cfg.earlyHints ?? [],
+		buildExternal: cfg.build?.external ?? []
+	};
+}
+function normalizeBase(base) {
+	if (!base) return "";
+	const b = base.startsWith("/") ? base : `/${base}`;
+	return b.endsWith("/") ? b.slice(0, -1) : b;
+}
+function workerName(raw) {
+	return raw.replace(/^@[^/]+\//, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "app";
+}
+//#endregion
+export { freezeConfig, normalizeBase, resolveDeployAdapter, workerName };

package/dist/config-loader.d.ts

@@ -3,7 +3,6 @@ import { JuneConfig } from "@junejs/core/config";
 /** 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 };
+export declare function findJuneConfigPath(appDir: string): string | null;
+export declare function loadJuneConfig(appDir: string): Promise<JuneConfig>;
+//#endregion

package/dist/connection-auth.d.ts

@@ -0,0 +1,38 @@
+import { ActionContext } from "@junejs/core/context";
+//#region src/connection-auth.d.ts
+export type AccountTokenStore = (args: {
+  userId: string;
+  providerId: string;
+}) => Promise<{
+  accessToken: string;
+} | null> | {
+  accessToken: string;
+} | null;
+export type LinkedAccountAuthOptions = {
+  providerId: string;
+  store: AccountTokenStore;
+};
+export type ConnectionAuth = (ctx?: ActionContext) => Promise<{
+  token: string;
+}>;
+export declare function linkedAccountAuth(opts: LinkedAccountAuthOptions): ConnectionAuth;
+export type BetterAuthLike = {
+  api: {
+    getAccessToken: (input: {
+      body: {
+        providerId: string;
+        userId?: string;
+        accountId?: string;
+      };
+      headers?: HeadersInit;
+    }) => Promise<{
+      accessToken?: string;
+      token?: string;
+    } | null | undefined>;
+  };
+};
+export declare function betterAuthAccountTokenStore(auth: BetterAuthLike): AccountTokenStore;
+export declare function betterAuthAccessToken(auth: BetterAuthLike, opts: {
+  providerId: string;
+}): ConnectionAuth;
+//#endregion

package/dist/connection-auth.js

@@ -0,0 +1,31 @@
+//#region src/connection-auth.ts
+function linkedAccountAuth(opts) {
+	return async (ctx) => {
+		const userId = ctx?.user?.id;
+		if (!userId) throw new Error(`connection auth (${opts.providerId}): no authenticated principal — set requiresPrincipal and resolve identity on the surface`);
+		const record = await opts.store({
+			userId,
+			providerId: opts.providerId
+		});
+		if (!record?.accessToken) throw new Error(`connection auth (${opts.providerId}): user "${userId}" has no linked "${opts.providerId}" account`);
+		return { token: record.accessToken };
+	};
+}
+function betterAuthAccountTokenStore(auth) {
+	return async ({ userId, providerId }) => {
+		const res = await auth.api.getAccessToken({ body: {
+			providerId,
+			userId
+		} });
+		const accessToken = res?.accessToken ?? res?.token;
+		return accessToken ? { accessToken } : null;
+	};
+}
+function betterAuthAccessToken(auth, opts) {
+	return linkedAccountAuth({
+		providerId: opts.providerId,
+		store: betterAuthAccountTokenStore(auth)
+	});
+}
+//#endregion
+export { betterAuthAccessToken, betterAuthAccountTokenStore, linkedAccountAuth };

package/dist/content-freeze-CyiW2fRK.d.ts

@@ -0,0 +1,4 @@
+//#region src/content-freeze.d.ts
+declare function generateContent(appRoot: string): Promise<string[]>;
+//#endregion
+export { generateContent as t };

package/dist/content-freeze.d.ts

@@ -0,0 +1,2 @@
+import { t as generateContent } from "./content-freeze-CyiW2fRK.js";
+export { generateContent };

package/dist/content-freeze.js

@@ -0,0 +1,83 @@
+import { findJuneConfigPath, loadJuneConfig } from "./config-loader.js";
+import { generateContentModule } from "./content.js";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { execFileSync } from "node:child_process";
+//#region src/content-freeze.ts
+async function generateContent(appRoot) {
+	const contentDir = join(appRoot, "content");
+	await mkdir(join(appRoot, "app"), { recursive: true });
+	const emit = async (sources, knownLocales) => {
+		const { code, names } = generateContentModule(contentDir, knownLocales, sources);
+		await writeFile(join(appRoot, "app", "_content.ts"), code);
+		return names;
+	};
+	const resolveSources = (sources) => sources.map((s) => ({
+		...s,
+		dir: resolve(appRoot, s.dir)
+	}));
+	const declaredLocales = (config) => config.i18n ? [.../* @__PURE__ */ new Set([config.i18n.defaultLocale, ...Object.keys(config.i18n.locales)])] : [];
+	let config = null;
+	try {
+		config = await loadJuneConfig(appRoot);
+	} catch {}
+	if (config) return emit(resolveSources(config.content?.sources ?? []), declaredLocales(config));
+	const names = await emit([], void 0);
+	await seedContentImports(appRoot);
+	const probed = probeConfigFresh(appRoot);
+	if (probed === null) {
+		console.warn("[june gen] june.config.ts failed to load — content.sources/i18n locales (if any) not applied");
+		return names;
+	}
+	return emit(resolveSources(probed.sources), probed.locales);
+}
+async function seedContentImports(appRoot) {
+	const cfgPath = findJuneConfigPath(appRoot);
+	if (!cfgPath) return;
+	const contentFile = join(appRoot, "app", "_content.ts");
+	const current = existsSync(contentFile) ? await readFile(contentFile, "utf8") : "";
+	const cfgSrc = await readFile(cfgPath, "utf8");
+	const isIdent = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
+	const seen = /* @__PURE__ */ new Set();
+	const stubs = [];
+	for (const m of cfgSrc.matchAll(/import\s*(?:type\s+)?\{([^}]*)\}\s*from\s*["'][^"']*app\/_content(?:\.\w+)?["']/g)) {
+		const inner = (m[1] ?? "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+		for (const part of inner.split(",")) {
+			const name = part.replace(/\btype\b/g, "").split(/\s+as\s+/).pop()?.trim();
+			if (!name || !isIdent(name) || seen.has(name)) continue;
+			seen.add(name);
+			const reName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			if (!new RegExp(`export (?:const|function|type) ${reName}\\b`).test(current)) stubs.push(`export const ${name}: ContentEntry[] = [];`);
+		}
+	}
+	if (stubs.length) await writeFile(contentFile, current + stubs.join("\n") + "\n");
+}
+function probeConfigFresh(appRoot) {
+	const path = findJuneConfigPath(appRoot);
+	if (!path) return {
+		sources: [],
+		locales: []
+	};
+	const code = `import(${JSON.stringify(pathToFileURL(path).href)}).then((m) => { const c = m.default ?? {}; process.stdout.write("\\n__JUNE_CONTENT__" + JSON.stringify({ sources: c.content?.sources ?? [], locales: c.i18n ? [...new Set([c.i18n.defaultLocale, ...Object.keys(c.i18n.locales ?? {})])] : [] }) + "__END__"); }, () => process.exit(42));`;
+	try {
+		const m = execFileSync(process.execPath, [
+			...process.execArgv,
+			"-e",
+			code
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).match(/__JUNE_CONTENT__(.*?)__END__/s);
+		return m ? JSON.parse(m[1]) : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { generateContent };

package/dist/content.d.ts

@@ -1,6 +1,15 @@
 import { ContentSource } from "@junejs/core/config";
 //#region src/content.d.ts
-type ContentEntry = {
+export type Heading = {
+  depth: number;
+  text: string;
+  id: string;
+};
+export declare function headingIds(html: string): {
+  html: string;
+  headings: Heading[];
+};
+export type ContentEntry = {
   slug: string;
   file: string;
   /** Parsed frontmatter (string values; `tags`-style lists become string[]). */
@@ -9,31 +18,35 @@ type ContentEntry = {
   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). */
+  /** The body rendered to HTML (CommonMark + GFM, via @momiji-rs/sparkdown/gfm wasm).
+   *  Every heading carries a GitHub-compatible `id` (see @junejs/core/slug) and nothing
+   *  else — no injected links or classes; how an anchor looks is the app's call. */
   html: string;
+  /** The headings of `html`, in document order: their depth (1–6), plain text, and the
+   *  `id` each carries in `html` — for a table of contents, or a structured projection. */
+  headings: Heading[];
   /** 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 = {
+export type ScannedCollection = {
   default: ContentEntry[];
   byLocale: Record<string, ContentEntry[]>;
 };
-declare function scanCollection(dir: string, knownLocales?: readonly string[]): ScannedCollection;
+export 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[];
+export 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?: {
+export 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[]): {
+export declare function generateContentModule(contentDir: string, knownLocales?: readonly string[], sources?: readonly ContentSource[]): {
   code: string;
   names: string[];
 };
-//#endregion
-export { ContentEntry, ScannedCollection, collection, entry, generateContentModule, scanCollection };
+//#endregion

package/dist/content.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { initSync, toHtmlSync } from "@momiji-rs/sparkdown/gfm";
+import { createSlugger } from "@junejs/core/slug";
 //#region src/content.ts
 let wasmReady = false;
 const ensureWasm = () => {
@@ -9,6 +10,42 @@ const ensureWasm = () => {
 		wasmReady = true;
 	}
 };
+const NAMED = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+const decodeEntities = (s) => s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e) => e[0] === "#" ? String.fromCodePoint(e[1] === "x" || e[1] === "X" ? parseInt(e.slice(2), 16) : Number(e.slice(1))) : NAMED[e.toLowerCase()] ?? m);
+const ID_ATTR = /\sid\s*=\s*(?:"([^"]*)"|'([^']*)')/i;
+function headingIds(html) {
+	const slug = createSlugger();
+	const taken = /* @__PURE__ */ new Set();
+	for (const m of html.matchAll(new RegExp(ID_ATTR.source, "gi"))) taken.add(m[1] ?? m[2]);
+	const headings = [];
+	return {
+		html: html.replace(/<h([1-6])(\s[^>]*)?>([\s\S]*?)<\/h\1>/gi, (_m, depth, attrs, inner) => {
+			const text = decodeEntities(inner.replace(/<[^>]*>/g, "")).trim();
+			const own = attrs ? ID_ATTR.exec(attrs) : null;
+			const authored = own ? own[1] ?? own[2] : void 0;
+			let id = authored;
+			if (!id) {
+				do
+					id = slug(text);
+				while (taken.has(id));
+				taken.add(id);
+			}
+			headings.push({
+				depth: Number(depth),
+				text,
+				id
+			});
+			return authored ? _m : `<h${depth}${(attrs ?? "").replace(ID_ATTR, "")} id="${id}">${inner}</h${depth}>`;
+		}),
+		headings
+	};
+}
 function parseFrontmatter(raw) {
 	if (!raw.startsWith("---")) return {
 		data: {},
@@ -48,13 +85,15 @@ function loadEntry(file, slug, locale) {
 		if (h1?.[1]) data.title = h1[1];
 	}
 	ensureWasm();
+	const { html, headings } = headingIds(toHtmlSync(body));
 	const entry = {
 		slug,
 		file,
 		data,
 		body,
 		original,
-		html: toHtmlSync(body),
+		html,
+		headings,
 		...locale ? { locale } : {}
 	};
 	memo.set(key, {
@@ -160,6 +199,7 @@ function generateContentModule(contentDir, knownLocales, sources) {
 		body: e.body,
 		original: e.original,
 		html: e.html,
+		headings: e.headings,
 		...e.locale ? { locale: e.locale } : {}
 	});
 	const collections = /* @__PURE__ */ new Map();
@@ -193,9 +233,9 @@ function generateContentModule(contentDir, knownLocales, sources) {
 		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,
+		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; headings: Array<{ depth: number; text: string; id: string }>; locale?: string };\n" : "export type ContentEntry = { slug: string; data: Record<string, string | string[]>; body: string; original: string; html: string; headings: Array<{ depth: number; text: string; id: string }> };\n") + body,
 		names
 	};
 }
 //#endregion
-export { collection, entry, generateContentModule, scanCollection };
+export { collection, entry, generateContentModule, headingIds, scanCollection };

package/dist/core-version.d.ts

@@ -0,0 +1,4 @@
+//#region src/core-version.d.ts
+export declare function assertCoreRuntimeVersion(surface: string): void;
+export declare function checkCoreRuntimeVersion(surface: string, actual: number | undefined, expected?: number): void;
+//#endregion

package/dist/core-version.js

@@ -0,0 +1,12 @@
+import * as coreRuntime from "@junejs/core/agent-runtime";
+//#region src/core-version.ts
+const EXPECTED_CORE_RUNTIME_API = 7;
+function assertCoreRuntimeVersion(surface) {
+	checkCoreRuntimeVersion(surface, coreRuntime.RUNTIME_API_VERSION);
+}
+function checkCoreRuntimeVersion(surface, actual, expected = EXPECTED_CORE_RUNTIME_API) {
+	if (actual === expected) return;
+	throw new Error(`${surface}: @junejs/server is built against @junejs/core runtime API v${expected}, but the @junejs/core it resolved provides ${actual === void 0 ? "no RUNTIME_API_VERSION (a pre-0.1.1-dev.16 core)" : `v${actual}`} — two copies of @junejs/core are likely installed (one nested under @junejs/server). Align the app's @junejs/core with @junejs/server's peer range, then reinstall/dedupe so one copy remains.`);
+}
+//#endregion
+export { assertCoreRuntimeVersion, checkCoreRuntimeVersion };

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

@@ -7,4 +7,5 @@
 declare module "*.module.css" {
   const classes: Record<string, string>;
   export default classes;
-}
+}
+export {};

package/dist/css-modules.d.ts

@@ -1,24 +1,23 @@
 //#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<{
+export declare const MODULE_STYLES_URL = "/_june/modules.css";
+export declare const isModuleCss: (id: string) => boolean;
+export declare function stableKey(appRoot: string, file: string): string;
+export 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<{
+export declare const moduleJs: (map: Record<string, string>) => string;
+export type ModuleMaps = Record<string, Record<string, string>>;
+export declare function buildModuleCss(appDir: string, appRoot: string): Promise<{
   maps: ModuleMaps;
   css: string | null;
 }>;
-declare function rolldownCssModulesPlugin(maps: ModuleMaps): {
+export 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 };
+export declare function registerCssModules(maps: ModuleMaps): Promise<void>;
+//#endregion

package/dist/css.d.ts

@@ -1,14 +1,13 @@
 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?: {
+export declare const STYLES_URL = "/_june/global.css";
+export declare function findGlobalCss(appDir: string): string | null;
+export declare function globalCssUsesTailwind(appDir: string): boolean;
+export declare function cssTargets(appDir: string): Promise<Targets>;
+export declare function processCssCached(appDir: string): Promise<string | null>;
+export declare function invalidateCss(): void;
+export declare function minifyCss(css: string, filename?: string, targets?: Targets): Promise<string>;
+export declare function processCss(appDir: string, opts?: {
   minify?: boolean;
 }): Promise<string | null>;
-//#endregion
-export { STYLES_URL, cssTargets, findGlobalCss, globalCssUsesTailwind, invalidateCss, minifyCss, processCss, processCssCached };
+//#endregion

package/dist/d1-migrate.d.ts

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

package/dist/d1-migrate.js

@@ -142,12 +142,13 @@ async function resolveD1Database(appRoot, configPath) {
 	return `${(pkgName ?? basename(appRoot)).replace(/[^a-z0-9-]/gi, "-").toLowerCase()}-db`;
 }
 async function migrateD1(opts) {
-	return migrate(wranglerD1({
+	const db = wranglerD1({
 		database: opts.database,
 		configPath: opts.configPath,
 		cwd: opts.appRoot,
 		exec: opts.exec
-	}), join(opts.appRoot, "db", "migrations"), {
+	});
+	return migrate(db, join(opts.appRoot, "db", "migrations"), {
 		allowDestructive: opts.allowDestructive,
 		now: opts.now
 	});

package/dist/db.d.ts

@@ -4,8 +4,8 @@ import { n as mysql, r as mysqlJuneDb, t as MysqlConnLike } from "./mysql-driver
 import { i as turso, r as libsqlJuneDb, t as LibsqlClientLike } from "./turso-driver-C1wEigMZ.js";
 import { DbFactory } from "@junejs/core/resources";
 //#region src/db.d.ts
-declare function sqlite(opts?: {
+export declare function sqlite(opts?: {
   path?: string;
 }): DbFactory;
 //#endregion
-export { type D1Database, type LibsqlClientLike, type MysqlConnLike, type PgClientLike, d1, libsqlJuneDb, mysql, mysqlJuneDb, pgJuneDb, postgres, sqlite, turso };
+export { type D1Database, type LibsqlClientLike, type MysqlConnLike, type PgClientLike, d1, libsqlJuneDb, mysql, mysqlJuneDb, pgJuneDb, postgres, turso };

package/dist/deploy.d.ts

@@ -5,7 +5,7 @@ type CliRun = (args: string[], cwd: string) => Promise<{
   stderr: string;
   exitCode: number;
 }>;
-type DeployResult = {
+export type DeployResult = {
   url: string | null;
   dryRun: boolean;
   configPath: string;
@@ -20,6 +20,5 @@ type DeployOptions = {
   d1Exec?: D1Exec;
   runCli?: CliRun;
 };
-declare function juneDeploy(appRoot: string, options?: DeployOptions): Promise<DeployResult>;
-//#endregion
-export { DeployResult, juneDeploy };
+export declare function juneDeploy(appRoot: string, options?: DeployOptions): Promise<DeployResult>;
+//#endregion

package/dist/deploy.js

@@ -49,6 +49,7 @@ async function deployStatic(appRoot) {
 		migrated: []
 	};
 }
+const DENO_CREATE_HINT = "first deploy? provision the app in dynamic mode (auto-detect won't find an entrypoint):\n  deno deploy create --org=<org> --app=<app> --source=local \\\n    --do-not-use-detected-build-config --runtime-mode=dynamic --entrypoint=worker.js";
 async function deployDeno(appRoot, cfg, options, run) {
 	const dist = join(appRoot, "dist");
 	if (!existsSync(join(dist, "worker.js"))) throw new Error(`no built bundle (expected ${join(dist, "worker.js")}) — run june build first`);
@@ -68,8 +69,8 @@ async function deployDeno(appRoot, cfg, options, run) {
 	if (stdout.trim()) console.log(stdout.trimEnd());
 	if (exitCode !== 0) {
 		const out = stderr + stdout;
-		if (/token|login|unauthorized|forbidden|organization was not found|app.*not found/i.test(out)) throw new Error("Deno Deploy auth/org failed — set DENO_DEPLOY_TOKEN (or `deno deploy login`) and the\n  org/app in deno({ org, app }).\n  first deploy? provision the app in dynamic mode (auto-detect won't find an entrypoint):\n  deno deploy create --org=<org> --app=<app> --source=local \\\n    --do-not-use-detected-build-config --runtime-mode=dynamic --entrypoint=worker.js\n" + stderr.trim());
-		if (/no runtime entrypoint|build config/i.test(out)) throw new Error("Deno Deploy build failed — first deploy? provision the app in dynamic mode (auto-detect won't find an entrypoint):\n  deno deploy create --org=<org> --app=<app> --source=local \\\n    --do-not-use-detected-build-config --runtime-mode=dynamic --entrypoint=worker.js\n" + stderr.trim());
+		if (/token|login|unauthorized|forbidden|organization was not found|app.*not found/i.test(out)) throw new Error("Deno Deploy auth/org failed — set DENO_DEPLOY_TOKEN (or `deno deploy login`) and the\n  org/app in deno({ org, app }).\n  " + DENO_CREATE_HINT + "\n" + stderr.trim());
+		if (/no runtime entrypoint|build config/i.test(out)) throw new Error("Deno Deploy build failed — " + DENO_CREATE_HINT + "\n" + stderr.trim());
 		throw new Error(`deno deploy failed (exit ${exitCode})\n${stderr.trim()}`);
 	}
 	return {

package/dist/dev-reload.d.ts

@@ -1,5 +1,4 @@
 //#region src/dev-reload.d.ts
-declare function notifyCssChange(): void;
-declare function withLiveReload(fetchApp: (req: Request) => Promise<Response>): (req: Request) => Promise<Response>;
-//#endregion
-export { notifyCssChange, withLiveReload };
+export declare function notifyCssChange(): void;
+export declare function withLiveReload(fetchApp: (req: Request) => Promise<Response>): (req: Request) => Promise<Response>;
+//#endregion

package/dist/dev.d.ts

@@ -1,13 +1,16 @@
 import { JuneHost, ServeHandle } from "./host.js";
 //#region src/dev.d.ts
-type DevServerOptions = {
+export type DevServerOptions = {
   appDir: string;
   port?: number;
+  hostname?: string;
   host?: JuneHost;
 };
-type DevServer = ServeHandle & {
+export declare function devUrl(hostname: string, port: number): string;
+export declare function devAllowedHosts(configured: readonly string[] | undefined, hostname: string): string[];
+export type DevServer = Omit<ServeHandle, "stop"> & {
   url: string;
+  stop(force?: boolean): Promise<void>;
 };
-declare function startDevServer({ appDir, port, host }: DevServerOptions): Promise<DevServer>;
-//#endregion
-export { DevServer, DevServerOptions, startDevServer };
+export declare function startDevServer({ appDir, port, hostname, host }: DevServerOptions): Promise<DevServer>;
+//#endregion