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

package/dist/d1-migrate.js

@@ -0,0 +1,156 @@
+import { migrate } from "./migrate.js";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { tmpdir } from "node:os";
+//#region src/d1-migrate.ts
+function inlineParams(sql, params) {
+	let i = 0;
+	return sql.replace(/\?/g, () => {
+		const p = params[i++];
+		if (p === null || p === void 0) return "null";
+		if (typeof p === "number" || typeof p === "bigint") return String(p);
+		if (typeof p === "boolean") return p ? "1" : "0";
+		return `'${String(p).replace(/'/g, "''")}'`;
+	});
+}
+function parseD1Json(stdout) {
+	const pick = (arr) => {
+		const f = arr[0] ?? {};
+		return {
+			results: f.results ?? [],
+			meta: f.meta ?? {}
+		};
+	};
+	const trimmed = stdout.trim();
+	try {
+		return pick(JSON.parse(trimmed));
+	} catch {
+		const lines = trimmed.split("\n");
+		for (let i = lines.length - 1; i >= 0; i--) if (lines[i].trimStart().startsWith("[")) try {
+			return pick(JSON.parse(lines.slice(i).join("\n")));
+		} catch {}
+		throw new Error(`wrangler d1 execute: no JSON array in output:\n${stdout}`);
+	}
+}
+function defaultExec(opts) {
+	return async ({ sql, mode, json }) => {
+		const base = [
+			"bunx",
+			`wrangler@${opts.wranglerVersion}`,
+			"d1",
+			"execute",
+			opts.database,
+			"--remote",
+			"--config",
+			opts.configPath
+		];
+		let tmpDir;
+		if (mode === "file") {
+			tmpDir = await mkdtemp(join(tmpdir(), "june-d1-"));
+			const tmp = join(tmpDir, "migration.sql");
+			await writeFile(tmp, sql);
+			base.push("--file", tmp);
+		} else base.push("--command", sql);
+		if (json) base.push("--json");
+		try {
+			const proc = Bun.spawn(base, {
+				cwd: opts.cwd,
+				stdout: "pipe",
+				stderr: "pipe"
+			});
+			const [stdout, stderr, exitCode] = await Promise.all([
+				new Response(proc.stdout).text(),
+				new Response(proc.stderr).text(),
+				proc.exited
+			]);
+			return {
+				stdout,
+				stderr,
+				exitCode
+			};
+		} finally {
+			if (tmpDir) await rm(tmpDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+function wranglerD1(opts) {
+	const exec = opts.exec ?? defaultExec({
+		...opts,
+		wranglerVersion: opts.wranglerVersion ?? "4.99.0"
+	});
+	const fail = (r) => {
+		throw new Error(`wrangler d1 execute failed (exit ${r.exitCode})\n${r.stderr || r.stdout}`.trim());
+	};
+	const db = {
+		async query(sql, params = []) {
+			const r = await exec({
+				sql: inlineParams(sql, params),
+				mode: "command",
+				json: true
+			});
+			if (r.exitCode !== 0) fail(r);
+			return parseD1Json(r.stdout).results;
+		},
+		async get(sql, params = []) {
+			return (await db.query(sql, params))[0] ?? void 0;
+		},
+		async run(sql, params = []) {
+			const r = await exec({
+				sql: inlineParams(sql, params),
+				mode: "command",
+				json: true
+			});
+			if (r.exitCode !== 0) fail(r);
+			const { meta } = parseD1Json(r.stdout);
+			return {
+				changes: meta.changes ?? 0,
+				lastInsertRowid: meta.last_row_id ?? 0
+			};
+		},
+		async exec(sql) {
+			const r = await exec({
+				sql,
+				mode: "file",
+				json: false
+			});
+			if (r.exitCode !== 0) fail(r);
+		},
+		async transaction(fn) {
+			return fn(db);
+		},
+		async close() {}
+	};
+	return db;
+}
+async function resolveD1Database(appRoot, configPath) {
+	try {
+		const raw = await Bun.file(configPath).text();
+		if (/\.jsonc?$/.test(configPath)) {
+			const json = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+			const name = JSON.parse(json).d1_databases?.[0]?.database_name;
+			if (name) return name;
+		}
+	} catch {}
+	const pkgPath = join(appRoot, "package.json");
+	let pkgName;
+	try {
+		pkgName = JSON.parse(await Bun.file(pkgPath).text()).name;
+	} catch {}
+	return `${(pkgName ?? basename(appRoot)).replace(/[^a-z0-9-]/gi, "-").toLowerCase()}-db`;
+}
+async function migrateD1(opts) {
+	return migrate(wranglerD1({
+		database: opts.database,
+		configPath: opts.configPath,
+		cwd: opts.appRoot,
+		exec: opts.exec
+	}), join(opts.appRoot, "db", "migrations"), {
+		allowDestructive: opts.allowDestructive,
+		now: opts.now
+	});
+}
+//#endregion
+export { inlineParams, migrateD1, resolveD1Database, wranglerD1 };

package/dist/d1.d.ts

@@ -0,0 +1,2 @@
+import { n as d1, t as D1Database } from "./d1-BkdUg9kg.js";
+export { D1Database, d1 };

package/dist/d1.js

@@ -0,0 +1,32 @@
+//#region src/d1.ts
+function d1(binding) {
+	const db = {
+		dialect: "sqlite",
+		async query(sql, params = []) {
+			return (await binding.prepare(sql).bind(...params).all()).results;
+		},
+		async get(sql, params = []) {
+			return await binding.prepare(sql).bind(...params).first() ?? void 0;
+		},
+		async run(sql, params = []) {
+			const { meta } = await binding.prepare(sql).bind(...params).run();
+			return {
+				changes: meta.changes ?? 0,
+				lastInsertRowid: meta.last_row_id ?? 0
+			};
+		},
+		async exec(sql) {
+			await binding.exec(sql);
+		},
+		async transaction(fn) {
+			return fn(db);
+		},
+		async close() {}
+	};
+	return {
+		kind: "d1",
+		open: async () => db
+	};
+}
+//#endregion
+export { d1 };

package/dist/db.d.ts

@@ -0,0 +1,11 @@
+import { n as d1, t as D1Database } from "./d1-BkdUg9kg.js";
+import { n as pgJuneDb, r as postgres, t as PgClientLike } from "./postgres-driver-DkkBFikA.js";
+import { n as mysql, r as mysqlJuneDb, t as MysqlConnLike } from "./mysql-driver-BsrWVqbp.js";
+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?: {
+  path?: string;
+}): DbFactory;
+//#endregion
+export { type D1Database, type LibsqlClientLike, type MysqlConnLike, type PgClientLike, d1, libsqlJuneDb, mysql, mysqlJuneDb, pgJuneDb, postgres, sqlite, turso };

package/dist/db.js

@@ -0,0 +1,20 @@
+import { d1 } from "./d1.js";
+import { pgJuneDb, postgres } from "./postgres-driver.js";
+import { mysql, mysqlJuneDb } from "./mysql-driver.js";
+import { libsqlJuneDb, turso } from "./turso-driver.js";
+//#region src/db.ts
+function sqlite(opts = {}) {
+	const path = opts.path ?? ".june/dev.sqlite";
+	return {
+		kind: "sqlite",
+		open: async () => {
+			const { mkdirSync } = await import("node:fs");
+			const { dirname } = await import("node:path");
+			const { host } = await import("./host.js");
+			if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
+			return host.openDb(path);
+		}
+	};
+}
+//#endregion
+export { d1, libsqlJuneDb, mysql, mysqlJuneDb, pgJuneDb, postgres, sqlite, turso };

package/dist/deploy.d.ts

@@ -0,0 +1,25 @@
+import { D1Exec } from "./d1-migrate.js";
+//#region src/deploy.d.ts
+type CliRun = (args: string[], cwd: string) => Promise<{
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}>;
+type DeployResult = {
+  url: string | null;
+  dryRun: boolean;
+  configPath: string;
+  migrated: string[];
+};
+type DeployOptions = {
+  dryRun?: boolean;
+  skipBuild?: boolean;
+  skipMigrate?: boolean;
+  allowDestructive?: boolean;
+  prod?: boolean;
+  d1Exec?: D1Exec;
+  runCli?: CliRun;
+};
+declare function juneDeploy(appRoot: string, options?: DeployOptions): Promise<DeployResult>;
+//#endregion
+export { DeployResult, juneDeploy };

package/dist/deploy.js

@@ -0,0 +1,158 @@
+import { loadJuneConfig } from "./config-loader.js";
+import { juneBuild } from "./build.js";
+import { blockedMessage } from "./migrate.js";
+import { migrateD1, resolveD1Database } from "./d1-migrate.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+//#region src/deploy.ts
+const spawnCli = async (args, cwd) => {
+	const proc = Bun.spawn(args, {
+		cwd,
+		stdout: "pipe",
+		stderr: "pipe"
+	});
+	const [stdout, stderr, exitCode] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited
+	]);
+	return {
+		stdout,
+		stderr,
+		exitCode
+	};
+};
+async function juneDeploy(appRoot, options = {}) {
+	const cfg = await loadJuneConfig(appRoot);
+	const target = (cfg.deploy?.adapter)?.name ?? cfg.deploy?.target ?? "workers";
+	if (target !== "workers" && target !== "vercel" && target !== "deno" && target !== "static") throw new Error(`unknown deploy target: ${target}`);
+	if (!options.skipBuild) {
+		const built = await juneBuild(appRoot);
+		console.log(`built ${built.outFile}`);
+	}
+	const run = options.runCli ?? spawnCli;
+	if (target === "static") return deployStatic(appRoot);
+	if (target === "vercel") return deployVercel(appRoot, options, run);
+	if (target === "deno") return deployDeno(appRoot, cfg, options, run);
+	return deployWorkers(appRoot, cfg, options, run);
+}
+async function deployStatic(appRoot) {
+	const site = join(appRoot, "dist", "static");
+	const index = join(site, "index.html");
+	if (!existsSync(index)) throw new Error(`no static site (expected ${index}) — run \`june build\` with the static() adapter first`);
+	console.log(`static site built → ${site}\n  publish it with your host's CI (GitHub Pages: actions/upload-pages-artifact + deploy-pages,
+  or peaceiris/actions-gh-pages with publish_dir: dist/static). \`june deploy\` does not push.`);
+	return {
+		url: null,
+		dryRun: false,
+		configPath: site,
+		migrated: []
+	};
+}
+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`);
+	if (options.dryRun) {
+		console.log(`dry-run: built ${dist} (skipping deno deploy)`);
+		return {
+			url: null,
+			dryRun: true,
+			configPath: dist,
+			migrated: []
+		};
+	}
+	if (!process.env.DENO_DEPLOY_TOKEN) console.log("note: DENO_DEPLOY_TOKEN not set — `deno deploy` will use its own login\n      (run `deno deploy login` once, or export the token).");
+	const args = ["deno", "deploy"];
+	if (options.prod) args.push("--prod");
+	const { stdout, stderr, exitCode } = await run(args, dist);
+	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());
+		throw new Error(`deno deploy failed (exit ${exitCode})\n${stderr.trim()}`);
+	}
+	return {
+		url: stdout.match(/https:\/\/\S+\.deno\.(net|dev)\S*/)?.[0] ?? null,
+		dryRun: false,
+		configPath: dist,
+		migrated: []
+	};
+}
+async function deployVercel(appRoot, options, run) {
+	const out = join(appRoot, ".vercel", "output");
+	if (!existsSync(join(out, "config.json"))) throw new Error(`no Vercel Build Output found (expected ${out}/config.json) — run june build first`);
+	if (options.dryRun) {
+		console.log(`dry-run: built ${out} (skipping vercel deploy)`);
+		return {
+			url: null,
+			dryRun: true,
+			configPath: out,
+			migrated: []
+		};
+	}
+	if (!process.env.VERCEL_TOKEN) console.log("note: VERCEL_TOKEN not set — the vercel CLI will use its own login\n      (run `bunx vercel login` once, or export the token).");
+	const args = [
+		"bunx",
+		"vercel@latest",
+		"deploy",
+		"--prebuilt",
+		"--yes"
+	];
+	if (options.prod) args.push("--prod");
+	const { stdout, stderr, exitCode } = await run(args, appRoot);
+	if (stdout.trim()) console.log(stdout.trimEnd());
+	if (exitCode !== 0) {
+		if (/credentials|token|forbidden|unauthorized/i.test(stderr + stdout)) throw new Error("vercel authentication failed — set VERCEL_TOKEN or run `bunx vercel login`.\n" + stderr.trim());
+		throw new Error(`vercel deploy failed (exit ${exitCode})\n${stderr.trim()}`);
+	}
+	return {
+		url: stdout.match(/https:\/\/\S+\.vercel\.app\S*/)?.[0] ?? null,
+		dryRun: false,
+		configPath: out,
+		migrated: []
+	};
+}
+async function deployWorkers(appRoot, cfg, options, run) {
+	const configPath = [join(appRoot, "wrangler.toml"), join(appRoot, "wrangler.jsonc")].find(existsSync) ?? join(appRoot, "dist/wrangler.jsonc");
+	if (!existsSync(configPath)) throw new Error(`no wrangler config found (expected ${configPath}) — run june build first`);
+	const migrated = [];
+	if (cfg.resources?.db && !options.skipMigrate && !options.dryRun) {
+		const database = await resolveD1Database(appRoot, configPath);
+		if (database) {
+			const r = await migrateD1({
+				appRoot,
+				database,
+				configPath,
+				allowDestructive: options.allowDestructive,
+				exec: options.d1Exec
+			});
+			if (r.blocked) throw new Error(`D1 ${database}: ${blockedMessage(r.blocked)}`);
+			migrated.push(...r.applied);
+			console.log(r.applied.length ? `migrated D1 ${database}: ${r.applied.join(", ")}` : `D1 ${database}: migrations up to date`);
+		}
+	}
+	if (!options.dryRun && !process.env.CLOUDFLARE_API_TOKEN) console.log("note: CLOUDFLARE_API_TOKEN not set — wrangler will fall back to its own login\n      (run `bunx wrangler login` once, or export the token).");
+	const args = [
+		"bunx",
+		"wrangler@4.99.0",
+		"deploy",
+		"--config",
+		configPath
+	];
+	if (options.dryRun) args.push("--dry-run");
+	const { stdout: out, stderr: err, exitCode: code } = await run(args, appRoot);
+	if (out.trim()) console.log(out.trimEnd());
+	if (code !== 0) {
+		if (/authentication|login|10000/i.test(err + out)) throw new Error("wrangler authentication failed — set CLOUDFLARE_API_TOKEN or run `bunx wrangler login`.\n" + err.trim());
+		throw new Error(`wrangler deploy failed (exit ${code})\n${err.trim()}`);
+	}
+	return {
+		url: out.match(/https:\/\/\S+\.workers\.dev\S*/)?.[0] ?? null,
+		dryRun: options.dryRun ?? false,
+		configPath,
+		migrated
+	};
+}
+//#endregion
+export { juneDeploy };

package/dist/dev-reload.d.ts

@@ -0,0 +1,5 @@
+//#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 };

package/dist/dev-reload.js

@@ -0,0 +1,123 @@
+//#region src/dev-reload.ts
+const EVENTS_PATH = "/__june/events";
+const SCRIPT_PATH = "/__june/reload.js";
+const RELOAD_JS = `// june dev live-reload: reconnect-after-drop → reload; "css" event → hot-swap
+(() => {
+  let dropped = false;
+  let es;
+  const swapCss = () => {
+    document.querySelectorAll('link[rel="stylesheet"]').forEach((old) => {
+      const u = new URL(old.href);
+      if (u.pathname !== "/_june/global.css") return;
+      // Clone with a cache-busted href; drop the old one once the new loads so
+      // there's no flash of unstyled content. No page reload → island state and
+      // scroll survive.
+      const next = old.cloneNode();
+      u.searchParams.set("t", Date.now());
+      next.href = u.pathname + u.search;
+      next.addEventListener("load", () => old.remove(), { once: true });
+      old.parentNode.insertBefore(next, old.nextSibling);
+    });
+  };
+  const connect = () => {
+    es = new EventSource(${JSON.stringify(EVENTS_PATH)});
+    es.addEventListener("open", () => {
+      if (dropped) {
+        // push-HMR: morph the freshly-restarted page in place (state survives);
+        // hard-reload only if there's no morph hook or it can't apply. On a
+        // successful morph also swap the stylesheet: a .tsx edit can change the
+        // class set, so the Tailwind-compiled /_june/global.css must refresh too
+        // (cache-busted) — otherwise new utility classes render unstyled.
+        const hot = window.__juneLiveReload;
+        (hot ? hot() : Promise.resolve(false)).then(
+          (ok) => { if (ok) swapCss(); else location.reload(); },
+          () => location.reload(),
+        );
+      }
+      dropped = false;
+    });
+    es.addEventListener("css", swapCss); // stylesheet edit → swap, no reload
+    es.addEventListener("error", () => {
+      dropped = true;
+      // EventSource auto-retries while the connection is flaky, but goes to
+      // CLOSED (and stays there) on hard failures like a refused connection
+      // mid-restart — recreate it ourselves in that case.
+      if (es.readyState === EventSource.CLOSED) {
+        es.close();
+        setTimeout(connect, 300);
+      }
+    });
+  };
+  // Release the SSE on navigation. In MPA mode every click is a full reload that
+  // opens a fresh EventSource; without this the old connection lingers and, since
+  // each held SSE consumes one of the browser's ~6 HTTP/1.1 slots per host, rapid
+  // navigation saturates them — further page loads stall (pending) / 503.
+  addEventListener("pagehide", () => { try { es && es.close(); } catch (e) {} });
+  connect();
+})();
+`;
+const clients = /* @__PURE__ */ new Set();
+const enc = new TextEncoder();
+function notifyCssChange() {
+	const msg = enc.encode("event: css\ndata: 1\n\n");
+	for (const c of clients) try {
+		c.enqueue(msg);
+	} catch {
+		clients.delete(c);
+	}
+}
+function devEvents() {
+	let heartbeat;
+	let self;
+	const stream = new ReadableStream({
+		start(controller) {
+			self = controller;
+			clients.add(controller);
+			controller.enqueue(enc.encode("retry: 300\n\ndata: connected\n\n"));
+			heartbeat = setInterval(() => {
+				try {
+					controller.enqueue(enc.encode(":hb\n\n"));
+				} catch {
+					clearInterval(heartbeat);
+				}
+			}, 2e4);
+		},
+		cancel() {
+			clearInterval(heartbeat);
+			if (self) clients.delete(self);
+		}
+	});
+	return new Response(stream, { headers: {
+		"content-type": "text/event-stream",
+		"cache-control": "no-store"
+	} });
+}
+function withLiveReload(fetchApp) {
+	return async (req) => {
+		const { pathname } = new URL(req.url);
+		if (pathname === EVENTS_PATH) return devEvents();
+		if (pathname === SCRIPT_PATH) return new Response(RELOAD_JS, { headers: {
+			"content-type": "text/javascript; charset=utf-8",
+			"cache-control": "no-store"
+		} });
+		const res = await fetchApp(req);
+		if (!res.headers.get("content-type")?.includes("text/html") || !res.body) return res;
+		const tag = new TextEncoder().encode(`<script src="${SCRIPT_PATH}" defer><\/script>`);
+		const tagged = res.body.pipeThrough(new TransformStream({
+			transform(chunk, controller) {
+				controller.enqueue(chunk);
+			},
+			flush(controller) {
+				controller.enqueue(tag);
+			}
+		}));
+		const headers = new Headers(res.headers);
+		headers.delete("content-length");
+		return new Response(tagged, {
+			status: res.status,
+			headers
+		});
+	};
+}
+//#endregion
+export { notifyCssChange, withLiveReload };

package/dist/dev.d.ts

@@ -0,0 +1,13 @@
+import { JuneHost, ServeHandle } from "./host.js";
+//#region src/dev.d.ts
+type DevServerOptions = {
+  appDir: string;
+  port?: number;
+  host?: JuneHost;
+};
+type DevServer = ServeHandle & {
+  url: string;
+};
+declare function startDevServer({ appDir, port, host }: DevServerOptions): Promise<DevServer>;
+//#endregion
+export { DevServer, DevServerOptions, startDevServer };

package/dist/dev.js

@@ -0,0 +1,55 @@
+import { findGlobalCss, invalidateCss, processCssCached } from "./css.js";
+import { createApp } from "./app.js";
+import { loadJuneConfig } from "./config-loader.js";
+import { blockedMessage, migrateApp } from "./migrate.js";
+import { notifyCssChange, withLiveReload } from "./dev-reload.js";
+import { installAsyncContext } from "./instrumentation.js";
+import { host } from "./host.js";
+import { watch } from "node:fs";
+import { dirname } from "node:path";
+import { createServer } from "node:net";
+//#region src/dev.ts
+async function findFreePort(start, tries = 20) {
+	for (let p = start; p < start + tries; p++) if (await new Promise((resolve) => {
+		const probe = createServer();
+		probe.once("error", () => resolve(false));
+		probe.listen(p, () => probe.close(() => resolve(true)));
+	})) return p;
+	throw new Error(`june dev: no free port between ${start} and ${start + tries - 1}`);
+}
+async function startDevServer({ appDir, port = 3e3, host: host$1 = host }) {
+	await installAsyncContext();
+	const config = await loadJuneConfig(appDir);
+	const m = await migrateApp(dirname(appDir), config);
+	if (m?.applied.length) console.log(`[june] migrated: ${m.applied.join(", ")}`);
+	if (m?.blocked) console.warn(`[june] ${blockedMessage(m.blocked)}`);
+	const app = createApp({
+		appDir,
+		config
+	});
+	await app.warmup();
+	const freePort = await findFreePort(port);
+	if (freePort !== port) console.log(`[june] port ${port} is taken → using ${freePort}`);
+	port = freePort;
+	const handle = host$1.serve(withLiveReload((req) => app.fetch(req)), {
+		port,
+		earlyHints: () => app.earlyHints()
+	});
+	if (findGlobalCss(appDir)) {
+		watch(appDir, { recursive: true }, (_event, file) => {
+			if (file && file.endsWith(".css")) {
+				invalidateCss();
+				notifyCssChange();
+			}
+		});
+		processCssCached(appDir).catch(() => {});
+	}
+	const url = `http://localhost:${handle.port}`;
+	console.log(`june dev → ${url}  (host: ${host$1.name})`);
+	return {
+		...handle,
+		url
+	};
+}
+//#endregion
+export { startDevServer };

package/dist/host.d.ts

@@ -0,0 +1,25 @@
+import { JuneDb, RunResult } from "@junejs/core/resources";
+//#region src/host.d.ts
+type ServeHandle = {
+  port: number;
+  stop(force?: boolean): void;
+};
+type SpawnedModule = {
+  stdout: ReadableStream<Uint8Array>;
+  stderrText(): Promise<string>;
+  exited: Promise<number>;
+};
+interface JuneHost {
+  readonly name: "bun" | "node";
+  serve(handler: (req: Request) => Promise<Response>, opts: {
+    port: number;
+    earlyHints?: () => string[];
+  }): ServeHandle;
+  spawnModule(entry: string, args: string[], opts: {
+    conditions?: string[];
+  }): SpawnedModule;
+  openDb(path: string): Promise<JuneDb>;
+}
+declare const host: JuneHost;
+//#endregion
+export { type JuneDb, JuneHost, type RunResult, ServeHandle, SpawnedModule, host };