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

package/dist/host.js

@@ -0,0 +1,107 @@
+import { openLocalSqlite } from "./sqlite-driver.js";
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+//#region src/host.ts
+function bunHost() {
+	return {
+		name: "bun",
+		serve(handler, opts) {
+			const server = Bun.serve({
+				port: opts.port,
+				fetch: handler,
+				idleTimeout: 0
+			});
+			return {
+				port: server.port ?? opts.port,
+				stop: (force) => void server.stop(force)
+			};
+		},
+		spawnModule(entry, args, opts) {
+			const cmd = [
+				"bun",
+				...(opts.conditions ?? []).flatMap((c) => ["--conditions", c]),
+				entry,
+				...args
+			];
+			const child = Bun.spawn({
+				cmd,
+				cwd: process.cwd(),
+				stdout: "pipe",
+				stderr: "pipe"
+			});
+			return {
+				stdout: child.stdout,
+				stderrText: () => new Response(child.stderr).text(),
+				exited: child.exited
+			};
+		},
+		openDb: openLocalSqlite
+	};
+}
+function nodeHost() {
+	return {
+		name: "node",
+		serve(handler, opts) {
+			const server = createServer(async (req, res) => {
+				try {
+					const hints = opts.earlyHints?.();
+					if (hints?.length && req.method === "GET" && (req.headers.accept ?? "").includes("text/html")) res.writeEarlyHints({ link: hints });
+					const url = `http://${req.headers.host ?? "localhost"}${req.url ?? "/"}`;
+					const hasBody = req.method !== "GET" && req.method !== "HEAD";
+					const response = await handler(new Request(url, {
+						method: req.method,
+						headers: req.headers,
+						body: hasBody ? Readable.toWeb(req) : void 0,
+						duplex: "half"
+					}));
+					res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+					if (response.body) Readable.fromWeb(response.body).pipe(res);
+					else res.end();
+				} catch (err) {
+					console.error("[june:node] request failed", err);
+					if (!res.headersSent) res.writeHead(500);
+					res.end("Internal Server Error");
+				}
+			});
+			server.listen(opts.port);
+			return {
+				get port() {
+					const addr = server.address();
+					return typeof addr === "object" && addr ? addr.port : opts.port;
+				},
+				stop(force) {
+					server.close();
+					if (force) server.closeAllConnections?.();
+				}
+			};
+		},
+		spawnModule(entry, args, opts) {
+			const child = spawn(process.execPath, [
+				"--import",
+				"tsx",
+				...(opts.conditions ?? []).flatMap((c) => ["--conditions", c]),
+				entry,
+				...args
+			], {
+				cwd: process.cwd(),
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+			const errChunks = [];
+			child.stderr.on("data", (c) => errChunks.push(c));
+			return {
+				stdout: Readable.toWeb(child.stdout),
+				stderrText: async () => Buffer.concat(errChunks).toString(),
+				exited: new Promise((resolve) => child.on("exit", (code) => resolve(code ?? 0)))
+			};
+		},
+		openDb: openLocalSqlite
+	};
+}
+const host = typeof Bun !== "undefined" ? bunHost() : nodeHost();
+//#endregion
+export { host };

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import { AdapterCapabilities, AdapterEmitContext, AdapterEntry, JuneAdapter, ResourcePlan, deno, staticSite, vercel, workers } from "./adapter.js";
+import { CreateAppOptions, JuneApp, createApp } from "./app.js";
+import { R2Bucket, localBlob, r2 } from "./blob.js";
+import { a as Pipeline, d as createPipeline, n as LayoutComponent, o as PipelineConfig, s as Resolved, u as RouteResolver } from "./pipeline-B2V6tKfO.js";
+import { WorkerManifest, createWorker } from "./worker.js";
+import { BuildResult, buildManifest, freezeConfig, generateContent, juneBuild, scanRoutes } from "./build.js";
+import { loadJuneConfig } from "./config-loader.js";
+import { ContentEntry, collection, entry } from "./content.js";
+import { a as blockedMessage, c as migrateApp, l as readMigrations, n as MigrateResult, o as classify, r as Migration, s as migrate, u as typesApp } from "./migrate-BbWt-PuB.js";
+import { D1Exec, migrateD1, resolveD1Database, wranglerD1 } from "./d1-migrate.js";
+import { n as d1, t as D1Database } from "./d1-BkdUg9kg.js";
+import { r as postgres } from "./postgres-driver-DkkBFikA.js";
+import { n as mysql } from "./mysql-driver-BsrWVqbp.js";
+import { i as turso } from "./turso-driver-C1wEigMZ.js";
+import { sqlite } from "./db.js";
+import { DeployResult, juneDeploy } from "./deploy.js";
+import { JuneDb, JuneHost, RunResult, ServeHandle, SpawnedModule, host } from "./host.js";
+import { DevServer, DevServerOptions, startDevServer } from "./dev.js";
+import { memoryKv, redisKv } from "./kv.js";
+import { ResourceFlags, WorkerEnv, bindWorkerResources, memoizeResources } from "./resources.js";
+import { MatchOptions, RouteMatch, RouteTreeMatch, SegmentMatch, listRoutes, matchRoute, matchRouteTree, resolveNotFound } from "./router.js";
+import { installAsyncContext } from "./instrumentation.js";
+import { Negotiated, negotiate } from "./negotiate.js";
+import { blob, db, kv } from "@junejs/db";
+import { I18nConfig, LOCALE_COOKIE, LocaleConfig, LocaleMatch, dirForLang, localeDir, localeHref, matchPinnedLocale, negotiateLocale, parseAcceptLanguage, resolveRequestLocale } from "@junejs/core/i18n";
+export { type AdapterCapabilities, type AdapterEmitContext, type AdapterEntry, type BuildResult, type ContentEntry, type CreateAppOptions, type D1Database, type D1Exec, type DeployResult, type DevServer, type DevServerOptions, type I18nConfig, type JuneAdapter, type JuneApp, type JuneDb, type JuneHost, LOCALE_COOKIE, type LayoutComponent, type LocaleConfig, type LocaleMatch, type MatchOptions, type MigrateResult, type Migration, type Negotiated, type Pipeline, type PipelineConfig, type R2Bucket, type Resolved, type ResourceFlags, type ResourcePlan, type RouteMatch, type RouteResolver, type RouteTreeMatch, type RunResult, type SegmentMatch, type ServeHandle, type SpawnedModule, type WorkerEnv, type WorkerManifest, bindWorkerResources, blob, blockedMessage, buildManifest, classify, collection, createApp, createPipeline, createWorker, d1, db, deno, dirForLang, entry, freezeConfig, generateContent, host, installAsyncContext, juneBuild, juneDeploy, kv, listRoutes, loadJuneConfig, localBlob, localeDir, localeHref, matchPinnedLocale, matchRoute, matchRouteTree, memoizeResources, memoryKv, migrate, migrateApp, migrateD1, mysql, negotiate, negotiateLocale, parseAcceptLanguage, postgres, r2, readMigrations, redisKv, resolveD1Database, resolveNotFound, resolveRequestLocale, scanRoutes, sqlite, startDevServer, staticSite, turso, typesApp, vercel, workers, wranglerD1 };

package/dist/index.js

@@ -0,0 +1,26 @@
+import { deno, staticSite, vercel, workers } from "./adapter.js";
+import { listRoutes, matchRoute, matchRouteTree, resolveNotFound } from "./router.js";
+import { negotiate } from "./negotiate.js";
+import { createPipeline } from "./pipeline.js";
+import { d1 } from "./d1.js";
+import { bindWorkerResources, memoizeResources } from "./resources.js";
+import { createApp } from "./app.js";
+import { localBlob, r2 } from "./blob.js";
+import { loadJuneConfig } from "./config-loader.js";
+import { collection, entry } from "./content.js";
+import { createWorker } from "./worker.js";
+import { buildManifest, freezeConfig, generateContent, juneBuild, scanRoutes } from "./build.js";
+import { blockedMessage, classify, migrate, migrateApp, readMigrations, typesApp } from "./migrate.js";
+import { migrateD1, resolveD1Database, wranglerD1 } from "./d1-migrate.js";
+import { postgres } from "./postgres-driver.js";
+import { mysql } from "./mysql-driver.js";
+import { turso } from "./turso-driver.js";
+import { sqlite } from "./db.js";
+import { juneDeploy } from "./deploy.js";
+import { installAsyncContext } from "./instrumentation.js";
+import { host } from "./host.js";
+import { startDevServer } from "./dev.js";
+import { memoryKv, redisKv } from "./kv.js";
+import { blob, db, kv } from "@junejs/db";
+import { LOCALE_COOKIE, dirForLang, localeDir, localeHref, matchPinnedLocale, negotiateLocale, parseAcceptLanguage, resolveRequestLocale } from "@junejs/core/i18n";
+export { LOCALE_COOKIE, bindWorkerResources, blob, blockedMessage, buildManifest, classify, collection, createApp, createPipeline, createWorker, d1, db, deno, dirForLang, entry, freezeConfig, generateContent, host, installAsyncContext, juneBuild, juneDeploy, kv, listRoutes, loadJuneConfig, localBlob, localeDir, localeHref, matchPinnedLocale, matchRoute, matchRouteTree, memoizeResources, memoryKv, migrate, migrateApp, migrateD1, mysql, negotiate, negotiateLocale, parseAcceptLanguage, postgres, r2, readMigrations, redisKv, resolveD1Database, resolveNotFound, resolveRequestLocale, scanRoutes, sqlite, startDevServer, staticSite, turso, typesApp, vercel, workers, wranglerD1 };

package/dist/instrumentation.d.ts

@@ -0,0 +1,4 @@
+//#region src/instrumentation.d.ts
+declare function installAsyncContext(): Promise<boolean>;
+//#endregion
+export { installAsyncContext };

package/dist/instrumentation.js

@@ -0,0 +1,15 @@
+import { installTraceContext } from "@junejs/core/instrumentation";
+//#region src/instrumentation.ts
+let installed = false;
+async function installAsyncContext() {
+	if (installed) return true;
+	try {
+		installTraceContext(new (await (import("node:async_hooks"))).AsyncLocalStorage());
+		installed = true;
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { installAsyncContext };

package/dist/island-registry.d.ts

@@ -0,0 +1,8 @@
+//#region src/island-registry.d.ts
+declare const ISLAND_REGISTRY_FILE = "_islands.gen.ts";
+declare function walk(dir: string): string[];
+declare function firstStatementIsDirective(src: string, directive: string): boolean;
+declare function exportNames(src: string): string[];
+declare function generateIslandRegistry(appDir: string): Promise<number>;
+//#endregion
+export { ISLAND_REGISTRY_FILE, exportNames, firstStatementIsDirective, generateIslandRegistry, walk };

package/dist/island-registry.js

@@ -0,0 +1,117 @@
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+//#region src/island-registry.ts
+const ISLAND_REGISTRY_FILE = "_islands.gen.ts";
+function walk(dir) {
+	return readdirSync(dir).flatMap((name) => {
+		const p = join(dir, name);
+		return statSync(p).isDirectory() ? walk(p) : [p];
+	});
+}
+function firstStatementIsDirective(src, directive) {
+	for (const line of src.split("\n")) {
+		const t = line.trim();
+		if (!t || t.startsWith("//")) continue;
+		return t.startsWith(`"${directive}"`) || t.startsWith(`'${directive}'`);
+	}
+	return false;
+}
+function exportNames(src) {
+	const names = [];
+	for (const line of src.split("\n")) {
+		const t = line.trim();
+		const decl = t.match(/^export\s+(?:async\s+)?(?:function|const|let|var|class)\s+([A-Za-z0-9_$]+)/);
+		if (decl) names.push(decl[1]);
+		const named = t.match(/^export\s*\{([^}]*)\}/);
+		if (named) for (const part of named[1].split(",")) {
+			const e = part.split(" as ").pop()?.trim();
+			if (e) names.push(e);
+		}
+	}
+	return names;
+}
+function importMap(program) {
+	const map = /* @__PURE__ */ new Map();
+	for (const n of program.body) {
+		if (n.type !== "ImportDeclaration" || typeof n.source?.value !== "string") continue;
+		const spec = n.source.value;
+		for (const s of n.specifiers ?? []) if (s.type === "ImportSpecifier") map.set(s.local.name, {
+			spec,
+			imported: s.imported.name,
+			kind: "named"
+		});
+		else if (s.type === "ImportDefaultSpecifier") map.set(s.local.name, {
+			spec,
+			imported: "default",
+			kind: "default"
+		});
+		else if (s.type === "ImportNamespaceSpecifier") map.set(s.local.name, {
+			spec,
+			imported: "*",
+			kind: "namespace"
+		});
+	}
+	return map;
+}
+function hasClientDirective(openingElement) {
+	return (openingElement.attributes ?? []).some((a) => a.type === "JSXAttribute" && a.name?.type === "JSXNamespacedName" && a.name.namespace?.name === "client");
+}
+function islandTags(program) {
+	const tags = [];
+	(function walkNode(node) {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) return node.forEach(walkNode);
+		if (node.type === "JSXElement" && node.openingElement?.name?.type === "JSXIdentifier" && hasClientDirective(node.openingElement)) tags.push(node.openingElement.name.name);
+		for (const k in node) if (k !== "type") walkNode(node[k]);
+	})(program);
+	return tags;
+}
+function resolveLocalModule(fromFile, spec) {
+	const base = resolve(dirname(fromFile), spec);
+	const exts = [
+		".tsx",
+		".ts",
+		".jsx",
+		".js"
+	];
+	for (const e of exts) if (existsSync(base + e)) return base + e;
+	for (const e of exts) if (existsSync(join(base, "index" + e))) return join(base, "index" + e);
+	return null;
+}
+async function generateIslandRegistry(appDir) {
+	const { parseSync } = await import("oxc-parser");
+	const seen = /* @__PURE__ */ new Map();
+	const entries = [];
+	for (const f of walk(appDir)) {
+		if (!/\.(tsx|jsx)$/.test(f) || f.endsWith("_islands.gen.ts") || f.endsWith(".gen.ts")) continue;
+		const src = readFileSync(f, "utf8");
+		if (!src.includes("client:")) continue;
+		const { program } = parseSync(f, src);
+		const ast = program;
+		const imports = importMap(ast);
+		const rel = "./" + relative(appDir, f);
+		for (const tag of islandTags(ast)) {
+			const imp = imports.get(tag);
+			if (!imp) throw new Error(`[june] <${tag} client:*/> in ${rel}: an island must be an IMPORTED component (a named import), not a local definition.`);
+			if (imp.kind !== "named") throw new Error(`[june] <${tag} client:*/> in ${rel}: island imports must be NAMED imports (a named \`{ ${tag} }\` import; default/namespace imports aren't supported as islands).`);
+			const name = imp.imported;
+			const isRelative = imp.spec.startsWith(".");
+			const loaderSpec = isRelative ? "./" + relative(appDir, resolve(dirname(f), imp.spec)) : imp.spec;
+			if (isRelative) {
+				const modFile = resolveLocalModule(f, imp.spec);
+				if (modFile && !firstStatementIsDirective(readFileSync(modFile, "utf8"), "use client")) throw new Error(`[june] island "${name}" (./${relative(appDir, modFile)}) is used with client:* but its module is not "use client". An island must be a client module.`);
+			}
+			const prev = seen.get(name);
+			if (prev && prev !== loaderSpec) throw new Error(`[june] duplicate island name "${name}" from different modules ("${prev}" and "${loaderSpec}"). Island names must be unique.`);
+			if (seen.has(name)) continue;
+			seen.set(name, loaderSpec);
+			entries.push(`  ${JSON.stringify(name)}: () => import(${JSON.stringify(loaderSpec)}).then((m) => m.${name}),`);
+		}
+	}
+	entries.sort();
+	const out = "// AUTO-GENERATED by June — do not edit. Lazy loaders for client:* islands.\n// Maps each island name to a loader that resolves its component; hydrateIslands uses it.\nexport const ISLAND_LOADERS: Record<string, () => Promise<unknown>> = {\n" + (entries.length ? entries.join("\n") + "\n" : "") + "};\n";
+	writeFileSync(join(appDir, ISLAND_REGISTRY_FILE), out);
+	return entries.length;
+}
+//#endregion
+export { ISLAND_REGISTRY_FILE, exportNames, firstStatementIsDirective, generateIslandRegistry, walk };

package/dist/kv.d.ts

@@ -0,0 +1,8 @@
+import { KvFactory } from "@junejs/core/resources";
+//#region src/kv.d.ts
+declare function memoryKv(): KvFactory;
+declare function redisKv(opts: {
+  url: string;
+}): KvFactory;
+//#endregion
+export { memoryKv, redisKv };

package/dist/kv.js

@@ -0,0 +1,35 @@
+import { memory, redis } from "@junejs/core/cache";
+//#region src/kv.ts
+function kvOver(store) {
+	return {
+		async get(key) {
+			return (await store.get(key))?.value ?? null;
+		},
+		async put(key, value, opts) {
+			const expiresAt = opts?.ttl ? Date.now() + opts.ttl * 1e3 : null;
+			await store.set(key, {
+				value,
+				expiresAt,
+				staleUntil: expiresAt,
+				tags: []
+			});
+		},
+		async delete(key) {
+			await store.delete(key);
+		}
+	};
+}
+function memoryKv() {
+	return {
+		kind: "memory",
+		open: async () => kvOver(await memory().connect())
+	};
+}
+function redisKv(opts) {
+	return {
+		kind: "redis",
+		open: async () => kvOver(await redis(opts).connect())
+	};
+}
+//#endregion
+export { memoryKv, redisKv };

package/dist/migrate-BbWt-PuB.d.ts

@@ -0,0 +1,32 @@
+import { JuneConfig } from "@junejs/core/config";
+import { JuneDb } from "@junejs/core/resources";
+//#region src/migrate.d.ts
+type Migration = {
+  id: string;
+  sql: string;
+};
+type ClassifiedMigration = Migration & {
+  destructive: boolean;
+  reasons: string[];
+};
+type MigrateResult = {
+  applied: string[];
+  blocked: ClassifiedMigration | null;
+};
+declare function classify(sql: string): {
+  destructive: boolean;
+  reasons: string[];
+};
+declare function readMigrations(dir: string): Promise<Migration[]>;
+declare function appliedIds(db: JuneDb): Promise<Set<string>>;
+declare function migrate(db: JuneDb, dir: string, opts?: {
+  allowDestructive?: boolean;
+  now?: string;
+}): Promise<MigrateResult>;
+declare function migrateApp(root: string, config: JuneConfig, opts?: {
+  allowDestructive?: boolean;
+}): Promise<MigrateResult | null>;
+declare function typesApp(root: string, config: JuneConfig): Promise<string | null>;
+declare function blockedMessage(m: ClassifiedMigration): string;
+//#endregion
+export { blockedMessage as a, migrateApp as c, appliedIds as i, readMigrations as l, MigrateResult as n, classify as o, Migration as r, migrate as s, ClassifiedMigration as t, typesApp as u };

package/dist/migrate.d.ts

@@ -0,0 +1,2 @@
+import { a as blockedMessage, c as migrateApp, i as appliedIds, l as readMigrations, n as MigrateResult, o as classify, r as Migration, s as migrate, t as ClassifiedMigration, u as typesApp } from "./migrate-BbWt-PuB.js";
+export { ClassifiedMigration, MigrateResult, Migration, appliedIds, blockedMessage, classify, migrate, migrateApp, readMigrations, typesApp };

package/dist/migrate.js

@@ -0,0 +1,115 @@
+import { existsSync } from "node:fs";
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+//#region src/migrate.ts
+const DESTRUCTIVE = [
+	{
+		re: /\bdrop\s+table\b/i,
+		label: "DROP TABLE"
+	},
+	{
+		re: /\bdrop\s+index\b/i,
+		label: "DROP INDEX"
+	},
+	{
+		re: /\bdrop\s+view\b/i,
+		label: "DROP VIEW"
+	},
+	{
+		re: /\bdrop\s+trigger\b/i,
+		label: "DROP TRIGGER"
+	},
+	{
+		re: /\bdelete\s+from\b/i,
+		label: "DELETE"
+	},
+	{
+		re: /\btruncate\b/i,
+		label: "TRUNCATE"
+	},
+	{
+		re: /\balter\s+table\b[\s\S]*?\bdrop\b/i,
+		label: "ALTER TABLE … DROP"
+	},
+	{
+		re: /\balter\s+table\b[\s\S]*?\brename\b/i,
+		label: "ALTER TABLE … RENAME"
+	}
+];
+function stripComments(sql) {
+	return sql.replace(/--[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function classify(sql) {
+	const clean = stripComments(sql);
+	const reasons = DESTRUCTIVE.filter((d) => d.re.test(clean)).map((d) => d.label);
+	return {
+		destructive: reasons.length > 0,
+		reasons
+	};
+}
+async function readMigrations(dir) {
+	if (!existsSync(dir)) return [];
+	const files = (await readdir(dir)).filter((f) => f.endsWith(".sql")).sort();
+	return Promise.all(files.map(async (id) => ({
+		id,
+		sql: await readFile(join(dir, id), "utf8")
+	})));
+}
+async function ensureLedger(db) {
+	await db.exec(`create table if not exists _june_migrations (id text primary key, applied_at text not null)`);
+}
+async function appliedIds(db) {
+	await ensureLedger(db);
+	const rows = await db.query("select id from _june_migrations");
+	return new Set(rows.map((r) => r.id));
+}
+async function migrate(db, dir, opts = {}) {
+	const already = await appliedIds(db);
+	const pending = (await readMigrations(dir)).filter((m) => !already.has(m.id));
+	const stamp = opts.now ?? (/* @__PURE__ */ new Date()).toISOString();
+	const applied = [];
+	for (const m of pending) {
+		const c = classify(m.sql);
+		if (c.destructive && !opts.allowDestructive) return {
+			applied,
+			blocked: {
+				...m,
+				...c
+			}
+		};
+		await db.exec(m.sql);
+		await db.run("insert into _june_migrations (id, applied_at) values (?, ?)", [m.id, stamp]);
+		applied.push(m.id);
+	}
+	return {
+		applied,
+		blocked: null
+	};
+}
+async function migrateApp(root, config, opts = {}) {
+	const factory = config.resources?.db;
+	if (!factory) return null;
+	const db = await factory.open();
+	try {
+		return await migrate(db, join(root, "db", "migrations"), opts);
+	} finally {
+		await db.close();
+	}
+}
+async function typesApp(root, config) {
+	const factory = config.resources?.db;
+	const emit = config.dataLayer?.emitTypes;
+	if (!factory || !emit) return null;
+	const db = await factory.open();
+	try {
+		await migrate(db, join(root, "db", "migrations"), { allowDestructive: false });
+		return await emit(db);
+	} finally {
+		await db.close();
+	}
+}
+function blockedMessage(m) {
+	return `migration ${m.id} is destructive (${m.reasons.join(", ")}) and was NOT applied.\n  review it, then apply explicitly: june db migrate --allow-destructive`;
+}
+//#endregion
+export { appliedIds, blockedMessage, classify, migrate, migrateApp, readMigrations, typesApp };

package/dist/mysql-driver-BsrWVqbp.d.ts

@@ -0,0 +1,12 @@
+import { DbFactory, JuneDb } from "@junejs/core/resources";
+//#region src/mysql-driver.d.ts
+interface MysqlConnLike {
+  query(sql: string, params?: unknown[]): Promise<[unknown, unknown]>;
+  end(): Promise<void>;
+}
+declare function mysqlJuneDb(conn: MysqlConnLike): JuneDb;
+declare function mysql(opts: {
+  url: string;
+}): DbFactory;
+//#endregion
+export { mysql as n, mysqlJuneDb as r, MysqlConnLike as t };

package/dist/mysql-driver.d.ts

@@ -0,0 +1,2 @@
+import { n as mysql, r as mysqlJuneDb, t as MysqlConnLike } from "./mysql-driver-BsrWVqbp.js";
+export { MysqlConnLike, mysql, mysqlJuneDb };

package/dist/mysql-driver.js

@@ -0,0 +1,52 @@
+//#region src/mysql-driver.ts
+function mysqlJuneDb(conn) {
+	const self = {
+		dialect: "mysql",
+		async query(sql, params = []) {
+			return (await conn.query(sql, params))[0];
+		},
+		async get(sql, params = []) {
+			return (await conn.query(sql, params))[0][0] ?? void 0;
+		},
+		async run(sql, params = []) {
+			const header = (await conn.query(sql, params))[0];
+			return {
+				changes: header.affectedRows ?? 0,
+				lastInsertRowid: header.insertId ?? 0
+			};
+		},
+		async exec(sql) {
+			await conn.query(sql);
+		},
+		async transaction(fn) {
+			await conn.query("begin");
+			try {
+				const out = await fn(self);
+				await conn.query("commit");
+				return out;
+			} catch (e) {
+				await conn.query("rollback");
+				throw e;
+			}
+		},
+		async close() {
+			await conn.end();
+		}
+	};
+	return self;
+}
+function mysql(opts) {
+	return {
+		kind: "mysql",
+		open: async () => {
+			const mod = await import("mysql2/promise");
+			const create = (mod.default ?? mod).createConnection;
+			return mysqlJuneDb(await create({
+				uri: opts.url,
+				multipleStatements: true
+			}));
+		}
+	};
+}
+//#endregion
+export { mysql, mysqlJuneDb };

package/dist/negotiate.d.ts

@@ -0,0 +1,11 @@
+import { RenderTarget } from "@junejs/core/route";
+import { FRAGMENT_ACCEPT, SEGMENT_HEADER, TITLE_HEADER, encodeTitle } from "@junejs/core/nav-protocol";
+//#region src/negotiate.d.ts
+type Negotiated = {
+  target: RenderTarget;
+  pathname: string;
+  speculative: boolean;
+};
+declare function negotiate(url: URL, request: Request, basePath?: string): Negotiated;
+//#endregion
+export { FRAGMENT_ACCEPT, Negotiated, SEGMENT_HEADER, TITLE_HEADER, encodeTitle, negotiate };

package/dist/negotiate.js

@@ -0,0 +1,39 @@
+import { FRAGMENT_ACCEPT, SEGMENT_HEADER, TITLE_HEADER, encodeTitle } from "@junejs/core/nav-protocol";
+//#region src/negotiate.ts
+const EXT_TARGET = {
+	".json": "json",
+	".md": "md"
+};
+const ACCEPT_TARGET = [
+	[/text\/vnd\.june\.fragment\+html/, "fragment"],
+	[/text\/markdown/, "md"],
+	[/application\/json/, "json"]
+];
+function negotiate(url, request, basePath) {
+	const original = basePath ?? url.pathname;
+	let pathname = original;
+	let target = null;
+	for (const [ext, t] of Object.entries(EXT_TARGET)) if (pathname.endsWith(ext)) {
+		target = t;
+		pathname = pathname.slice(0, -ext.length) || "/";
+		break;
+	}
+	if (pathname === "/index") pathname = "/";
+	else if (target && pathname === "/") pathname = original;
+	if (!target) {
+		const accept = request.headers.get("accept") ?? "";
+		for (const [re, t] of ACCEPT_TARGET) if (re.test(accept)) {
+			target = t;
+			break;
+		}
+	}
+	const purpose = request.headers.get("sec-purpose") ?? "";
+	const speculative = /prefetch|prerender/.test(purpose);
+	return {
+		target: target ?? "view",
+		pathname,
+		speculative
+	};
+}
+//#endregion
+export { FRAGMENT_ACCEPT, SEGMENT_HEADER, TITLE_HEADER, encodeTitle, negotiate };