@ogygia/core 0.0.0 → 0.11.0

package/dist/compiler/link/server-manifest.js

@@ -0,0 +1,45 @@
+import { V_SERVER_ISLANDS } from "../ids.js";
+// src/compiler/link/server-manifest.ts
+/** The SERVER-island ids the manifest carries right now (deferred / server-picked regions). */
+function server_island_ids(program) {
+	const ids = [];
+	for (const [iid, virtualPath] of program.by_id) if (program.registry.get(virtualPath)?.server) ids.push(iid);
+	return ids;
+}
+function server_manifest_module(ssr, program, is_dev, devUrlFor, publicUrlFor) {
+	if (!ssr) return `export const load_islands = () => Promise.resolve({ islands: {} });\nexport const island_url = {};\nexport const island_name = {};\nexport const island_render = {};\nexport const render_island = {};\nexport const island_reads_page_data = null;`;
+	const urls = [];
+	const names = [];
+	const renders = [];
+	/** render id → the server entry that renders it (the smallest id: one answer per build) */
+	const by_render = /* @__PURE__ */ new Map();
+	for (const [iid, virtualPath] of program.by_id) {
+		const reg = program.registry.get(virtualPath);
+		if (!reg?.server) continue;
+		if (reg.renderId) {
+			renders.push(`  ${JSON.stringify(iid)}: ${JSON.stringify(reg.renderId)}`);
+			const seen = by_render.get(reg.renderId);
+			if (seen === void 0 || iid < seen) by_render.set(reg.renderId, iid);
+		}
+		const file = reg.componentPath ?? "";
+		const base = file.slice(file.lastIndexOf("/") + 1);
+		if (base.endsWith(".svelte")) names.push(`  ${JSON.stringify(iid)}: ${JSON.stringify(base.slice(0, -7))}`);
+		urls.push(`  ${JSON.stringify(iid)}: ${JSON.stringify(is_dev ? devUrlFor(virtualPath) : publicUrlFor(iid))}`);
+	}
+	return `export const load_islands = () => import(${JSON.stringify(V_SERVER_ISLANDS)});\nexport const island_url = {\n${urls.join(",\n")}\n};\nexport const island_name = {\n${names.join(",\n")}\n};\nexport const island_render = {\n${renders.join(",\n")}\n};\nexport const render_island = {\n${[...by_render].map(([r, iid]) => `  ${JSON.stringify(r)}: ${JSON.stringify(iid)}`).join(",\n")}\n};\nexport const island_reads_page_data = ${is_dev ? "null" : PAGE_DATA_READS_PLACEHOLDER};`;
+}
+/** `virtual:ogygia/server-islands`: each SERVER island's loader, `id → () => import(entry)` (empty on
+*  the client). Imported only by the manifest's `load_islands()` — never statically. */
+function server_islands_module(ssr, program) {
+	const entries = [];
+	if (ssr) {
+		for (const [iid, virtualPath] of program.by_id) if (program.registry.get(virtualPath)?.server) entries.push(`  ${JSON.stringify(iid)}: () => import(${JSON.stringify(virtualPath)})`);
+	}
+	return `export const islands = {\n${entries.join(",\n")}\n};\n`;
+}
+/** The token the build replaces with its answer (driver `patch_page_data_reads`), inside a string
+*  literal the bundler cannot fold: a plain `null` placeholder was inlined into every reader as the
+*  constant it was (every hole then looked its page up). Unpatched it parses to nothing → `null`. */
+const PAGE_DATA_READS_TOKEN = "__OGYGIA_PAGE_DATA_READS__";
+const PAGE_DATA_READS_PLACEHOLDER = `(() => { try { return JSON.parse("${PAGE_DATA_READS_TOKEN}"); } catch { return null; } })()`;
+export { PAGE_DATA_READS_PLACEHOLDER, PAGE_DATA_READS_TOKEN, server_island_ids, server_islands_module, server_manifest_module };

package/dist/compiler/link/speculation.d.ts

@@ -0,0 +1,17 @@
+/**
+ * MPA-mode Speculation Rules — the static `prerender` / `prefetch` JSON the server handle injects
+ * into every page head when the SPA router is OFF (`router: false`). Pure: no build state, one
+ * deterministic string. Covered by unit tests.
+ */
+/**
+ * Static Speculation Rules for MPA mode (`router: false`) — the server handle injects them into
+ * every page head. Document rules covering same-origin links, with a per-link/subtree opt-out
+ * (`data-ogygia-speculate="off"`, re-enable with `"on"`); the region endpoint is never speculated.
+ * BOTH lists ship: a prerender-capable browser prerenders (prefetch is its first stage), a
+ * prefetch-only browser prefetches, an unsupporting one ignores the JSON entirely — graceful by
+ * construction, no JS fallback. In SPA mode no rules exist at all: speculation caches serve real
+ * navigations only, which a body-swap router can never read.
+ *
+ * @internal Exported for unit tests.
+ */
+export declare function mpaSpeculationRules(endpoint?: string): string;

package/dist/compiler/link/speculation.js

@@ -0,0 +1,36 @@
+// src/compiler/link/speculation.ts
+/**
+* MPA-mode Speculation Rules — the static `prerender` / `prefetch` JSON the server handle injects
+* into every page head when the SPA router is OFF (`router: false`). Pure: no build state, one
+* deterministic string. Covered by unit tests.
+*/
+/**
+* Static Speculation Rules for MPA mode (`router: false`) — the server handle injects them into
+* every page head. Document rules covering same-origin links, with a per-link/subtree opt-out
+* (`data-ogygia-speculate="off"`, re-enable with `"on"`); the region endpoint is never speculated.
+* BOTH lists ship: a prerender-capable browser prerenders (prefetch is its first stage), a
+* prefetch-only browser prefetches, an unsupporting one ignores the JSON entirely — graceful by
+* construction, no JS fallback. In SPA mode no rules exist at all: speculation caches serve real
+* navigations only, which a body-swap router can never read.
+*
+* @internal Exported for unit tests.
+*/
+function mpaSpeculationRules(endpoint = "/__ogygia__") {
+	const where = { and: [
+		{ href_matches: "/*" },
+		{ not: { href_matches: endpoint + "*" } },
+		{ not: { selector_matches: "[rel~=nofollow]" } },
+		{ or: [{ not: { selector_matches: "[data-ogygia-speculate=\"off\"], [data-ogygia-speculate=\"off\"] *" } }, { selector_matches: "[data-ogygia-speculate=\"on\"], [data-ogygia-speculate=\"on\"] *" }] }
+	] };
+	return JSON.stringify({
+		prerender: [{
+			where,
+			eagerness: "moderate"
+		}],
+		prefetch: [{
+			where,
+			eagerness: "moderate"
+		}]
+	});
+}
+export { mpaSpeculationRules };

package/dist/compiler/link/transport.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `virtual:ogygia/transport` emitter — re-exports the app's universal `transport` hook (or an empty
+ * map) for the client remote wire codec. Universal hooks are isomorphic, so this is client-safe.
+ * Pure over the resolved absolute path to the app's universal hooks module (or null).
+ */
+export declare function transport_module(universal_hooks: string | null, kit_codec?: string | null): string;
+/**
+ * `virtual:ogygia/kit-transport` emitter — the value behind the barrel's `ogygia.transport` (the Kit
+ * `transport` hook the app spreads into its universal hooks). GENERATED per-app, not a fixed export:
+ * the real `ogygiaTransport` statically pulls the whole codec cluster (wire/store/snippet/fn + region,
+ * ~9 kB) since a wired value can nest any other kind. A **pure-island** app crosses NOTHING through
+ * Kit's transport, so it gets an empty map and never bundles a decoder it can't use. `app_crosses_wire`
+ * is the compiler's own knowledge (a transportable class / portable snippet → the `wire` mark, plus a
+ * remote file or a `region`/content import) — never a scan for `ogygia.transport` in app source.
+ * `transport_spec` is the resolvable path to ogygia's own `transport.js` (dist).
+ */
+export declare function kit_transport_module(app_crosses_wire: boolean, transport_spec: string): string;
+/** True when `src` produces a held region / transportable value that can cross Kit's `transport`. */
+export declare function source_crosses_wire(src: string): boolean;
+/**
+ * `virtual:ogygia/transportables` emitter — where the `[ogygia.wire]` codecs come from, so an island
+ * receiving a transportable prop never has to import the class itself. Per leg:
+ * - SERVER: side-effect-imports every module that defines a transportable class (the region endpoint
+ *   decodes signed props of any island; loaded once per process).
+ * - CLIENT: NO eager import — every island page used to download every transportable class of the
+ *   app. It exports `wire_loaders`, a class module's tag path (root-relative, the part of a tag
+ *   before `#`) → a lazy import; the runtime loads just the ones an island's props carry (the server
+ *   stamps them on its props sidecar) before it decodes them.
+ * `modules` is the Program's set of transportable module paths (absolute); `rel` makes a tag path.
+ */
+export declare function transportables_module(modules: Iterable<string>, ssr: boolean, rel: (abs: string) => string, crosses_wire?: boolean): string;

package/dist/compiler/link/transport.js

@@ -0,0 +1,67 @@
+import { OWN_SPECIFIER_SOURCE } from "../../own-package.js";
+// src/compiler/link/transport.ts
+/**
+* `virtual:ogygia/transport` emitter — re-exports the app's universal `transport` hook (or an empty
+* map) for the client remote wire codec. Universal hooks are isomorphic, so this is client-safe.
+* Pure over the resolved absolute path to the app's universal hooks module (or null).
+*/
+function transport_module(universal_hooks, kit_codec = null) {
+	if (!universal_hooks) return `export const transport = {};\nexport const encoders = {};\nexport const decoders = {};`;
+	const src = `import * as hooks from ${JSON.stringify(universal_hooks)};\nexport const transport = hooks.transport || {};\nconst codecs = Object.entries(transport);\nexport const encoders = Object.fromEntries(codecs.map(([k, v]) => [k, v.encode]));\nexport const decoders = Object.fromEntries(codecs.map(([k, v]) => [k, v.decode]));`;
+	if (!kit_codec) return src;
+	return `import { init_transport } from ${JSON.stringify(kit_codec)};\n${src}\ninit_transport(transport);`;
+}
+/**
+* `virtual:ogygia/kit-transport` emitter — the value behind the barrel's `ogygia.transport` (the Kit
+* `transport` hook the app spreads into its universal hooks). GENERATED per-app, not a fixed export:
+* the real `ogygiaTransport` statically pulls the whole codec cluster (wire/store/snippet/fn + region,
+* ~9 kB) since a wired value can nest any other kind. A **pure-island** app crosses NOTHING through
+* Kit's transport, so it gets an empty map and never bundles a decoder it can't use. `app_crosses_wire`
+* is the compiler's own knowledge (a transportable class / portable snippet → the `wire` mark, plus a
+* remote file or a `region`/content import) — never a scan for `ogygia.transport` in app source.
+* `transport_spec` is the resolvable path to ogygia's own `transport.js` (dist).
+*/
+function kit_transport_module(app_crosses_wire, transport_spec) {
+	if (!app_crosses_wire) return `export const transport = {};\n`;
+	return `export { ogygiaTransport as transport } from ${JSON.stringify(transport_spec)};\n`;
+}
+const OGYGIA_WIRE_NAMED = new RegExp(`import\\s+(?:type\\s+)?\\{([\\s\\S]*?)\\}\\s*from\\s*['"]${OWN_SPECIFIER_SOURCE}['"]`, "g");
+const WIRE_API = /\b(?:region|Region|site)\b/;
+const OGYGIA_CONTENT_IMPORT = /from\s*['"]@ogygia\/content(?:\/[a-z-]+)?['"]/;
+const OGYGIA_NS_IMPORT = new RegExp(`import\\s*\\*\\s*as\\s+(\\w+)\\s*from\\s*['"]${OWN_SPECIFIER_SOURCE}['"]`);
+const NS_WIRE_USAGE = /\b(\w+)\.(?:region|Region|site)\b/g;
+/** True when `src` produces a held region / transportable value that can cross Kit's `transport`. */
+function source_crosses_wire(src) {
+	if (OGYGIA_CONTENT_IMPORT.test(src)) return true;
+	OGYGIA_WIRE_NAMED.lastIndex = 0;
+	let m;
+	while (m = OGYGIA_WIRE_NAMED.exec(src)) if (WIRE_API.test(m[1])) return true;
+	const ns = OGYGIA_NS_IMPORT.exec(src);
+	if (!ns) return false;
+	NS_WIRE_USAGE.lastIndex = 0;
+	let u;
+	while (u = NS_WIRE_USAGE.exec(src)) if (u[1] === ns[1]) return true;
+	return false;
+}
+/**
+* `virtual:ogygia/transportables` emitter — where the `[ogygia.wire]` codecs come from, so an island
+* receiving a transportable prop never has to import the class itself. Per leg:
+* - SERVER: side-effect-imports every module that defines a transportable class (the region endpoint
+*   decodes signed props of any island; loaded once per process).
+* - CLIENT: NO eager import — every island page used to download every transportable class of the
+*   app. It exports `wire_loaders`, a class module's tag path (root-relative, the part of a tag
+*   before `#`) → a lazy import; the runtime loads just the ones an island's props carry (the server
+*   stamps them on its props sidecar) before it decodes them.
+* `modules` is the Program's set of transportable module paths (absolute); `rel` makes a tag path.
+*/
+function transportables_module(modules, ssr, rel, crosses_wire = false) {
+	if (ssr) {
+		const imports = [];
+		for (const abs of modules) imports.push(`import ${JSON.stringify(abs)};`);
+		return imports.join("\n") + "\nexport const wire_loaders = {};\nexport const wire_all = false;\n";
+	}
+	const entries = [];
+	for (const abs of modules) entries.push(`${JSON.stringify(rel(abs))}: () => import(${JSON.stringify(abs)})`);
+	return `export const wire_loaders = {${entries.join(", ")}};\nexport const wire_all = ${crosses_wire && entries.length > 0};\n`;
+}
+export { kit_transport_module, source_crosses_wire, transport_module, transportables_module };

package/dist/compiler/macros/bake.d.ts

@@ -0,0 +1,20 @@
+export type AliasEntry = {
+  find: string | RegExp;
+  replacement: string;
+};
+export type BakeOptions = {
+  /** Content hash of the eval entry — names/isolates the bundle in the cache. */
+  hash: string;
+  /** `resolve.alias` entries so a baked `fn` can import `$lib/…`. */
+  alias: AliasEntry[];
+  /** Project root — anchors the `$lib` convention fallback. */
+  root: string;
+};
+/**
+ * Rewrite every `import.meta.og.bake(fn)` in `src` to its inlined, devalue-serialized result. ASYNC
+ * (bundles + executes). Returns the input unchanged (same reference) when there is nothing to do.
+ * Throws build-voice on a non-serializable result or an `fn` that references non-imported scope.
+ */
+export declare function rewrite_bake(src: string, id: string, opts: Omit<BakeOptions, "hash"> & {
+  markupExts?: readonly string[];
+}): Promise<string>;

package/dist/compiler/macros/bake.js

@@ -0,0 +1,317 @@
+import { fs, path } from "../host.js";
+import { og_member } from "./wire.js";
+import { parse_module } from "../parse/oxc.js";
+import { og_js_regions } from "../parse/scan.js";
+import { BuildCache } from "../../build-cache.js";
+import { uneval } from "devalue";
+import { pathToFileURL } from "node:url";
+// src/compiler/macros/bake.ts
+/**
+* `import.meta.og.bake(fn)` — run `fn` at BUILD, serialize its result, inline it as a constant.
+*
+*   const nav = import.meta.og.bake(() => buildNav());   // → const nav = {…the computed tree…}
+*
+* At build the macro bundles `fn` together with the module's imports (via the app's vite / rolldown, aliases resolved),
+* executes the bundle in Node, `devalue.uneval`s the result, and rewrites the call to that literal.
+* At runtime there is no function and no work — just the answer, even in client code. "Run at build,
+* ship the answer." Content-addressed, so an unchanged `fn` (same source + same imports) re-bakes
+* only when its inputs change.
+*
+* The CONTRACT (like Bun's macros): `fn` is self-contained — it may use the module's IMPORTS and
+* literals, and `await` freely, but must not close over the module's other local variables (the
+* eval bundle carries the imports, not the surrounding scope). Its result must be devalue-serializable
+* (JSON + Date/Map/Set/RegExp/BigInt/…): a function or Promise in the result is a build error. Both
+* violations surface as build-voice errors naming the file and line. Node-only.
+*/
+const REGEX_SPECIAL_G = /[.*+?^${}()|[\]\\]/g;
+const LEADING_SLASH_RE = /^\//;
+/** bake's corner of the shared build cache — the transient eval bundles live here (never committed;
+*  written and deleted per bake). All writes go through the cache interface, like the git checkouts. */
+const bake_cache = new BuildCache("bake");
+const MARKER = "import.meta.og.bake";
+function walk(node, visit) {
+	visit(node);
+	for (const key in node) {
+		if (key === "type" || key === "start" || key === "end") continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const c of child) if (c && typeof c === "object" && typeof c.type === "string") walk(c, visit);
+		} else if (child && typeof child === "object" && typeof child.type === "string") walk(child, visit);
+	}
+}
+function line_of(src, offset) {
+	let line = 1;
+	for (let i = 0; i < offset && i < src.length; i++) if (src[i] === "\n") line++;
+	return line;
+}
+/**
+* Collect import declarations (with bound names) and every bake() call across the module's JS
+* regions — whole file for `.ts`/`.js`, each `<script>` block for `.svelte`. All spans are ABSOLUTE
+* (offset-mapped from each region into `src`), so an edit splices straight into `src`. Returns null
+* when no region parses (a half-typed file waits). `markup_exts` is the construct-host set.
+*/
+function scan(src, id, markup_exts) {
+	const regions = og_js_regions(src, id, markup_exts);
+	if (!regions) return null;
+	const imports = [];
+	const calls = [];
+	let any = false;
+	for (const region of regions) {
+		const { program, ok } = parse_module(region.code, id);
+		if (!ok || !program) continue;
+		any = true;
+		const off = region.offset;
+		for (const n of program.body ?? []) {
+			if (n.type !== "ImportDeclaration") continue;
+			const names = [];
+			for (const s of n.specifiers ?? []) if (s.local?.name) names.push(s.local.name);
+			imports.push({
+				start: off + n.start,
+				end: off + n.end,
+				text: region.code.slice(n.start, n.end),
+				names
+			});
+		}
+		walk(program, (n) => {
+			if (n.type !== "CallExpression" || og_member(n.callee) !== "bake") return;
+			const abs = off + n.start;
+			const args = n.arguments ?? [];
+			if (args.length !== 1) throw new Error(`[ogygia] ${id}:${line_of(src, abs)} — import.meta.og.bake(fn) takes exactly one argument (a function).`);
+			const a = args[0];
+			if (a.type !== "ArrowFunctionExpression" && a.type !== "FunctionExpression") throw new Error(`[ogygia] ${id}:${line_of(src, abs)} — import.meta.og.bake(fn): the argument must be a function (\`() => …\`).`);
+			calls.push({
+				start: abs,
+				end: off + n.end,
+				fn: region.code.slice(a.start, a.end)
+			});
+		});
+	}
+	return any ? {
+		imports,
+		calls
+	} : null;
+}
+/** The imports the EVAL bundle needs: those whose bound name appears (word-boundary) in some bake
+*  fn. Excludes everything the fns don't use — crucially a `.svelte`'s component imports, which
+*  rolldown couldn't execute anyway. */
+function eval_imports(imports, calls) {
+	const fnText = calls.map((c) => c.fn).join("\n");
+	return imports.filter((imp) => imp.names.some((name) => new RegExp(`(?<![\\w$])${name.replace(REGEX_SPECIAL_G, "\\$&")}(?![\\w$])`).test(fnText)));
+}
+/**
+* Which imports become UNUSED once every bake call is replaced by its result? An import is removable
+* when none of its bound names appears anywhere OUTSIDE the import statements and the bake spans — so
+* the binding was used only to feed a baked function. Over-conservative on purpose (a word-boundary
+* text scan of the remainder counts property keys / strings as uses too): it may KEEP a truly-dead
+* import, never REMOVE a live one. A kept-but-dead import just tree-shakes in the final bundle; a
+* wrongly-removed one would break the module.
+*/
+function dead_imports(src, imports, calls) {
+	const blanks = [...imports.map((i) => [i.start, i.end]), ...calls.map((c) => [c.start, c.end])].sort((a, b) => a[0] - b[0]);
+	let remainder = "";
+	let last = 0;
+	for (const [s, e] of blanks) {
+		remainder += src.slice(last, s) + " ".repeat(e - s);
+		last = e;
+	}
+	remainder += src.slice(last);
+	return imports.filter((imp) => imp.names.length > 0 && imp.names.every((name) => {
+		return !new RegExp(`(?<![\\w$])${name.replace(REGEX_SPECIAL_G, "\\$&")}(?![\\w$])`).test(remainder);
+	}));
+}
+const RESOLVE_EXTS = [
+	"",
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs",
+	".jsx",
+	".json"
+];
+const INDEX_EXTS = [
+	"/index.ts",
+	"/index.mts",
+	"/index.js",
+	"/index.mjs",
+	"/index.jsx",
+	"/index.tsx"
+];
+/** Resolve a relative specifier against `dir` to an existing absolute FILE path (extension/`index`
+*  probing), or null. */
+function resolve_relative(dir, source) {
+	return resolve_file(path.resolve(dir, source));
+}
+/**
+* The rolldown plugin that serves the virtual eval entry and roots resolution at the REAL module's
+* directory. It resolves — WITH extension probing, so an extensionless TS import lands on `x.ts` —
+* the entry's relative imports (`./data`) against `module_dir`, its `$lib/…` against `<root>/src/lib`
+* (the SvelteKit convention, robust even if the config alias isn't populated yet), and any configured
+* alias. Anything a resolved module then pulls in has a real path and resolves normally.
+*/
+function bake_plugin(entry_id, entry_code, module_dir, root, aliases) {
+	return {
+		name: "ogygia-bake-entry",
+		resolveId(source, importer) {
+			if (source === entry_id) return entry_id;
+			const from_entry = importer === entry_id || importer === void 0;
+			for (const { find, replacement } of aliases) {
+				let mapped = null;
+				if (typeof find === "string") {
+					if (source === find) mapped = replacement;
+					else if (source.startsWith(find + "/")) mapped = path.join(replacement, source.slice(find.length + 1));
+				} else if (find.test(source)) mapped = source.replace(find, replacement);
+				if (mapped) return resolve_file(mapped) ?? mapped;
+			}
+			if (source === "$lib" || source.startsWith("$lib/")) return resolve_file(path.join(root, "src", "lib", source.slice(4).replace(LEADING_SLASH_RE, "")));
+			if (from_entry && (source.startsWith("./") || source.startsWith("../"))) return resolve_relative(module_dir, source);
+			return null;
+		},
+		load(id) {
+			return id === entry_id ? entry_code : null;
+		}
+	};
+}
+/** Probe an absolute path base to an existing file (extension / `index`), or null. */
+function resolve_file(base) {
+	for (const e of RESOLVE_EXTS) {
+		const f = base + e;
+		try {
+			if (fs.statSync(f).isFile()) return f;
+		} catch {}
+	}
+	for (const e of INDEX_EXTS) {
+		const f = base + e;
+		try {
+			if (fs.statSync(f).isFile()) return f;
+		} catch {}
+	}
+	return null;
+}
+/**
+* Bundle + execute the eval entry, returning the array of results (one per bake call). Isolated in a
+* fresh module URL each time so Node's ESM cache never serves a stale bake.
+*/
+async function evaluate(entry_code, id, opts) {
+	const { build } = await import(
+		/* @vite-ignore */
+		"vite"
+);
+	const ENTRY = "\0ogygia-bake-entry.js";
+	const module_dir = path.dirname(id.split("?")[0]);
+	const result = await build({
+		configFile: false,
+		logLevel: "silent",
+		root: module_dir,
+		resolve: { extensions: [
+			".ts",
+			".tsx",
+			".mts",
+			".js",
+			".mjs",
+			".jsx",
+			".json",
+			".node"
+		] },
+		ssr: {
+			noExternal: true,
+			external: []
+		},
+		build: {
+			write: false,
+			minify: false,
+			target: "esnext",
+			ssr: true,
+			rollupOptions: {
+				input: ENTRY,
+				external: (source) => source.startsWith("node:"),
+				plugins: [bake_plugin(ENTRY, entry_code, module_dir, opts.root, opts.alias)],
+				output: {
+					format: "esm",
+					exports: "named"
+				}
+			}
+		}
+	});
+	{
+		const code = (Array.isArray(result) ? result[0].output : result.output)[0].code;
+		const dir = bake_cache.dir();
+		if (!dir) throw new Error("the build cache (node_modules/.ogygia) is unavailable — cannot stage the bake bundle");
+		const file = path.join(dir, `${opts.hash}.mjs`);
+		fs.writeFileSync(file, code);
+		try {
+			const mod = await import(pathToFileURL(file).href + `?t=${opts.hash}`);
+			if (typeof mod.__run !== "function") throw new Error("bake eval module produced no __run export");
+			return await mod.__run();
+		} finally {
+			fs.rmSync(file, { force: true });
+		}
+	}
+}
+/**
+* Rewrite every `import.meta.og.bake(fn)` in `src` to its inlined, devalue-serialized result. ASYNC
+* (bundles + executes). Returns the input unchanged (same reference) when there is nothing to do.
+* Throws build-voice on a non-serializable result or an `fn` that references non-imported scope.
+*/
+async function rewrite_bake(src, id, opts) {
+	if (!src.includes(MARKER)) return src;
+	const found = scan(src, id, opts.markupExts ?? [".svelte"]);
+	if (!found || !found.calls.length) return src;
+	const runners = found.calls.map((c, i) => `		r[${i}] = await (${c.fn})();`).join("\n");
+	const entry_code = eval_imports(found.imports, found.calls).map((i) => i.text).join("\n") + `\nexport async function __run() {\n\tconst r = [];\n${runners}\n\treturn r;\n}\n`;
+	const hash = hash_of(id + "\0" + entry_code);
+	let results;
+	try {
+		results = await evaluate(entry_code, id, {
+			...opts,
+			hash
+		});
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		throw new Error(`[ogygia] import.meta.og.bake() in ${path.basename(id)}: evaluating the function failed — ${msg}. A baked function may use this module's IMPORTS and literals only (not its other local variables), and must not touch runtime-only modules ($app/*, the browser).`);
+	}
+	const edits = [];
+	found.calls.forEach((c, i) => {
+		let literal;
+		try {
+			literal = uneval(results[i]);
+		} catch (e) {
+			const msg = e instanceof Error ? e.message : String(e);
+			throw new Error(`[ogygia] ${id}:${line_of(src, c.start)} — import.meta.og.bake(): the result is not serializable (${msg}). bake produces DATA — return plain values (JSON + Date/Map/Set/RegExp/BigInt), never a function, Promise, or class instance.`);
+		}
+		edits.push({
+			start: c.start,
+			end: c.end,
+			text: `(${literal})`
+		});
+	});
+	for (const imp of dead_imports(src, found.imports, found.calls)) {
+		const end = src[imp.end] === "\n" ? imp.end + 1 : imp.end;
+		edits.push({
+			start: imp.start,
+			end,
+			text: ""
+		});
+	}
+	edits.sort((a, b) => a.start - b.start);
+	let out = "";
+	let last = 0;
+	for (const e of edits) {
+		out += src.slice(last, e.start) + e.text;
+		last = e.end;
+	}
+	out += src.slice(last);
+	return out;
+}
+/** Stable non-crypto hash (FNV-1a) → hex. Enough to address a bundle by its inputs. */
+function hash_of(s) {
+	let h = 2166136261;
+	for (let i = 0; i < s.length; i++) {
+		h ^= s.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return (h >>> 0).toString(16).padStart(8, "0");
+}
+export { rewrite_bake };

package/dist/compiler/macros/browser.d.ts

@@ -0,0 +1,11 @@
+import { PluginMacro } from "./pipeline.js";
+/**
+ * Run the browser-safe macro passes over one module. `source` is the current text; `macros` are the
+ * plugins' browser-safe macros (content's `code` / `md`, built with the app's markdown config).
+ * Returns the rewritten code and whether anything changed — the caller invalidates its own sourcemap
+ * on `touched`.
+ */
+export declare function run_browser_macros(source: string, id: string, macros?: readonly PluginMacro[]): Promise<{
+  code: string;
+  touched: boolean;
+}>;

package/dist/compiler/macros/browser.js

@@ -0,0 +1,69 @@
+import { rewrite_wire } from "./wire.js";
+import { rewrite_dollar } from "./dollar.js";
+import { rewrite_store } from "./store.js";
+// src/compiler/macros/browser.ts
+/**
+* The BROWSER-safe subset of the module-macro pipeline ({@link ./pipeline.ts}), for a REPL that runs the
+* real compiler in-browser (the Observatory) — the same passes, over the same parser, as a real build.
+*
+* It runs `import.meta.og.wire`, `.$` / `.store`, and the plugins' macros it is handed (content's `.code`
+* / `.md`, with the same Shiki/mdsvex renderers as a build). It deliberately OMITS only
+* `bake` — which runs `fn` at build via a mini rolldown bundle + `node:url` module eval (Node-only) —
+* so `run_module_macros` (which statically imports the node-only `bake` pass) stays out of the browser
+* bundle; this is the narrow, node-free slice the REPL needs. Keep the pass order in sync with pipeline.ts.
+*
+* The `$` / `store` passes emit a SELF-CONTAINED call (`__og_$(tag, bound, () => factory)` — the factory
+* is inline), so a single-tree live preview runs them by providing the runtime `__og_$` / `__og_store`
+* (see the Observatory's `ogygia/internal` module). The build's fn/store MANIFEST (the cross-island decode
+* fallback the driver emits from the hoists) is not needed here — the preview is one tree.
+*/
+const MARKUP_EXTS = [".svelte"];
+/**
+* Run the browser-safe macro passes over one module. `source` is the current text; `macros` are the
+* plugins' browser-safe macros (content's `code` / `md`, built with the app's markdown config).
+* Returns the rewritten code and whether anything changed — the caller invalidates its own sourcemap
+* on `touched`.
+*/
+async function run_browser_macros(source, id, macros = []) {
+	let out = source;
+	let touched = false;
+	if (out.includes("import.meta.og.wire")) {
+		const rewritten = rewrite_wire(out, id, MARKUP_EXTS);
+		if (rewritten !== out) {
+			out = rewritten;
+			touched = true;
+		}
+	}
+	if (out.includes("import.meta.og.$")) {
+		const res = rewrite_dollar(out, id, id, MARKUP_EXTS);
+		if (res.code !== out) {
+			out = res.code;
+			touched = true;
+		}
+	}
+	if (out.includes("import.meta.og.store")) {
+		const rewritten = rewrite_store(out, id, id, MARKUP_EXTS);
+		if (rewritten !== out) {
+			out = rewritten;
+			touched = true;
+		}
+	}
+	for (const macro of macros) {
+		if (!out.includes("import.meta.og." + macro.name)) continue;
+		const rewritten = await macro.handler(out, {
+			id,
+			rel: id,
+			root: "/",
+			markupExts: MARKUP_EXTS
+		});
+		if (rewritten !== out) {
+			out = rewritten;
+			touched = true;
+		}
+	}
+	return {
+		code: out,
+		touched
+	};
+}
+export { run_browser_macros };

package/dist/compiler/macros/dedent.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Strip the common leading indentation from a block of source, and trim leading/trailing blank
+ * lines. Source embedded in a call (`import.meta.og.code(\`…\`, …)`) is indented to match where the
+ * call sits; that indentation is an artifact of the surrounding code, not part of the snippet. This
+ * normalizes it so the rendered `<pre>` shows the snippet's OWN logical indentation, flush-left.
+ *
+ * Blank lines (whitespace-only) don't count toward the common indent; tabs and spaces are treated by
+ * their literal column contribution to the prefix (the common prefix is computed on raw characters,
+ * so mixed tabs/spaces still de-indent correctly as long as the leading run is consistent — which it
+ * is for machine-indented source).
+ */
+export declare function dedent(text: string): string;