@ogygia/core 0.0.0 → 0.11.0

package/dist/compiler/flags.d.ts

@@ -0,0 +1,16 @@
+/** The import a flag site comes through. (Moves into the flags plugin's compile facet once the
+ *  compile port lands: internal/notes/packages.md.) */
+export declare const FLAGS_SPEC = "@ogygia/flags";
+export interface FlagSite {
+  name: string;
+  kind: "flag";
+  /** root-relative (or package-relative) posix path. */
+  file: string;
+  line: number;
+}
+export declare function collect_flag_sites(code: string, id: string, file: string): FlagSite[];
+/** Stable, deduped (both build legs prescan) manifest shape. */
+export declare function flags_manifest(sites: readonly FlagSite[]): {
+  flags: FlagSite[];
+  names: string[];
+};

package/dist/compiler/flags.js

@@ -0,0 +1,101 @@
+import { parse_module } from "./parse/oxc.js";
+import { walk } from "estree-walker";
+// src/compiler/flags.ts
+/**
+* Flag/experiment INVENTORY — pure OBSERVATION during the prescan. Nothing is rewritten, so per
+* the macro law this is deliberately NOT an `import.meta.og.*` construct: the compiler only
+* REPORTS what it saw. The build writes the collected sites to
+* `node_modules/.ogygia/flags-manifest.json` — diff it in CI to catch flags that never die
+* (flag debt: the reason Uber built a whole refactoring bot; an inventory is the law-abiding
+* subset our file-local compiler can give for free).
+*
+* AST-walked, not text-matched (user ruling): `flag` is an ordinary function — a text sweep
+* would miss `import { flag as f }` and false-positive on any local function that happens to be
+* named `flag`. The walk resolves the module's ACTUAL bindings from `'@ogygia/flags'` (named, renamed,
+* or namespace imports) and only counts calls through those. Known pragmatic limit (same as the
+* macro family's): a local declaration SHADOWING an imported `flag` inside a nested scope is not
+* scope-analyzed.
+*/
+/** The import a flag site comes through. (Moves into the flags plugin's compile facet once the
+*  compile port lands: internal/notes/packages.md.) */
+const FLAGS_SPEC = "@ogygia/flags";
+const KINDS = /* @__PURE__ */ new Set(["flag"]);
+/** Cheap pre-parse gate — most modules import ogygia for other reasons. */
+const MAYBE_RE = /\bflag\b/;
+/** All `<script …>` blocks of a `.svelte` file (instance AND module — flags can sit in either). */
+const SCRIPT_BLOCK_RE = /<script\b[^>]*>([\s\S]*?)<\/script>/g;
+const NL = 10;
+function line_at(src, index, base_line) {
+	let line = base_line;
+	for (let i = 0; i < index; i++) if (src.charCodeAt(i) === NL) line++;
+	return line;
+}
+function string_arg(node) {
+	if (!node) return null;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	if (node.type === "StringLiteral" && typeof node.value === "string") return node.value;
+	return null;
+}
+/** Walk ONE parsed js/ts body. `base_line` positions a svelte script block inside its file. */
+function collect_from_source(src, id, file, base_line, out) {
+	const result = parse_module(src, id);
+	if (!result.ok || !result.program) return;
+	const locals = /* @__PURE__ */ new Map();
+	const namespaces = /* @__PURE__ */ new Set();
+	for (const node of result.program.body ?? []) {
+		if (node.type !== "ImportDeclaration") continue;
+		if (node.source?.value !== "@ogygia/flags") continue;
+		for (const s of node.specifiers ?? []) if (s.type === "ImportSpecifier") {
+			const imported = s.imported?.name;
+			if (KINDS.has(imported)) locals.set(s.local.name, imported);
+		} else if (s.type === "ImportNamespaceSpecifier") namespaces.add(s.local.name);
+	}
+	if (locals.size === 0 && namespaces.size === 0) return;
+	walk(result.program, { enter(n) {
+		const node = n;
+		if (node.type !== "CallExpression") return;
+		const callee = node.callee;
+		let kind;
+		if (callee?.type === "Identifier") kind = locals.get(callee.name);
+		else if (callee?.type === "MemberExpression" && callee.object?.type === "Identifier" && namespaces.has(callee.object.name) && callee.computed !== true && KINDS.has(callee.property?.name)) kind = callee.property.name;
+		if (!kind) return;
+		const name = string_arg(node.arguments?.[0]);
+		if (name == null) return;
+		out.push({
+			name,
+			kind,
+			file,
+			line: line_at(src, node.start ?? 0, base_line)
+		});
+	} });
+}
+function collect_flag_sites(code, id, file) {
+	if (!code.includes("ogygia") || !MAYBE_RE.test(code)) return [];
+	const out = [];
+	if (id.endsWith(".svelte")) {
+		SCRIPT_BLOCK_RE.lastIndex = 0;
+		let m;
+		while (m = SCRIPT_BLOCK_RE.exec(code)) {
+			const body_start = m.index + m[0].indexOf(">") + 1;
+			collect_from_source(m[1], id + ".ts", file, line_at(code, body_start, 1), out);
+		}
+	} else collect_from_source(code, id, file, 1, out);
+	return out;
+}
+/** Stable, deduped (both build legs prescan) manifest shape. */
+function flags_manifest(sites) {
+	const seen = /* @__PURE__ */ new Set();
+	const flags = [];
+	for (const s of sites) {
+		const k = `${s.kind}\0${s.name}\0${s.file}\0${s.line}`;
+		if (seen.has(k)) continue;
+		seen.add(k);
+		flags.push(s);
+	}
+	flags.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : a.file < b.file ? -1 : 1);
+	return {
+		flags,
+		names: [...new Set(flags.map((f) => f.name))].sort()
+	};
+}
+export { FLAGS_SPEC, collect_flag_sites, flags_manifest };

package/dist/compiler/fouc-css.d.ts

@@ -0,0 +1,97 @@
+export declare const FOUC_CSS_PREFIX = "virtual:ogygia/fouc-css/";
+export declare const FOUC_SCOPED_PREFIX = "virtual:ogygia/fouc-scoped/";
+/** @param relPosix */
+export declare function foucCssVirtualId(relPosix: string): string;
+/** @param relPosix */
+export declare function foucScopedVirtualId(relPosix: string): string;
+/** @param id */
+export declare function isFoucCssId(id: string): boolean;
+/** @param id */
+export declare function isFoucScopedId(id: string): boolean;
+/** @param id */
+export declare function foucRelFromId(id: string): string | null;
+/**
+ * Resolve a static import specifier against an importer file + `$lib`.
+ * @param spec
+ * @param importerAbs
+ * @param libDir
+ */
+/** One resolved Vite alias (`resolve.alias`, normalized) — Kit's `kit.alias` entries arrive here. */
+export interface FoucAlias {
+  find: string | RegExp;
+  replacement: string;
+}
+export declare function resolveFoucImportSpec(spec: string, importerAbs: string, libDir: string, alias?: readonly FoucAlias[]): string | null;
+/**
+ * Collect side-effect import specs that pull island CSS into the client graph without JS.
+ * @param entryAbs absolute path to the island entry `.svelte`
+ * @param opts
+ */
+export declare function buildFoucCssModuleSource(entryAbs: string, opts: CssReachOptions): Promise<string>;
+/**
+ * The transitive CSS-reachability walk under `buildFoucCssModuleSource`, exported on its own for the
+ * server-router CSS registry (link/router-css.ts): from a component entry, in DISCOVERY ORDER (the
+ * cascade order the aggregator has always imported in), every `.svelte` with a `<style>` block
+ * (`kind: 'scoped'`) and every plain style-file import (`kind: 'css'`) reachable through the
+ * component tree. Abs paths. Same resolution rules as the aggregator, so both stay in lockstep.
+ */
+export interface CssReachOptions {
+  root: string;
+  libDir: string;
+  readFile?: (p: string) => string | null;
+  /** app aliases to follow (`$lib_x/…`, `@scope/pkg/…` → source dirs) — the fallback resolver's */
+  alias?: readonly FoucAlias[];
+  /**
+   * The bundler's own resolver (Vite's `this.resolve`): a package specifier through its `exports`
+   * (a TypeScript entry included), a workspace link, an alias — whatever the build resolves. Without
+   * it (a unit test, a host with no bundler) `$lib`, relative paths and `alias` only.
+   */
+  resolve?: (spec: string, importer: string) => Promise<string | null>;
+}
+/**
+ * THE CSS A COMPONENT TREE REACHES — every `.svelte` with a `<style>` block (`kind: 'scoped'`) and
+ * every plain style-file import (`kind: 'css'`), in DISCOVERY ORDER (the cascade order the aggregator
+ * has always imported in). Abs paths.
+ *
+ * A subtree no client chunk carries (a server-only hole, a router page, a lake) gets its CSS from
+ * here, so this walk must reach what the bundler reaches — a component imported through a workspace
+ * package's TypeScript barrel came back unstyled: its specifier was not resolved, and a `.ts` module
+ * was a dead end. So:
+ * - specifiers resolve through the bundler's resolver (`opts.resolve`) when the build has one;
+ * - a `.svelte` file is a component: all of it renders, so every import of it is followed;
+ * - a script module is followed by the NAMES taken from it: through a barrel (the debarrel index —
+ *   nested barrels, `export *`), each name to its leaf, so a barrel of twenty components brings the
+ *   CSS of the two imported; a module with code of its own, every import it makes (its code may
+ *   render them). A dependency's own JavaScript (`node_modules`, not a barrel) is not walked: a
+ *   package ships compiled code, its components as `.svelte` files a barrel names.
+ */
+export declare function collectFoucCssReachable(entryAbs: string, opts: CssReachOptions): Promise<Array<{
+  kind: "scoped" | "css";
+  abs: string;
+}>>;
+/**
+ * Compile scoped CSS for a `.svelte` file (filename must match SSR for hash stability).
+ * @param abs
+ * @param source
+ */
+export declare function compileFoucScopedCss(abs: string, source: string, opts?: {
+  /** Keep the `<script>` (already free of TS/dialects): a template reading `$store` from an
+   *  imported store, or any script-declared name, only compiles WITH its script. Stripping it
+   *  throws on such a template and falls back to UNSCOPED style bodies — which match nothing
+   *  the SSR'd markup carries. Without it (a source that may still carry TypeScript), the
+   *  source is tried whole first (Svelte reads `lang="ts"` itself), then script-stripped. */
+  keepScript?: boolean;
+}): string;
+/** @param source */
+export declare function svelteHasStyle(source: string): boolean;
+/**
+ * Static import sources from a Svelte file's script blocks (default + side-effect).
+ * @param source
+ * @param filename
+ */
+/** A component's static imports: each specifier with the names it takes (`*` for a namespace;
+ *  none for a bare `import 'x'`). Type-only imports are left out: they bring nothing at runtime. */
+export declare function listStaticImports(source: string, filename: string): Array<{
+  source: string;
+  names: Set<string>;
+}>;

package/dist/compiler/fouc-css.js

@@ -0,0 +1,335 @@
+import { fs, path } from "./host.js";
+import { unscoped_marker } from "../unscoped-css.js";
+import { blank_styles } from "./blank-styles.js";
+import { BarrelIndex } from "./debarrel/barrel.js";
+import { analyze_exports, analyze_imports } from "./debarrel/parse.js";
+import { compile, parse } from "svelte/compiler";
+import { walk } from "estree-walker";
+// src/compiler/fouc-css.ts
+/**
+* csr=false FOUC without dual-owning island component JS.
+*
+* Kit only links stylesheets from the *client* page graph. Importing the authored `.svelte`
+* for that purpose (0.4.1) puts the same default-export module in the page graph and the
+* `emitFile` island entry → Rolldown thin-facades `og-region.*`.
+*
+* Hosts instead import `virtual:ogygia/fouc-css/<encoded>.js` which side-effect-imports:
+*   - plain `.css` files reachable from the entry
+*   - `virtual:ogygia/fouc-scoped/<encoded>.css` for each `.svelte` with a `<style>` block
+* Aggregator ids end in `.js` and scoped ids in `.css` so vite-plugin-svelte / Vite classify
+* them correctly (never as `.svelte` components). Scoped CSS is compiled with the real
+* filename so hashes match SSR.
+*/
+const FOUC_CSS_PREFIX = "virtual:ogygia/fouc-css/";
+const FOUC_SCOPED_PREFIX = "virtual:ogygia/fouc-scoped/";
+const PATH_SEP = /[/\\]/;
+const SCRIPT_TAG = /<script\b[^>]*>[\s\S]*?<\/script>/gi;
+const STYLE_OPEN = /<style\b/i;
+const STYLE_BODY = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+const STYLE_EXT = /\.(css|scss|sass|less|styl|stylus|pcss)(?:\?|$)/i;
+const SVELTE_EXT = /\.svelte(?:\?|$)/i;
+const IMPORT_SPEC = /import\s+(?:[\s\S]*?\s+from\s+)?["']([^"']+\.(?:svelte|css|scss|sass|less|styl|pcss)(?:\?[^"']*)?)["']/g;
+const WIN_DRIVE_RE = /^[a-zA-Z]:/;
+const PARENT_TRAVERSAL_RE = /(^|[\\/])\.\.([\\/]|$)/;
+/** @param relPosix */
+function foucCssVirtualId(relPosix) {
+	return FOUC_CSS_PREFIX + encodeURIComponent(relPosix.split(PATH_SEP).join("/")) + ".js";
+}
+/** @param relPosix */
+function foucScopedVirtualId(relPosix) {
+	return FOUC_SCOPED_PREFIX + encodeURIComponent(relPosix.split(PATH_SEP).join("/")) + ".css";
+}
+/** @param id */
+function isFoucCssId(id) {
+	const bare = id.startsWith("\0") ? id.slice(1) : id;
+	return bare.startsWith("virtual:ogygia/fouc-css/") && bare.endsWith(".js");
+}
+/** @param id */
+function isFoucScopedId(id) {
+	const bare = id.startsWith("\0") ? id.slice(1) : id;
+	return bare.startsWith("virtual:ogygia/fouc-scoped/") && bare.endsWith(".css");
+}
+/** @param id */
+function foucRelFromId(id) {
+	const bare = id.startsWith("\0") ? id.slice(1) : id;
+	let encoded = null;
+	if (bare.startsWith("virtual:ogygia/fouc-css/") && bare.endsWith(".js")) encoded = bare.slice(24, -3);
+	else if (bare.startsWith("virtual:ogygia/fouc-scoped/") && bare.endsWith(".css")) encoded = bare.slice(27, -4);
+	if (encoded == null) return null;
+	let rel;
+	try {
+		rel = decodeURIComponent(encoded);
+	} catch {
+		rel = encoded;
+	}
+	if (rel.startsWith("/") || rel.startsWith("\\") || WIN_DRIVE_RE.test(rel) || PARENT_TRAVERSAL_RE.test(rel)) return null;
+	return rel;
+}
+function resolveFoucImportSpec(spec, importerAbs, libDir, alias = []) {
+	if (spec === "$lib" || spec.startsWith("$lib/")) return path.join(libDir, spec === "$lib" ? "" : spec.slice(5));
+	if (spec.startsWith(".")) return path.resolve(path.dirname(importerAbs), spec);
+	for (const a of alias) if (typeof a.find === "string") {
+		if (spec === a.find) return a.replacement;
+		if (spec.startsWith(a.find + "/")) return a.replacement + spec.slice(a.find.length);
+	} else if (a.find.test(spec)) return spec.replace(a.find, a.replacement);
+	return null;
+}
+/**
+* Collect side-effect import specs that pull island CSS into the client graph without JS.
+* @param entryAbs absolute path to the island entry `.svelte`
+* @param opts
+*/
+async function buildFoucCssModuleSource(entryAbs, opts) {
+	const entries = await collectFoucCssReachable(entryAbs, opts);
+	const posix_rel = (abs) => path.relative(opts.root, abs).split(PATH_SEP).join("/");
+	const imports = [];
+	for (const e of entries) if (e.kind !== "scoped") imports.push(e.abs);
+	else {
+		const rel = posix_rel(e.abs);
+		if (!rel.startsWith("../") && !path.isAbsolute(rel)) imports.push(foucScopedVirtualId(rel));
+	}
+	if (imports.length === 0) return "export {}";
+	return imports.map((s) => `import ${JSON.stringify(s)};`).join("\n") + "\n";
+}
+const SCRIPT_MODULE_EXT = /\.(?:[cm]?[jt]sx?|svelte\.[jt]s)$/;
+const RESOLVE_SUFFIXES = [
+	"",
+	".ts",
+	".js",
+	"/index.ts",
+	"/index.js"
+];
+const NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
+/** every name a module exports — a namespace import, or a module reached for its own code */
+const ALL = "*";
+/** the barrel index of each bundler resolver (one per build's legs: see `collectFoucCssReachable`) */
+const barrel_indexes = /* @__PURE__ */ new WeakMap();
+/**
+* THE CSS A COMPONENT TREE REACHES — every `.svelte` with a `<style>` block (`kind: 'scoped'`) and
+* every plain style-file import (`kind: 'css'`), in DISCOVERY ORDER (the cascade order the aggregator
+* has always imported in). Abs paths.
+*
+* A subtree no client chunk carries (a server-only hole, a router page, a lake) gets its CSS from
+* here, so this walk must reach what the bundler reaches — a component imported through a workspace
+* package's TypeScript barrel came back unstyled: its specifier was not resolved, and a `.ts` module
+* was a dead end. So:
+* - specifiers resolve through the bundler's resolver (`opts.resolve`) when the build has one;
+* - a `.svelte` file is a component: all of it renders, so every import of it is followed;
+* - a script module is followed by the NAMES taken from it: through a barrel (the debarrel index —
+*   nested barrels, `export *`), each name to its leaf, so a barrel of twenty components brings the
+*   CSS of the two imported; a module with code of its own, every import it makes (its code may
+*   render them). A dependency's own JavaScript (`node_modules`, not a barrel) is not walked: a
+*   package ships compiled code, its components as `.svelte` files a barrel names.
+*/
+async function collectFoucCssReachable(entryAbs, opts) {
+	const read = opts.readFile || ((p) => {
+		try {
+			return fs.readFileSync(p, "utf8");
+		} catch {
+			return null;
+		}
+	});
+	const resolve = async (spec, importer) => {
+		if (opts.resolve) {
+			const id = await opts.resolve(spec, importer);
+			return id ? path.normalize(id.split("?")[0]) : null;
+		}
+		const base = resolveFoucImportSpec(spec, importer, opts.libDir, opts.alias);
+		if (!base) return null;
+		const clean = base.split("?")[0];
+		if (STYLE_EXT.test(clean) || SVELTE_EXT.test(clean)) return path.normalize(clean);
+		for (const suffix of RESOLVE_SUFFIXES) {
+			const candidate = path.normalize(clean + suffix);
+			if (read(candidate) != null) return candidate;
+		}
+		return null;
+	};
+	let barrels = opts.resolve ? barrel_indexes.get(opts.resolve) : void 0;
+	if (!barrels) {
+		barrels = new BarrelIndex({
+			read: (id) => read(id),
+			resolve: (spec, importer) => resolve(spec, importer),
+			candidate: () => true,
+			forced: () => false,
+			kept: () => false,
+			follow_packages: true
+		});
+		if (opts.resolve) barrel_indexes.set(opts.resolve, barrels);
+	}
+	const entries = [];
+	const seen_css = /* @__PURE__ */ new Set();
+	const seen_svelte = /* @__PURE__ */ new Set();
+	/** script module → the names already followed (`*`: all of them) */
+	const seen_names = /* @__PURE__ */ new Map();
+	const visit = async (abs, names, spec) => {
+		if (STYLE_EXT.test(abs)) {
+			if (!seen_css.has(abs)) {
+				seen_css.add(abs);
+				entries.push({
+					kind: "css",
+					abs
+				});
+			}
+		} else if (SVELTE_EXT.test(abs)) await visit_svelte(abs);
+		else if (SCRIPT_MODULE_EXT.test(abs)) await visit_script(abs, names, spec);
+	};
+	const follow = async (decls, importer) => {
+		for (const d of decls) {
+			const resolved = await resolve(d.source, importer);
+			if (resolved) await visit(resolved, d.names, d.source);
+		}
+	};
+	const visit_svelte = async (abs) => {
+		if (seen_svelte.has(abs)) return;
+		seen_svelte.add(abs);
+		const source = read(abs);
+		if (source == null) return;
+		if (svelteHasStyle(source)) entries.push({
+			kind: "scoped",
+			abs
+		});
+		await follow(listStaticImports(source, abs), abs);
+	};
+	const visit_script = async (abs, names, spec) => {
+		let done = seen_names.get(abs);
+		if (!done) seen_names.set(abs, done = /* @__PURE__ */ new Set());
+		if (done.has(ALL)) return;
+		const wanted = names.has(ALL) ? [ALL] : [...names].filter((n) => !done.has(n));
+		if (!wanted.length) return;
+		for (const n of wanted) done.add(n);
+		const map = await barrels.map(abs, spec);
+		if (map && !wanted.includes(ALL)) {
+			const own = [];
+			for (const n of wanted) {
+				const entry = map.entries.get(n);
+				if (entry && typeof entry === "object") await visit(entry.id, /* @__PURE__ */ new Set(["namespace" in entry ? ALL : entry.name]), entry.id);
+				else own.push(n);
+			}
+			if (!own.length && !map.opaque) return;
+		}
+		if (NODE_MODULES_RE.test(abs)) return;
+		const code = read(abs);
+		if (code == null) return;
+		const decls = analyze_imports(code, abs);
+		if (!decls) return;
+		await follow(decls.filter((d) => !d.type_only).map((d) => ({
+			source: d.source,
+			names: new Set(d.side_effect ? [] : d.specs.filter((s) => !s.type_only).map((s) => s.kind === "namespace" ? ALL : s.imported))
+		})), abs);
+		const shape = analyze_exports(code, abs);
+		if (shape) await follow(shape.exports.flatMap((e) => e.kind === "reexport" && !e.type_only ? [{
+			source: e.source,
+			names: /* @__PURE__ */ new Set([e.imported])
+		}] : e.kind === "star" && !e.type_only ? [{
+			source: e.source,
+			names: /* @__PURE__ */ new Set([ALL])
+		}] : e.kind === "star_ns" ? [{
+			source: e.source,
+			names: /* @__PURE__ */ new Set([ALL])
+		}] : []), abs);
+	};
+	await visit_svelte(path.normalize(entryAbs));
+	return entries;
+}
+/**
+* Compile scoped CSS for a `.svelte` file (filename must match SSR for hash stability).
+* @param abs
+* @param source
+*/
+function compileFoucScopedCss(abs, source, opts = {}) {
+	const inputs = opts.keepScript ? [source] : [source, source.replace(SCRIPT_TAG, "")];
+	let err;
+	for (const input of inputs) try {
+		return compile(input, {
+			filename: abs,
+			generate: "client",
+			css: "external",
+			discloseVersion: false,
+			experimental: { async: true }
+		}).css?.code ?? "";
+	} catch (e) {
+		err ??= e;
+	}
+	const why = err.message.split("\n")[0];
+	if (opts.keepScript) console.warn(`[ogygia] scoped CSS for ${abs} could not be compiled (${why}) — shipping its style bodies unscoped`);
+	const raw = extractRawStyleBodies(source);
+	return raw ? unscoped_marker(abs, why) + raw : raw;
+}
+/** @param source */
+function svelteHasStyle(source) {
+	return STYLE_OPEN.test(source);
+}
+/**
+* Unwrap `:global(SELECTOR)` → `SELECTOR`. `:global(...)` is a Svelte construct, not CSS — left
+* literal in a raw style body (the fallback below never runs the Svelte compiler) the browser drops
+* the whole rule. This fallback already ships styles UNSCOPED, so a global-wrapped selector is just
+* the selector. Balanced-paren scan so `:global(x:not(.y))` unwraps to `x:not(.y)`, not `x:not(.y`.
+*/
+function unwrap_global(css) {
+	let out = "";
+	let i = 0;
+	while (i < css.length) {
+		const at = css.indexOf(":global(", i);
+		if (at === -1) {
+			out += css.slice(i);
+			break;
+		}
+		out += css.slice(i, at);
+		let depth = 1;
+		let j = at + 8;
+		for (; j < css.length && depth > 0; j++) if (css[j] === "(") depth++;
+		else if (css[j] === ")") depth--;
+		out += css.slice(at + 8, j - 1);
+		i = j;
+	}
+	return out;
+}
+/** @param source */
+function extractRawStyleBodies(source) {
+	return unwrap_global([...source.matchAll(STYLE_BODY)].map((m) => m[1]).join("\n"));
+}
+/**
+* Static import sources from a Svelte file's script blocks (default + side-effect).
+* @param source
+* @param filename
+*/
+/** A component's static imports: each specifier with the names it takes (`*` for a namespace;
+*  none for a bare `import 'x'`). Type-only imports are left out: they bring nothing at runtime. */
+function listStaticImports(source, filename) {
+	const out = [];
+	try {
+		const ast = parse(blank_styles(source), {
+			filename,
+			modern: true
+		});
+		const scripts = [ast.instance, ast.module].filter(Boolean);
+		for (const block of scripts) {
+			const content = block?.content;
+			if (!content || content.type !== "Program") continue;
+			walk(content, { enter(node) {
+				if (node.type !== "ImportDeclaration") return;
+				const decl = node;
+				const src = decl.source?.value;
+				if (typeof src !== "string" || decl.importKind === "type") return;
+				const names = /* @__PURE__ */ new Set();
+				for (const s of decl.specifiers ?? []) {
+					if (s.importKind === "type") continue;
+					if (s.type === "ImportDefaultSpecifier") names.add("default");
+					else if (s.type === "ImportNamespaceSpecifier") names.add(ALL);
+					else names.add(s.imported?.name ?? s.imported?.value ?? ALL);
+				}
+				out.push({
+					source: src,
+					names
+				});
+			} });
+		}
+	} catch {
+		for (const m of source.matchAll(IMPORT_SPEC)) out.push({
+			source: m[1],
+			names: /* @__PURE__ */ new Set([ALL])
+		});
+	}
+	return out;
+}
+export { FOUC_CSS_PREFIX, FOUC_SCOPED_PREFIX, buildFoucCssModuleSource, collectFoucCssReachable, compileFoucScopedCss, foucCssVirtualId, foucRelFromId, foucScopedVirtualId, isFoucCssId, isFoucScopedId, listStaticImports, resolveFoucImportSpec, svelteHasStyle };

package/dist/compiler/free-vars.d.ts

@@ -0,0 +1,20 @@
+import { SvelteNode } from "./region/ir.js";
+/** Collect all snippet names defined anywhere in a subtree (for cross-boundary error detection). */
+export declare function collectSnippetNames(nodes: SvelteNode[]): Set<unknown>;
+/**
+ * @param nodes hoisted subtree top-level nodes
+ * @returns free identifier names + free mutation targets + `$store` read sites
+ */
+export declare function collectCaptureInfo(nodes: SvelteNode[]): {
+  free: Set<string>;
+  mutated: Set<string>;
+  stores: Map<string, {
+    start: number;
+    end: number;
+  }[]>;
+};
+/**
+ * @param nodes hoisted subtree top-level nodes
+ * @returns free identifier names
+ */
+export declare function collectFreeIdentifiers(nodes: SvelteNode[]): Set<string>;