@ogygia/core 0.0.0 → 0.11.0

package/dist/compiler/macros/dedent.js

@@ -0,0 +1,36 @@
+// src/compiler/macros/dedent.ts
+const CRLF_G = /\r\n?/g;
+const LEADING_INDENT_RE = /^[\t ]*/;
+/**
+* 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).
+*/
+function dedent(text) {
+	const lines = text.replace(CRLF_G, "\n").split("\n");
+	while (lines.length && lines[0].trim() === "") lines.shift();
+	while (lines.length && lines[lines.length - 1].trim() === "") lines.pop();
+	if (!lines.length) return "";
+	let common = null;
+	for (const line of lines) {
+		if (line.trim() === "") continue;
+		const lead = LEADING_INDENT_RE.exec(line)[0];
+		if (common === null) common = lead;
+		else {
+			let i = 0;
+			const max = Math.min(common.length, lead.length);
+			while (i < max && common[i] === lead[i]) i++;
+			common = common.slice(0, i);
+		}
+		if (common === "") break;
+	}
+	const n = common?.length ?? 0;
+	return lines.map((line) => line.trim() === "" ? "" : line.slice(n)).join("\n");
+}
+export { dedent };

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

@@ -0,0 +1,15 @@
+/** One hoisted factory, destined for the fn manifest. `factory_src` is self-contained. */
+export interface DollarHoist {
+  tag: string;
+  factory_src: string;
+}
+export interface DollarResult {
+  code: string;
+  hoists: DollarHoist[];
+}
+/**
+ * Rewrite every `import.meta.og.$` mark in `src`. Returns the input (same reference, empty
+ * hoists) when there is nothing to do. Throws build-error voice on misuse. `rel_id` is the
+ * root-relative module path used for tags; `markup_exts` as in og-wire (['.svelte']).
+ */
+export declare function rewrite_dollar(src: string, id: string, rel_id: string, markup_exts: readonly string[]): DollarResult;

package/dist/compiler/macros/dollar.js

@@ -0,0 +1,387 @@
+import { match_close, og_js_regions } from "../parse/scan.js";
+import { parse_module } from "../parse/oxc.js";
+import { og_member } from "./wire.js";
+// src/compiler/macros/dollar.ts
+/**
+* `import.meta.og.$()` — the boundary mark for FUNCTIONS, as a compile construct.
+*
+* A closure can't serialize; what can is a handle: WHERE the code lives + WHAT it captured.
+* The construct does the split at build time:
+*
+*   setContext('fmt', import.meta.og.$((n) => `€${(n * (1 + tax)).toFixed(2)}`));
+*     ↓
+*   setContext('fmt', __og_$('src/routes/+layout.svelte#$0', [tax],
+*     (tax) => ((n) => `€${(n * (1 + tax)).toFixed(2)}`)));
+*
+* `__og_$` (runtime, fn-transport.ts) registers the factory under the tag and returns the LIVE
+* bound function — the host renders with a real closure; if it crosses a boundary, the fn kind
+* ships `{t: tag, d: bound}` and the far side rebinds. The factory is SELF-CONTAINED by
+* construction (see capture law), so the same factory text is also collected for the
+* `virtual:ogygia/fn-manifest` module the client runtime imports — every factory registers
+* before any island hydrates, and calls stay synchronous.
+*
+* CAPTURE LAW (v1): a free identifier inside the marked function becomes a BOUND PARAMETER —
+* its VALUE crosses as data (same law as island props; the boundary classifier judges it at
+* the seam). Recognized globals (console, Math, JSON, fetch, …) pass through untouched.
+* Because every non-global free name is bound, the factory references NOTHING from its module
+* — which is what makes hoisting it into the manifest a pure text move. A capture that is a
+* module IMPORT therefore crosses by VALUE too; if that value can't serialize (a function),
+* the boundary errors at the seam with the path — move that dependency inside the marked fn
+* (import it there via a bound serializable, or use a store/wire capture for live state).
+*
+* STRICT BY CONSTRUCTION (og-wire's playbook): the construct is legal in exactly ONE shape —
+* a direct call `import.meta.og.$(<inline function expression>)`. Bare access, aliasing,
+* zero/multiple arguments, or a non-function argument are BUILD ERRORS naming file:line.
+* Detection is AST-precise over the module's JS regions; no scanner fallback — a mid-edit
+* unparseable file simply doesn't transform (the marker then fails at runtime loudly, since
+* `import.meta.og` is undefined without the transform).
+*/
+const SERVER_MODULE_RE = /\.server(\.|$|\/)/;
+const IDENT_CHAR_RE = /[A-Za-z0-9_$.]/;
+const WS_RE = /\s/;
+const MARKER = "import.meta.og.$";
+/** Globals a hoisted factory may reference without binding (never captured). */
+const KNOWN_GLOBALS = /* @__PURE__ */ new Set([
+	"undefined",
+	"null",
+	"true",
+	"false",
+	"NaN",
+	"Infinity",
+	"globalThis",
+	"console",
+	"Math",
+	"JSON",
+	"Date",
+	"RegExp",
+	"Error",
+	"TypeError",
+	"RangeError",
+	"Object",
+	"Array",
+	"String",
+	"Number",
+	"Boolean",
+	"Symbol",
+	"BigInt",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"Promise",
+	"Proxy",
+	"Reflect",
+	"ArrayBuffer",
+	"Uint8Array",
+	"TextEncoder",
+	"TextDecoder",
+	"URL",
+	"URLSearchParams",
+	"fetch",
+	"Request",
+	"Response",
+	"Headers",
+	"FormData",
+	"AbortController",
+	"structuredClone",
+	"queueMicrotask",
+	"setTimeout",
+	"clearTimeout",
+	"setInterval",
+	"clearInterval",
+	"crypto",
+	"performance",
+	"atob",
+	"btoa",
+	"isNaN",
+	"isFinite",
+	"parseInt",
+	"parseFloat",
+	"encodeURIComponent",
+	"decodeURIComponent",
+	"window",
+	"document",
+	"navigator",
+	"location",
+	"arguments"
+]);
+function walk(node, visit, parent = null) {
+	visit(node, parent);
+	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, node);
+		} else if (child && typeof child === "object" && typeof child.type === "string") walk(child, visit, node);
+	}
+}
+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;
+}
+function misuse(id, src, offset, what) {
+	throw new Error(`[ogygia] ${id}:${line_of(src, offset)} — ${what}. import.meta.og.$ is legal in exactly one shape: a direct call wrapping an inline function — import.meta.og.$((args) => { … }). It hoists that function so its VALUE can cross an island boundary as a handle.`);
+}
+/** Names DECLARED anywhere inside `fn` (params, vars, inner fns, catch, destructuring). */
+function declared_names(fn) {
+	const out = /* @__PURE__ */ new Set();
+	const collect_pattern = (p) => {
+		if (!p) return;
+		switch (p.type) {
+			case "Identifier":
+				out.add(p.name);
+				break;
+			case "ObjectPattern":
+				for (const prop of p.properties ?? []) collect_pattern(prop.value ?? prop.argument);
+				break;
+			case "ArrayPattern":
+				for (const el of p.elements ?? []) collect_pattern(el);
+				break;
+			case "AssignmentPattern":
+				collect_pattern(p.left);
+				break;
+			case "RestElement": collect_pattern(p.argument);
+		}
+	};
+	walk(fn, (n) => {
+		if (n.type === "VariableDeclarator") collect_pattern(n.id);
+		else if (n.type === "FunctionDeclaration" || n.type === "ClassDeclaration") {
+			if (n.id?.name) out.add(n.id.name);
+		} else if (n.type === "CatchClause") collect_pattern(n.param);
+		else if (n.type === "FunctionExpression" || n.type === "ArrowFunctionExpression" || n.type === "FunctionDeclaration") {
+			for (const p of n.params ?? []) collect_pattern(p);
+			if (n.id?.name) out.add(n.id.name);
+		}
+	});
+	for (const p of fn.params ?? []) collect_pattern(p);
+	return out;
+}
+/** Free identifiers of `fn`: referenced, not declared inside, not a known global. Source order. */
+function free_names(fn) {
+	const declared = declared_names(fn);
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	walk(fn, (n, parent) => {
+		if (n.type !== "Identifier") return;
+		const name = n.name;
+		if (declared.has(name) || KNOWN_GLOBALS.has(name) || seen.has(name)) return;
+		if (parent) {
+			const pt = parent.type;
+			if (pt.startsWith("TS")) return;
+			if (pt === "MemberExpression" && parent.property === n && !parent.computed) return;
+			if ((pt === "Property" || pt === "ObjectProperty") && parent.key === n && !parent.shorthand) return;
+			if (pt === "LabeledStatement" || pt === "BreakStatement" || pt === "ContinueStatement") return;
+		}
+		seen.add(name);
+		out.push(name);
+	});
+	return out;
+}
+/**
+* The moved factory text is a RAW source slice, so in a `<script lang="ts">` (or `.ts`) file it still
+* carries TS type annotations — and it lands in a PLAIN-JS registration script (`data-ogygia-fnm`) +
+* the fn-manifest module. `(n: number) => …` there is a syntax error. Blank every TS-only span inside
+* `fn` (type annotations, generics, `as`/`satisfies`/`!`) with spaces — length-preserving, so the
+* captured-name offsets and the surrounding slice stay valid. This is the same technique as
+* ts-blank-space, scoped to the one hoisted function.
+*/
+function strip_ts_types(fn, region_code) {
+	const base = fn.start;
+	const chars = region_code.slice(base, fn.end).split("");
+	const blank = (s, e) => {
+		for (let i = s - base; i < e - base; i++) if (i >= 0 && i < chars.length) chars[i] = " ";
+	};
+	walk(fn, (n) => {
+		const t = n.type;
+		if (t === "TSTypeAnnotation" || t === "TSTypeParameterDeclaration" || t === "TSTypeParameterInstantiation") blank(n.start, n.end);
+		else if (t === "TSAsExpression" || t === "TSSatisfiesExpression" || t === "TSNonNullExpression" || t === "TSInstantiationExpression") {
+			const expr = n.expression;
+			if (expr) blank(expr.end, n.end);
+		}
+	});
+	return chars.join("");
+}
+/**
+* Rewrite every `import.meta.og.$` mark in `src`. Returns the input (same reference, empty
+* hoists) when there is nothing to do. Throws build-error voice on misuse. `rel_id` is the
+* root-relative module path used for tags; `markup_exts` as in og-wire (['.svelte']).
+*/
+function rewrite_dollar(src, id, rel_id, markup_exts) {
+	if (!src.includes(MARKER)) return {
+		code: src,
+		hoists: []
+	};
+	const regions = og_js_regions(src, id, markup_exts);
+	if (!regions) return {
+		code: src,
+		hoists: []
+	};
+	const edits = [];
+	const hoists = [];
+	let seq = 0;
+	let needs_import = false;
+	let needs_boundary_import = false;
+	for (const region of regions) {
+		const { program, ok } = parse_module(region.code, id.endsWith(".svelte") ? id + ".ts" : id);
+		if (!ok || !program) continue;
+		const server_only = /* @__PURE__ */ new Map();
+		for (const node of program.body ?? []) {
+			if (node.type !== "ImportDeclaration") continue;
+			const src_val = node.source?.value;
+			if (!src_val) continue;
+			if (!(src_val === "$app/server" || src_val.startsWith("$env/static/private") || src_val.startsWith("$env/dynamic/private") || SERVER_MODULE_RE.test(src_val))) continue;
+			for (const sp of node.specifiers ?? []) if (sp.local?.name) server_only.set(sp.local.name, src_val);
+		}
+		const claimed = /* @__PURE__ */ new Set();
+		walk(program, (n) => {
+			if (n.type === "CallExpression" && og_member(n.callee) === "$") {
+				const abs = region.offset + n.start;
+				const args = n.arguments;
+				if (!args || args.length !== 1) misuse(id, src, abs, `$() takes exactly one argument — the function to hoist`);
+				const fn = args[0];
+				if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression") {
+					claimed.add(n);
+					claimed.add(n.callee);
+					const expr_text = strip_ts_types(fn, region.code);
+					const site = `${rel_id}:${line_of(src, abs)}`;
+					needs_boundary_import = true;
+					edits.push({
+						start: abs,
+						end: region.offset + n.end,
+						text: `__og_boundary((${expr_text}), ${JSON.stringify(site)})`
+					});
+					return;
+				}
+				claimed.add(n);
+				claimed.add(n.callee);
+				const captures = free_names(fn);
+				for (const c of captures) {
+					const from = server_only.get(c);
+					if (from) misuse(id, src, abs, `$() captures \`${c}\` from the server-only module '${from}' — its value would ship into client HTML. Do the server work in a remote function and capture ITS result, or pass a derived, non-secret value instead`);
+				}
+				const fn_text = strip_ts_types(fn, region.code);
+				const tag = `${rel_id}#$${seq++}`;
+				const factory = `(${captures.join(", ")}) => (${fn_text})`;
+				hoists.push({
+					tag,
+					factory_src: factory
+				});
+				needs_import = true;
+				edits.push({
+					start: abs,
+					end: region.offset + n.end,
+					text: `__og_$(${JSON.stringify(tag)}, [${captures.join(", ")}], ${factory})`
+				});
+				return;
+			}
+			if (og_member(n) === "$" && !claimed.has(n)) misuse(id, src, region.offset + n.start, `bare import.meta.og.$ used as a value`);
+		});
+		if ((needs_import || needs_boundary_import) && !edits.some((e) => e.text.startsWith("import"))) {
+			const names = [needs_import ? "__og_$" : "", needs_boundary_import ? "__og_boundary" : ""].filter(Boolean).join(", ");
+			edits.push({
+				start: region.offset,
+				end: region.offset,
+				text: `import { ${names} } from 'ogygia/internal';`
+			});
+			needs_import = false;
+			needs_boundary_import = false;
+		}
+	}
+	const in_region = (pos) => regions.some((r) => pos >= r.offset && pos < r.offset + r.code.length);
+	const template_calls = [];
+	{
+		const M = "import.meta.og.$";
+		let at = -1;
+		while ((at = src.indexOf(M, at + 1)) !== -1) {
+			if (in_region(at)) continue;
+			const after = at + 16;
+			if (IDENT_CHAR_RE.test(src[after] ?? "")) continue;
+			let open = after;
+			while (open < src.length && WS_RE.test(src[open])) open++;
+			if (src[open] !== "(") continue;
+			let before = at - 1;
+			while (before >= 0 && WS_RE.test(src[before])) before--;
+			if (src[before] !== "{" && src[before] !== "(") continue;
+			const close = match_close(src, open);
+			if (close < 0) continue;
+			template_calls.push({
+				start: at,
+				end: close + 1,
+				args: src.slice(open + 1, close)
+			});
+			at = close;
+		}
+	}
+	let template_needs = null;
+	for (const call of template_calls) {
+		const arg_text = call.args.trim();
+		if (!arg_text) misuse(id, src, call.start, `$() takes exactly one argument`);
+		const wrapped = `(${arg_text})`;
+		const { program, ok } = parse_module(wrapped, id.endsWith(".svelte") ? id + ".expr.ts" : id);
+		if (!ok || !program) misuse(id, src, call.start, `$()'s argument does not parse as an expression`);
+		let expr = (program.body?.[0] ?? {}).expression ?? {};
+		while (expr.type === "ParenthesizedExpression") expr = expr.expression;
+		const expr_text = strip_ts_types(expr, wrapped);
+		if (expr.type === "ArrowFunctionExpression" || expr.type === "FunctionExpression") {
+			const captures = free_names(expr);
+			const tag = `${rel_id}#$${seq++}`;
+			const factory = `(${captures.join(", ")}) => (${expr_text})`;
+			hoists.push({
+				tag,
+				factory_src: factory
+			});
+			(template_needs ??= {
+				fn: false,
+				boundary: false
+			}).fn = true;
+			edits.push({
+				start: call.start,
+				end: call.end,
+				text: `__og_$(${JSON.stringify(tag)}, [${captures.join(", ")}], ${factory})`
+			});
+		} else {
+			const site = `${rel_id}:${line_of(src, call.start)}`;
+			(template_needs ??= {
+				fn: false,
+				boundary: false
+			}).boundary = true;
+			edits.push({
+				start: call.start,
+				end: call.end,
+				text: `__og_boundary((${expr_text}), ${JSON.stringify(site)})`
+			});
+		}
+	}
+	if (template_needs) {
+		const first = regions[0];
+		if (!first) misuse(id, src, 0, `og.$ in markup needs a <script> block to receive its runtime import`);
+		const names = [template_needs.fn ? "__og_$" : "", template_needs.boundary ? "__og_boundary" : ""].filter(Boolean).join(", ");
+		const existing = edits.find((e) => e.start === first.offset && e.text.startsWith("import { "));
+		if (existing) {
+			const have = existing.text.slice(9, existing.text.indexOf(" }"));
+			existing.text = `import { ${[.../* @__PURE__ */ new Set([...have.split(", "), ...names.split(", ")])].filter(Boolean).join(", ")} } from 'ogygia/internal';`;
+		} else edits.push({
+			start: first.offset,
+			end: first.offset,
+			text: `import { ${names} } from 'ogygia/internal';`
+		});
+	}
+	if (!edits.length) return {
+		code: src,
+		hoists: []
+	};
+	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 {
+		code: out,
+		hoists
+	};
+}
+export { rewrite_dollar };

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

@@ -0,0 +1,31 @@
+import { Profiler } from "../driver.js";
+/** A plugin's `import.meta.og.<name>` macro (registered with `b.macro`). */
+export interface PluginMacro {
+  name: string;
+  handler: (code: string, m: {
+    id: string;
+    rel: string;
+    root: string;
+    markupExts: readonly string[];
+  }) => string | Promise<string>;
+}
+export interface MacroPipelineCtx {
+  root: string;
+  /** Resolved Vite aliases the `bake` pass hands to its mini-bundler. */
+  resolveAlias: unknown[];
+  /** ogygia's own package root — auto-brand skips ogygia source. */
+  pkgRoot: string;
+  /** Filled with every `import.meta.og.$` hoist (tag → factory source) for the fn-manifest emit. */
+  dollarHoists: Map<string, string>;
+  /** The plugins' macros, in plugin order (after core's, before `bake`). */
+  macros?: readonly PluginMacro[];
+}
+/**
+ * Run the ordered macro passes over one module. `source` is the CURRENT text (a content-preset tag
+ * or an earlier pass may already have edited it upstream) — never the raw file — because each pass
+ * feeds the next. Returns the rewritten code and whether anything changed.
+ */
+export declare function run_module_macros(source: string, id: string, ctx: MacroPipelineCtx, profiler: Profiler): Promise<{
+  code: string;
+  touched: boolean;
+}>;

package/dist/compiler/macros/pipeline.js

@@ -0,0 +1,106 @@
+import { path } from "../host.js";
+import { rewrite_wire } from "./wire.js";
+import { rewrite_dollar } from "./dollar.js";
+import { rewrite_source } from "./source.js";
+import { auto_brand_stores, rewrite_store } from "./store.js";
+// src/compiler/macros/pipeline.ts
+/**
+* The module-macro pipeline — the ordered `import.meta.og.*` passes that run BEFORE either branch
+* (island transform / svelte compile / ts-region minting) sees a module: `wire`, `$`, `store`,
+* auto-branding, `code`/`md`, and `bake`. Each pass is a no-op unless its exact marker is present, is
+* extension-aware, and (where it matters) AST-precise. Pulled out of the Vite adapter so the whole
+* macro leg is one call (`Compiler.macros`) the driver owns — a REPL runs the same passes with no Vite
+* in sight. Pure over `(source, id, ctx)` apart from the `dollarHoists` map it fills and the profiler
+* timing it records; returns `{ code, touched }` (the caller invalidates its own sourcemap on touch).
+*/
+const performance = globalThis.performance;
+const EXPORT_CONST_RE = /export\s+const/;
+const CONSTRUCT_MARKUP_EXTS = [".svelte"];
+/**
+* Run the ordered macro passes over one module. `source` is the CURRENT text (a content-preset tag
+* or an earlier pass may already have edited it upstream) — never the raw file — because each pass
+* feeds the next. Returns the rewritten code and whether anything changed.
+*/
+async function run_module_macros(source, id, ctx, profiler) {
+	let out = source;
+	let touched = false;
+	if (out.includes("import.meta.og.wire")) {
+		const rewritten = rewrite_wire(out, id, CONSTRUCT_MARKUP_EXTS);
+		if (rewritten !== out) {
+			out = rewritten;
+			touched = true;
+		}
+	}
+	if (out.includes("import.meta.og.$")) {
+		const rel_dollar = path.relative(ctx.root, id.split("?")[0]).split(path.sep).join("/");
+		const res = rewrite_dollar(out, id, rel_dollar, CONSTRUCT_MARKUP_EXTS);
+		if (res.code !== out) {
+			out = res.code;
+			touched = true;
+			for (const h of res.hoists) ctx.dollarHoists.set(h.tag, h.factory_src);
+		}
+	}
+	if (out.includes("import.meta.og.source")) {
+		const rel_source = path.relative(ctx.root, id.split("?")[0]).split(path.sep).join("/");
+		const rewritten = rewrite_source(out, id, rel_source, CONSTRUCT_MARKUP_EXTS);
+		if (rewritten !== out) {
+			out = rewritten;
+			touched = true;
+		}
+	}
+	if (out.includes("import.meta.og.store")) {
+		const rel_store = path.relative(ctx.root, id.split("?")[0]).split(path.sep).join("/");
+		const rewritten = rewrite_store(out, id, rel_store, CONSTRUCT_MARKUP_EXTS);
+		if (rewritten !== out) {
+			out = rewritten;
+			touched = true;
+		}
+	}
+	if (!id.includes("node_modules") && !id.startsWith(ctx.pkgRoot) && EXPORT_CONST_RE.test(out)) {
+		const rel_auto = path.relative(ctx.root, id.split("?")[0]).split(path.sep).join("/");
+		const branded = auto_brand_stores(out, id, rel_auto, CONSTRUCT_MARKUP_EXTS);
+		if (branded !== out) {
+			out = branded;
+			touched = true;
+		}
+	}
+	if (ctx.macros?.length) {
+		let rel;
+		for (const macro of ctx.macros) {
+			if (!out.includes("import.meta.og." + macro.name)) continue;
+			rel ??= path.relative(ctx.root, id.split("?")[0]).split(path.sep).join("/");
+			const rewritten = await macro.handler(out, {
+				id: id.split("?")[0],
+				rel,
+				root: ctx.root,
+				markupExts: CONSTRUCT_MARKUP_EXTS
+			});
+			if (rewritten !== out) {
+				out = rewritten;
+				touched = true;
+			}
+		}
+	}
+	if (out.includes("import.meta.og.bake")) {
+		const __bk = profiler.P ? performance.now() : 0;
+		const { rewrite_bake } = await import("./bake.js");
+		const rewritten = await rewrite_bake(out, id, {
+			alias: ctx.resolveAlias,
+			root: ctx.root,
+			markupExts: CONSTRUCT_MARKUP_EXTS
+		});
+		if (rewritten !== out) {
+			out = rewritten;
+			touched = true;
+		}
+		if (profiler.P) {
+			profiler.prof.bakeMs += performance.now() - __bk;
+			profiler.prof.bakeN++;
+		}
+	}
+	return {
+		code: out,
+		touched
+	};
+}
+export { run_module_macros };

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

@@ -0,0 +1,6 @@
+/**
+ * Rewrite every source mark in `src` (strict position rules), injecting the runtime-wrapper
+ * import once. `rel` is the module's root-relative posix path (the id rail). Returns the input
+ * unchanged (same reference) when there is nothing to do.
+ */
+export declare function rewrite_source(src: string, id: string, rel: string, markup_exts: readonly string[]): string;