@ogygia/core 0.0.0 → 0.11.0

package/dist/vite/profiler-maps.js

@@ -0,0 +1,178 @@
+import { PROFILER_MAPS_PLACEHOLDER } from "../compiler/ids.js";
+import { build_module_map } from "./module-map.js";
+import { client_maps_stash } from "./server-sourcemaps.js";
+import fs from "node:fs";
+import path from "node:path";
+import zlib from "node:zlib";
+// src/vite/profiler-maps.ts
+/**
+* THE PROFILER'S MAPS, WRITTEN INTO THE CODE: after the server build has written its chunks (and
+* their hidden `.map` files), the module that `virtual:ogygia/profiler-maps` became gets one JSON
+* string in place of its placeholder: the module map (which source module sits at which lines of each
+* chunk) and every chunk's sourcemap, by chunk file.
+*
+* Why in the code: an adapter copies what the server code imports, not files read by path. Vercel's
+* traces imports (the `.map` files and `ogygia-modules.json` are left behind); adapter-node re-bundles
+* the chunks with maps of its own that point back at chunks it does not ship. A dynamic import rides
+* every adapter; the profiler loads it only when it resolves a frame, so a request pays nothing.
+*/
+function fill_profiler_maps(dir, bundle, root) {
+	const chunks = Object.values(bundle).filter((x) => x.type === "chunk" && typeof x.fileName === "string");
+	const quoted = [`"${PROFILER_MAPS_PLACEHOLDER}"`, `'${PROFILER_MAPS_PLACEHOLDER}'`];
+	let target;
+	for (const c of chunks) {
+		const file = path.join(dir, c.fileName);
+		let code;
+		try {
+			code = fs.readFileSync(file, "utf8");
+		} catch {
+			continue;
+		}
+		if (quoted.some((q) => code.includes(q))) {
+			target = {
+				file,
+				code
+			};
+			break;
+		}
+	}
+	if (!target) return false;
+	const maps = {};
+	const src = path.join(root, "src") + path.sep;
+	/** chunks the build wrote no map for */
+	const mapless = /* @__PURE__ */ new Set();
+	for (const c of chunks) {
+		const file = path.join(dir, c.fileName);
+		if (file === target.file) continue;
+		let raw;
+		try {
+			raw = fs.readFileSync(file + ".map", "utf8");
+		} catch {
+			mapless.add(c.fileName);
+			continue;
+		}
+		const slim = slim_map(raw, path.dirname(file), src);
+		if (slim !== void 0) maps[c.fileName] = slim;
+	}
+	const client_dir = path.join(dir, "..", "client");
+	const stash = client_maps_stash(client_dir);
+	for (const rel of list_maps(stash)) {
+		let raw;
+		try {
+			raw = fs.readFileSync(path.join(stash, rel), "utf8");
+		} catch {
+			continue;
+		}
+		const chunk = rel.slice(0, -4);
+		const at = path.join(client_dir, chunk);
+		if (!maps_app_code(raw, path.dirname(at), src)) continue;
+		const slim = slim_map(raw, path.dirname(at), src);
+		if (slim !== void 0) maps["client/" + chunk.split(path.sep).join("/")] = slim;
+	}
+	fs.rmSync(stash, {
+		recursive: true,
+		force: true
+	});
+	const on_disk = {};
+	for (const [k, v] of Object.entries(bundle)) {
+		const c = v;
+		if (c.type !== "chunk" || !c.fileName) {
+			on_disk[k] = v;
+			continue;
+		}
+		let code = c.code;
+		try {
+			code = fs.readFileSync(path.join(dir, c.fileName), "utf8");
+		} catch {}
+		on_disk[k] = {
+			...c,
+			code
+		};
+	}
+	const modules = build_module_map(on_disk, root).chunks;
+	const sources = {};
+	const texts = {};
+	for (const chunk of mapless) {
+		let app = false;
+		for (const [, , id] of modules[chunk] ?? []) {
+			if (!id.startsWith("src/") || is_data(id)) continue;
+			app = true;
+			if (id in sources) continue;
+			try {
+				sources[id] = fs.readFileSync(path.join(root, id), "utf8");
+			} catch {}
+		}
+		const code = on_disk[chunk]?.code;
+		if (app && typeof code === "string") texts[chunk] = code;
+	}
+	const payload = {
+		v: 1,
+		modules,
+		maps,
+		...Object.keys(sources).length ? { sources } : {},
+		...Object.keys(texts).length ? { chunks: texts } : {}
+	};
+	const literal = JSON.stringify("gz:" + zlib.gzipSync(JSON.stringify(payload), { level: 9 }).toString("base64"));
+	let code = target.code;
+	for (const q of quoted) code = code.split(q).join(literal);
+	fs.writeFileSync(target.file, code);
+	return true;
+}
+const is_data = (source) => source.endsWith(".json");
+/** every `.map` under `dir`, relative to it (none when it does not exist) */
+function list_maps(dir) {
+	const out = [];
+	const walk = (d) => {
+		let entries;
+		try {
+			entries = fs.readdirSync(d, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const e of entries) {
+			const p = path.join(d, e.name);
+			if (e.isDirectory()) walk(p);
+			else if (e.name.endsWith(".map")) out.push(path.relative(dir, p));
+		}
+	};
+	walk(dir);
+	return out;
+}
+/** does this map's code come (in part) from the app's own files (a source under `src`) */
+function maps_app_code(raw, chunk_dir, src) {
+	try {
+		const map = JSON.parse(raw);
+		const root = typeof map.sourceRoot === "string" ? map.sourceRoot : "";
+		return Array.isArray(map.sources) && map.sources.some((s) => typeof s === "string" && path.resolve(chunk_dir, root + s).startsWith(src));
+	} catch {
+		return false;
+	}
+}
+/**
+* A CHUNK'S MAP, CUT TO WHAT THE PROFILER READS: the mappings and names whole (every frame's line
+* and name), the source TEXT only for the app's own code files — what the source checks read on a
+* host without `src/` (a load line by line, a component's `{#each}`, a late island's data). A
+* package's text and imported data (`.json`: no function runs on its lines) are the bulk of a real
+* app's maps and never read there. Undefined for a map of data alone (nothing to name).
+*/
+function slim_map(raw, chunk_dir, src) {
+	let map;
+	try {
+		map = JSON.parse(raw);
+	} catch {
+		return;
+	}
+	const sources = map.sources ?? [];
+	if (sources.length > 0 && sources.every(is_data)) return void 0;
+	if (Array.isArray(map.sourcesContent)) {
+		const root = map.sourceRoot ?? "";
+		map.sourcesContent = sources.map((s, i) => {
+			const text = map.sourcesContent?.[i];
+			if (typeof text !== "string" || is_data(s)) return null;
+			const abs = path.resolve(chunk_dir, root + s);
+			return abs.startsWith(src) && !abs.includes(`${path.sep}node_modules${path.sep}`) ? text : null;
+		});
+	}
+	return JSON.stringify(map);
+}
+export { fill_profiler_maps, slim_map };

package/dist/vite/server-sourcemaps.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from "vite";
+/** where the client build's maps are kept, off the served output: `<kit outDir>/ogygia-client-maps` */
+export declare const CLIENT_MAPS_DIR = "ogygia-client-maps";
+/** `<kit outDir>/output/client` → `<kit outDir>/ogygia-client-maps` */
+export declare function client_maps_stash(client_dir: string): string;
+/** `measuring()`: a plugin asked for the build's measurement data (read when the config resolves,
+ *  after ogygia's own `config` ran the plugins' build hooks). */
+export declare function server_sourcemaps_plugin(measuring: () => boolean): Plugin;

package/dist/vite/server-sourcemaps.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import path from "node:path";
+// src/vite/server-sourcemaps.ts
+/**
+* PROFILER ON → the SERVER build writes hidden sourcemaps: `.map` files beside the server chunks, no
+* `//# sourceMappingURL` comment. They stay on the server (a browser never loads a server chunk),
+* and the profiler reads `<chunk>.map` to name every line by its source — a load's lines, a
+* component's markup, where a late island's data is fetched — on the host that runs the build
+* (Amplify, Lambda).
+*
+* After Kit's own config hook (`order: 'post'`): that is where Kit marks the build as the server one.
+* Kit then starts the CLIENT build with the server's `sourcemap` setting copied in. Maps left in the
+* client output would be served to anyone, so the client build keeps them hidden and MOVES them out
+* of its output the moment it has written it — into `.svelte-kit/ogygia-client-maps/`, which no
+* adapter copies. The server build (whose writeBundle ran this client build, and whose closeBundle
+* comes before Kit's adapter) then embeds the app's own ones into the profiler's maps module
+* (vite/profiler-maps.ts): the browser's CPU traces name the app's functions by their source line.
+* An app's own `build.sourcemap` choice wins both ways (its maps are its to serve, or not to make).
+*/
+/** app roots whose server build THIS process gave hidden maps (Kit's client build runs as a second
+*  `vite.build` with fresh plugin instances, in the same process; two apps built in one process each
+*  keep their own answer) */
+const SERVER_MAPS = Symbol.for("ogygia.server-hidden-maps");
+/** where the client build's maps are kept, off the served output: `<kit outDir>/ogygia-client-maps` */
+const CLIENT_MAPS_DIR = "ogygia-client-maps";
+/** `<kit outDir>/output/client` → `<kit outDir>/ogygia-client-maps` */
+function client_maps_stash(client_dir) {
+	return path.join(client_dir, "..", "..", CLIENT_MAPS_DIR);
+}
+/** `measuring()`: a plugin asked for the build's measurement data (read when the config resolves,
+*  after ogygia's own `config` ran the plugins' build hooks). */
+function server_sourcemaps_plugin(measuring) {
+	const g = globalThis;
+	/** this instance is the client build of a server build that got hidden maps from us */
+	let client_ours = false;
+	return {
+		name: "ogygia:server-sourcemaps",
+		config: {
+			order: "post",
+			handler(config, env) {
+				if (!measuring() || env.command !== "build") return;
+				const ours = g[SERVER_MAPS] ??= /* @__PURE__ */ new Set();
+				const root = path.resolve(config.root ?? ".");
+				if (config.build?.ssr) {
+					ours.delete(root);
+					if (config.build.sourcemap !== void 0) return;
+					ours.add(root);
+					return { build: { sourcemap: "hidden" } };
+				}
+				if (ours.has(root) && config.build?.sourcemap === "hidden") client_ours = true;
+			}
+		},
+		writeBundle: {
+			order: "post",
+			sequential: true,
+			handler(options, bundle) {
+				if (!client_ours || !options.dir) return;
+				const stash = client_maps_stash(options.dir);
+				fs.rmSync(stash, {
+					recursive: true,
+					force: true
+				});
+				const maps = /* @__PURE__ */ new Set();
+				for (const file of Object.keys(bundle)) maps.add(file.endsWith(".map") ? file : file + ".map");
+				for (const file of maps) {
+					const from = path.join(options.dir, file);
+					if (!fs.existsSync(from)) continue;
+					const to = path.join(stash, file);
+					try {
+						fs.mkdirSync(path.dirname(to), { recursive: true });
+						fs.renameSync(from, to);
+					} catch {
+						fs.rmSync(from, { force: true });
+					}
+				}
+			}
+		}
+	};
+}
+export { CLIENT_MAPS_DIR, client_maps_stash, server_sourcemaps_plugin };

package/dist/vite/sourcemaps.d.ts

@@ -0,0 +1,18 @@
+import { Program } from "../compiler/program.js";
+import { Plugin } from "vite";
+/**
+ * Rewrite vite-plugin-svelte island sourcemap `sources` so Vite treats them as virtual.
+ *
+ * Svelte emits the basename of `virtual:ogygia/island/<id>.svelte` (just `<id>.svelte`).
+ * That string does not match Vite's `virtualSourceRE`, so `injectSourcesContent` tries a
+ * disk read and warns "points to missing source files". Pointing sources back at the
+ * full virtual module id silences the warning (and keeps maps coherent).
+ *
+ * @internal Also covered by unit tests.
+ */
+export declare function rewrite_island_sourcemap_sources(moduleId: string, sources: (string | null)[] | undefined): (string | null)[] | null;
+/** The `ogygia:island-sourcemaps` post plugin (Vite flattens it into the adapter's array). */
+export declare function island_sourcemaps_plugin(deps: {
+  program: Program;
+  is_island_path: (id: string) => boolean;
+}): Plugin;

package/dist/vite/sourcemaps.js

@@ -0,0 +1,80 @@
+import { strip_id } from "../compiler/program.js";
+import path from "node:path";
+// src/vite/sourcemaps.ts
+/**
+* The island-sourcemap sub-plugin — the irreducibly-Vite half of the sourcemap fix (it needs
+* `this.getCombinedSourcemap`). Split out of the adapter's returned array as a factory taking the
+* two things it reads: the `Program` (for the registry row's generated source) and the adapter's
+* `is_island_path` predicate. Kept in `vite/` because it is a Vite `Plugin`, not a driver phase.
+*/
+/**
+* Rewrite vite-plugin-svelte island sourcemap `sources` so Vite treats them as virtual.
+*
+* Svelte emits the basename of `virtual:ogygia/island/<id>.svelte` (just `<id>.svelte`).
+* That string does not match Vite's `virtualSourceRE`, so `injectSourcesContent` tries a
+* disk read and warns "points to missing source files". Pointing sources back at the
+* full virtual module id silences the warning (and keeps maps coherent).
+*
+* @internal Also covered by unit tests.
+*/
+function rewrite_island_sourcemap_sources(moduleId, sources) {
+	if (!sources?.length) return null;
+	let changed = false;
+	const next = sources.map((s) => {
+		if (typeof s !== "string") return s;
+		if (s === moduleId || s.startsWith("virtual:") || s.includes("\0")) return s;
+		if (s.endsWith(".svelte") && !s.includes("/") && !path.isAbsolute(s)) {
+			changed = true;
+			return moduleId;
+		}
+		return s;
+	});
+	return changed ? next : null;
+}
+/** The `ogygia:island-sourcemaps` post plugin (Vite flattens it into the adapter's array). */
+function island_sourcemaps_plugin(deps) {
+	const { program, is_island_path } = deps;
+	return {
+		name: "ogygia:island-sourcemaps",
+		enforce: "post",
+		transform(code, id) {
+			const bare = strip_id(id);
+			if (!is_island_path(bare)) return null;
+			if (bare.includes("/wrapper/")) return {
+				code,
+				map: { mappings: "" }
+			};
+			let map;
+			try {
+				map = this.getCombinedSourcemap();
+			} catch {
+				return null;
+			}
+			if (!map?.mappings || !map.sources?.length) return null;
+			const rewritten = rewrite_island_sourcemap_sources(bare, map.sources);
+			const sources = rewritten ?? map.sources;
+			const entry = program.registry.get(bare);
+			const base_name = bare.slice(bare.lastIndexOf("/") + 1);
+			let injected = false;
+			const sourcesContent = sources.map((s, i) => {
+				const prev = Array.isArray(map.sourcesContent) ? map.sourcesContent[i] : null;
+				if (prev != null) return prev;
+				if (entry && (s === bare || s === base_name)) {
+					injected = true;
+					return entry.source;
+				}
+				return null;
+			});
+			if (!rewritten && !injected) return null;
+			return {
+				code,
+				map: {
+					...map,
+					sources,
+					sourcesContent
+				}
+			};
+		}
+	};
+}
+export { island_sourcemaps_plugin, rewrite_island_sourcemap_sources };

package/dist/vite/style-preprocess.d.ts

@@ -0,0 +1,2 @@
+/** `source` with `<style lang="scss|sass">` compiled to CSS and `<script lang="ts">` stripped of TS. */
+export declare function preprocess_component_for_css(source: string, abs: string, root: string): Promise<string>;

package/dist/vite/style-preprocess.js

@@ -0,0 +1,96 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+// src/vite/style-preprocess.ts
+/**
+* A component source made compilable by `svelte.compile` alone, for the build-time tree-CSS
+* collection (`compileFoucScopedCss`): `<style lang="scss|sass">` compiled to CSS, `<script
+* lang="ts">` stripped of TypeScript. The compiler reads neither dialect; without this step such a
+* component's scoped CSS compiles to nothing (or ships raw and unscoped) and a server-rendered
+* subtree styled that way goes unstyled.
+*
+* Node-only (this is the Vite leg): `sass-embedded` or `sass` is resolved from the APP root, the
+* way vitePreprocess finds it (neither installed → the block is left as is, one warning); TS is
+* stripped with Vite's own transform (oxc on Vite ≥ 8, esbuild before).
+*/
+const STYLE_BLOCK_G = /<style\b([^>]*)>([\s\S]*?)<\/style>/gi;
+const SCRIPT_BLOCK_G = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
+const STYLE_LANG_ATTR = /\blang\s*=\s*["']?(scss|sass)["']?/i;
+const SCRIPT_LANG_TS_ATTR = /\blang\s*=\s*["']?ts["']?/i;
+let sass;
+let sass_warned = false;
+let transform;
+function load_sass(root) {
+	if (sass !== void 0) return sass;
+	const require = createRequire(path.join(root, "package.json"));
+	for (const name of ["sass-embedded", "sass"]) try {
+		sass = require(name);
+		return sass;
+	} catch {}
+	sass = null;
+	return sass;
+}
+async function load_ts_transform() {
+	if (transform !== void 0) return transform;
+	const vite = await import("vite");
+	const oxc = vite.transformWithOxc;
+	const esbuild = vite.transformWithEsbuild;
+	transform = oxc ? (code, id) => oxc(code, id, {
+		lang: "ts",
+		typescript: { onlyRemoveTypeImports: true }
+	}) : esbuild ? (code, id) => esbuild(code, id, {
+		loader: "ts",
+		target: "esnext",
+		tsconfigRaw: { compilerOptions: { verbatimModuleSyntax: true } }
+	}) : null;
+	return transform;
+}
+/** `source` with `<style lang="scss|sass">` compiled to CSS and `<script lang="ts">` stripped of TS. */
+async function preprocess_component_for_css(source, abs, root) {
+	let out = source;
+	if (STYLE_LANG_ATTR.test(out)) {
+		const compiler = load_sass(root);
+		if (!compiler) {
+			if (!sass_warned) {
+				sass_warned = true;
+				console.warn("[ogygia] a server-rendered component has `<style lang=\"scss\">` but neither `sass-embedded` nor `sass` is installed — its hole/router CSS ships unprocessed");
+			}
+		} else out = out.replace(STYLE_BLOCK_G, (whole, attrs, body) => {
+			const lang = STYLE_LANG_ATTR.exec(attrs)?.[1]?.toLowerCase();
+			if (!lang) return whole;
+			try {
+				const { css } = compiler.compileString(body, {
+					syntax: lang === "sass" ? "indented" : "scss",
+					loadPaths: [
+						path.dirname(abs),
+						root,
+						path.join(root, "node_modules")
+					],
+					quietDeps: true,
+					silenceDeprecations: ["import"]
+				});
+				return `<style${attrs.replace(STYLE_LANG_ATTR, "")}>${css}</style>`;
+			} catch (err) {
+				console.warn(`[ogygia] ${path.relative(root, abs)}: scss compile failed — ${err.message}`);
+				return whole;
+			}
+		});
+	}
+	if (SCRIPT_LANG_TS_ATTR.test(out)) {
+		const ts = await load_ts_transform();
+		if (ts) {
+			const blocks = [...out.matchAll(SCRIPT_BLOCK_G)];
+			for (const m of blocks) {
+				const [whole, attrs, body] = m;
+				if (!SCRIPT_LANG_TS_ATTR.test(attrs)) continue;
+				try {
+					const { code } = await ts(body, abs + ".ts");
+					out = out.replace(whole, `<script${attrs}>${code}<\/script>`);
+				} catch (err) {
+					console.warn(`[ogygia] ${path.relative(root, abs)}: TypeScript strip failed — ${err.message}`);
+				}
+			}
+		}
+	}
+	return out;
+}
+export { preprocess_component_for_css };

package/package.json

@@ -1,7 +1,181 @@
 {
-	"name": "@ogygia/core",
-	"version": "0.0.0",
-	"description": "Reserved for ogygia. The first release is on its way: https://ogygia.puruvj.dev",
-	"license": "MIT",
-	"repository": { "type": "git", "url": "git+https://github.com/ogygiajs/ogygia.git", "directory": "packages/core" }
-}
+  "name": "@ogygia/core",
+  "version": "0.11.0",
+  "description": "The core of ogygia (SSR islands for SvelteKit): apps install `ogygia`, plugins build on this",
+  "homepage": "https://ogygiajs.dev",
+  "bugs": {
+    "url": "https://github.com/ogygiajs/ogygia/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ogygiajs/ogygia.git",
+    "directory": "packages/core"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "ambient.d.ts"
+  ],
+  "type": "module",
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./vite": {
+      "types": "./dist/vite/index.d.ts",
+      "default": "./dist/vite/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "default": "./dist/runtime/index.js"
+    },
+    "./hooks": {
+      "types": "./dist/hooks.d.ts",
+      "default": "./dist/hooks.js"
+    },
+    "./app": {
+      "types": "./dist/app.d.ts",
+      "default": "./dist/app.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "svelte": "./dist/internal.js",
+      "default": "./dist/internal.js"
+    },
+    "./internal/server": {
+      "types": "./dist/internal-server.d.ts",
+      "svelte": "./dist/internal-server.js",
+      "default": "./dist/internal-server.js"
+    },
+    "./internal/instruments": {
+      "types": "./dist/internal-instruments.d.ts",
+      "svelte": "./dist/internal-instruments.js",
+      "default": "./dist/internal-instruments.js"
+    },
+    "./internal/register": {
+      "types": "./dist/internal-register.d.ts",
+      "svelte": "./dist/internal-register.js",
+      "default": "./dist/internal-register.js"
+    },
+    "./internal/compiler-ids": {
+      "types": "./dist/compiler/ids.d.ts",
+      "svelte": "./dist/compiler/ids.js",
+      "default": "./dist/compiler/ids.js"
+    },
+    "./internal/region-core": {
+      "types": "./dist/region-core.d.ts",
+      "svelte": "./dist/region-core.js",
+      "default": "./dist/region-core.js"
+    },
+    "./internal/reconcile": {
+      "types": "./dist/internal-reconcile.d.ts",
+      "svelte": "./dist/internal-reconcile.js",
+      "default": "./dist/internal-reconcile.js"
+    },
+    "./server": {
+      "types": "./dist/hooks.d.ts",
+      "default": "./dist/hooks.js"
+    },
+    "./markup": {
+      "types": "./dist/markup.d.ts",
+      "default": "./dist/markup.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin/index.d.ts",
+      "default": "./dist/plugin/index.js"
+    },
+    "./plugin/utils": {
+      "types": "./dist/plugin/utils.d.ts",
+      "default": "./dist/plugin/utils.js"
+    },
+    "./plugin/css": {
+      "types": "./dist/plugin/css.d.ts",
+      "default": "./dist/plugin/css.js"
+    },
+    "./plugin/testing": {
+      "types": "./dist/plugin/testing.d.ts",
+      "default": "./dist/plugin/testing.js"
+    },
+    "./plugin/client": {
+      "types": "./dist/plugin/client.d.ts",
+      "default": "./dist/plugin/client.js"
+    },
+    "./events": {
+      "types": "./dist/events/index.d.ts",
+      "default": "./dist/events/index.js"
+    },
+    "./insights": {
+      "types": "./dist/insights/index.d.ts",
+      "default": "./dist/insights/index.js"
+    },
+    "./internal/compiler": {
+      "types": "./dist/compiler/index.d.ts",
+      "default": "./dist/compiler/index.js"
+    },
+    "./types": {
+      "types": "./ambient.d.ts"
+    },
+    "./internal/compiler-browser": {
+      "types": "./dist/compiler/browser.d.ts",
+      "default": "./dist/compiler/browser.js"
+    },
+    "./internal/compiler-browser-full": {
+      "types": "./dist/compiler/browser-full.d.ts",
+      "default": "./dist/compiler/browser-full.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "devalue": "^5.9.3",
+    "esm-env": "^1.2.2",
+    "estree-walker": "^3.0.3",
+    "magic-string": "^1.4.5",
+    "tinyglobby": "^0.2.17"
+  },
+  "devDependencies": {
+    "@sveltejs/kit": "^2.70.2",
+    "@sveltejs/vite-plugin-svelte": "^7.2.0",
+    "@types/node": "^26.1.2",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "@vitest/browser": "4.1.12",
+    "@vitest/browser-playwright": "4.1.12",
+    "rolldown": "^1.2.2",
+    "sass-embedded": "^1.104.1",
+    "svelte": "5.56.8",
+    "svelte-check": "^4.7.4",
+    "svelte2tsx": "^0.7.60",
+    "tsdown": "^0.23.4",
+    "typescript": "^6.0.3",
+    "valibot": "^1.4.2",
+    "vite": "^8.3.5",
+    "vitest": "^4.1.12",
+    "@ogygia/tsdown-plugin-svelte": "1.1.0"
+  },
+  "peerDependencies": {
+    "@sveltejs/kit": ">=2.70.2 <4",
+    "rolldown": ">=1.0.0",
+    "svelte": "^5.56.8",
+    "vite": "^8.2.4"
+  },
+  "peerDependenciesMeta": {
+    "rolldown": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:node": "vitest run --project node",
+    "test:browser": "vitest run --project browser",
+    "check": "tsc --noEmit && svelte-check --tsconfig ./tsconfig.check.json --fail-on-warnings && tsc -p test && vitest run",
+    "verify:package": "node scripts/verify-package.ts"
+  }
+}