@ogygia/core 0.0.0 → 0.11.1

package/dist/Region.svelte.d.ts

@@ -0,0 +1,68 @@
+export default Region;
+type Region = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<{
+        of?: RegionValue | Promise<RegionValue> | undefined;
+        placeholder?: Snippet<[]> | undefined;
+        children?: Snippet<[]> | undefined;
+        __mode?: "server" | "island" | "lake" | undefined;
+        __baked?: boolean | undefined;
+        visible?: string | boolean | undefined;
+        idle?: boolean | undefined;
+        media?: string | undefined;
+        load?: boolean | undefined;
+        interaction?: boolean | undefined;
+        __keep?: string | undefined;
+        __entry?: string | undefined;
+        __src?: string | undefined;
+        __component?: Component<any, any, string> | undefined;
+        __css?: unknown;
+        __load?: (() => Promise<Component<any, any, string>>) | undefined;
+        __props?: Record<string, unknown> | undefined;
+        __defer?: string | undefined;
+        __margin?: string | undefined;
+        __hydrate?: string | undefined;
+        __hydrateMargin?: string | undefined;
+        __module?: string | undefined;
+        __cacheTtl?: number | undefined;
+        __stitch?: string | undefined;
+        __prefetch?: string | undefined;
+        ogygiaFallback?: Snippet<[]> | undefined;
+        __remount?: string | undefined;
+        __when?: string | undefined;
+        __maxAge?: number | undefined;
+        __onExpire?: "empty" | "fetch" | undefined;
+    }>): void;
+};
+declare const Region: import("svelte").Component<{
+    of?: import("./region.js").RegionValue | Promise<import("./region.js").RegionValue>;
+    placeholder?: import("svelte").Snippet;
+    children?: import("svelte").Snippet;
+    __mode?: "island" | "server" | "lake";
+    __baked?: boolean;
+    visible?: string | boolean;
+    idle?: boolean;
+    media?: string;
+    load?: boolean;
+    interaction?: boolean;
+    __keep?: string;
+    __entry?: string;
+    __src?: string;
+    __component?: import("svelte").Component;
+    __css?: unknown;
+    __load?: () => Promise<import("svelte").Component>;
+    __props?: Record<string, unknown>;
+    __defer?: string;
+    __margin?: string;
+    __hydrate?: string;
+    __hydrateMargin?: string;
+    __module?: string;
+    __cacheTtl?: number;
+    __stitch?: string;
+    __prefetch?: string;
+    ogygiaFallback?: import("svelte").Snippet;
+    __remount?: string;
+    __when?: string;
+    __maxAge?: number;
+    __onExpire?: "empty" | "fetch";
+}, {}, "">;

package/dist/SlotBoundary.svelte

@@ -0,0 +1,13 @@
+<script>/**
+* The nested-context RESET around an island's in-place slot children. Region `setNested()`s for its
+* subtree so islands rendered INSIDE an island degrade to plain inline components — but slot children
+* belong to the HOST page, not the island: an island inside them must render as a FULL region
+* (`<ogygia-region>` + payload) so the runtime can wake it independently after the parent ADOPTS the
+* slot DOM. Server-only in practice (the client adopts, never re-renders slot children).
+*/
+import { setNested } from "./context.js";
+let { children } = $props();
+setNested(false);
+</script>
+
+{@render children?.()}

package/dist/SlotBoundary.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    children?: Snippet;
+};
+declare const SlotBoundary: import("svelte").Component<$$ComponentProps, {}, "">;
+type SlotBoundary = ReturnType<typeof SlotBoundary>;
+export default SlotBoundary;

package/dist/app.d.ts

@@ -0,0 +1,4 @@
+import { afterNavigate, beforeNavigate, bust_page_cache, disableScrollHandling, goto, invalidate, invalidateAll, preloadCode, preloadData } from "./shims/app-navigation.js";
+import { spa_html_cacheable } from "./runtime/spa-cacheable.js";
+import { AfterNavigateCallback, AfterNavigation, BeforeNavigateCallback, BeforeNavigation, NavTarget } from "./runtime/router.js";
+export { type AfterNavigateCallback, type AfterNavigation, type BeforeNavigateCallback, type BeforeNavigation, type NavTarget, afterNavigate, beforeNavigate, bust_page_cache, disableScrollHandling, goto, invalidate, invalidateAll, preloadCode, preloadData, spa_html_cacheable };

package/dist/app.js

@@ -0,0 +1,3 @@
+import { afterNavigate, beforeNavigate, bust_page_cache, disableScrollHandling, goto, invalidate, invalidateAll, preloadCode, preloadData } from "./shims/app-navigation.js";
+import { spa_html_cacheable } from "./runtime/spa-cacheable.js";
+export { afterNavigate, beforeNavigate, bust_page_cache, disableScrollHandling, goto, invalidate, invalidateAll, preloadCode, preloadData, spa_html_cacheable };

package/dist/boundary.d.ts

@@ -0,0 +1,35 @@
+export interface BoundaryFinding {
+  /** What the seam will do with this leaf. */
+  kind: "plain" | "wire" | "store" | "warn" | "refuse";
+  /** Dot-path from the context value to the leaf (empty = the value itself). */
+  path: string;
+  /** One human sentence: what it is + what to do about it. */
+  detail: string;
+}
+/** App-configurable secret policy (call once in hooks.server.ts). `allow` names keys/paths the
+ *  sniff must NOT refuse (a false positive like 'tokenColor'); `deny` names ones it MUST refuse
+ *  even when the regex misses (a semantic secret the shape can't reveal). Exact, case-sensitive
+ *  matches against the context key or the finding path. */
+export interface BoundaryPolicy {
+  allow?: readonly string[];
+  deny?: readonly string[];
+}
+export declare function configure_boundary(p: BoundaryPolicy): void;
+/**
+ * Classify one boundary value. `key` is the context key / prop name (used for secret sniffing
+ * and in messages). Returns every finding, worst problems included — the caller decides
+ * whether to warn (dev) or refuse (encode).
+ */
+export declare function classify_boundary(value: unknown, key?: string): BoundaryFinding[];
+/** The findings that make a value undroppable-into-HTML (used to explain a dropped context key). */
+export declare function boundary_problems(value: unknown, key?: string): BoundaryFinding[];
+/** Format one finding as the console line for a dropped/degraded context key. */
+export declare function format_boundary_finding(key: string, f: BoundaryFinding): string;
+/**
+ * The `import.meta.og.$` rewrite target for NON-function values — the universal boundary
+ * assertion. Classifies the value AT THE MARK (creation), so a refusal (DOM node, bare
+ * function, unwired class, secret) throws with the marked file:line instead of surfacing
+ * deep inside a serializer at request time. Mark-don't-wrap: the value itself is returned
+ * untouched — stores/classes/data keep their own passports; identity mints at the seam.
+ */
+export declare function __og_boundary<T>(value: T, site: string): T;

package/dist/boundary.js

@@ -0,0 +1,127 @@
+import { is_derived_like, is_store } from "./store-transport.js";
+import { wire } from "./live-transport.js";
+// src/boundary.ts
+/**
+* Boundary classifier — guard layer of the transportable seam.
+*
+* When a context/prop value heads for an island boundary, this walks it and names, per leaf,
+* what will happen: cross free, auto-wire, warn, or refuse — WITH the path to the leaf. It
+* exists so a value that can't cross fails at BOUNDARY DISCOVERY with "context 'user' @
+* profile.avatarEl: live DOM node", instead of an island silently reading `undefined` in prod.
+*
+* Dev-only caller today: `serialize_provided_context` used to drop unbridgeable keys silently;
+* it now explains each drop. The classifier is pure and dependency-light (store detection is
+* by shape, DOM by nodeType) so it costs nothing to import server-side.
+*/
+const SECRET_KEY_RE = /token|secret|passw(or)?d|api[-_]?key|credential|authorization/i;
+let policy = {
+	allow: /* @__PURE__ */ new Set(),
+	deny: /* @__PURE__ */ new Set()
+};
+function configure_boundary(p) {
+	policy = {
+		allow: new Set(p.allow ?? []),
+		deny: new Set(p.deny ?? [])
+	};
+}
+const secret_like = (name) => !policy.allow.has(name) && (policy.deny.has(name) || SECRET_KEY_RE.test(name));
+const STORE_BUILTINS = /* @__PURE__ */ new Set([
+	"subscribe",
+	"set",
+	"update"
+]);
+function is_dom(v) {
+	return typeof v.nodeType === "number" && typeof v.nodeName === "string";
+}
+function is_plain_object(v) {
+	const proto = Object.getPrototypeOf(v);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* Classify one boundary value. `key` is the context key / prop name (used for secret sniffing
+* and in messages). Returns every finding, worst problems included — the caller decides
+* whether to warn (dev) or refuse (encode).
+*/
+function classify_boundary(value, key = "") {
+	const findings = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (kind, path, detail) => findings.push({
+		kind,
+		path,
+		detail
+	});
+	if (secret_like(key) && typeof value === "string") add("refuse", "", `key "${key}" looks like a secret — refusing to ship it into client-island HTML`);
+	(function walk(v, path) {
+		if (v === null || typeof v !== "object") {
+			if (typeof v === "function") add("refuse", path, "a bare function cannot cross an island boundary — make it a method on a [og.wire] class, a remote function, or provide it from an island");
+			else if (typeof v === "string" && path && secret_like(path.split(".").pop() ?? path)) add("warn", path, "secret-looking field crossing into client HTML — check this is not a credential");
+			return;
+		}
+		if (is_dom(v)) {
+			add("refuse", path, "live DOM node — it only exists in this document; provide it from an island (same-heap) instead");
+			return;
+		}
+		if (seen.has(v)) return;
+		seen.add(v);
+		const cls = v.constructor;
+		if (typeof cls === "function" && cls[wire]) {
+			add("wire", path, "transportable class — crosses via its [og.wire] codec");
+			return;
+		}
+		if (v[Symbol.for("ogygia.derived")] !== void 0) {
+			add("store", path, "resumable derived (og_derived) — its recipe crosses; islands re-derive against the reunified sources");
+			return;
+		}
+		if (is_store(v)) {
+			if (is_derived_like(v)) add("warn", path, "derived/readable store — the VALUE crosses but the derivation does not; islands see a frozen seed. Re-derive client-side or wire the sources");
+			else add("store", path, "store — auto-wires (current value crosses, islands share one live instance)");
+			const extra = Object.keys(v).filter((k) => !STORE_BUILTINS.has(k) && typeof v[k] === "function");
+			if (extra.length) add("warn", path, `store methods [${extra.join(", ")}] need a registered factory to survive — mark the factory (mark_store / auto-wire), else islands get a plain writable`);
+			return;
+		}
+		if (v instanceof Map) {
+			for (const [k, entry] of v) walk(entry, path ? `${path}.get(${String(k)})` : `get(${String(k)})`);
+			return;
+		}
+		if (v instanceof Set) {
+			let idx = 0;
+			for (const entry of v) walk(entry, `${path}[set:${idx++}]`);
+			return;
+		}
+		if (v instanceof Date || v instanceof RegExp) return;
+		if (Array.isArray(v)) {
+			v.forEach((entry, idx) => walk(entry, `${path}[${idx}]`));
+			return;
+		}
+		if (!is_plain_object(v)) {
+			add("refuse", path, `instance of class "${cls?.name ?? "?"}" without a [og.wire] codec — prototype and methods would be lost; give it \`static wire = import.meta.og.wire({ … })\``);
+			return;
+		}
+		for (const k of Object.keys(v)) walk(v[k], path ? `${path}.${k}` : k);
+	})(value, "");
+	return findings;
+}
+/** The findings that make a value undroppable-into-HTML (used to explain a dropped context key). */
+function boundary_problems(value, key = "") {
+	return classify_boundary(value, key).filter((f) => f.kind === "refuse" || f.kind === "warn");
+}
+/** Format one finding as the console line for a dropped/degraded context key. */
+function format_boundary_finding(key, f) {
+	return `[ogygia] context '${key}'${f.path ? ` @ ${f.path}` : ""}: ${f.detail}`;
+}
+/**
+* The `import.meta.og.$` rewrite target for NON-function values — the universal boundary
+* assertion. Classifies the value AT THE MARK (creation), so a refusal (DOM node, bare
+* function, unwired class, secret) throws with the marked file:line instead of surfacing
+* deep inside a serializer at request time. Mark-don't-wrap: the value itself is returned
+* untouched — stores/classes/data keep their own passports; identity mints at the seam.
+*/
+function __og_boundary(value, site) {
+	const refusals = classify_boundary(value).filter((f) => f.kind === "refuse");
+	if (refusals.length) {
+		const f = refusals[0];
+		throw new Error(`[ogygia] ${site} — og.$ value${f.path ? ` @ ${f.path}` : ""}: ${f.detail}` + (refusals.length > 1 ? ` (+${refusals.length - 1} more)` : ""));
+	}
+	return value;
+}
+export { __og_boundary, boundary_problems, classify_boundary, configure_boundary, format_boundary_finding };

package/dist/build-cache.d.ts

@@ -0,0 +1,13 @@
+/** Point the cache at a project (the Vite plugin calls this with the app root at config time). */
+export declare function configure_build_cache(project_root: string): void;
+/** Test hook: force the cache root (or `null` to disable, `undefined` to re-probe). */
+export declare function __set_build_cache_root(dir: string | null | undefined): void;
+export declare class BuildCache<T> {
+  readonly namespace: string;
+  constructor(namespace: string);
+  /** This namespace's DIRECTORY, for artifact trees the consumer manages itself (git checkouts).
+   *  Returns the ensured absolute path, or `null` when the cache is unavailable. */
+  dir(): string | null;
+  get(key: string): T | null;
+  set(key: string, value: T): void;
+}

package/dist/build-cache.js

@@ -0,0 +1,77 @@
+import { fs, path } from "./compiler/host.js";
+// src/build-cache.ts
+/**
+* ogygia's BUILD CACHE — one shared, namespaced store for everything derived at build time. Node-only.
+*
+* Each consumer initialises its own corner: `new BuildCache<T>('fences')` — its namespace is its
+* directory inside the shared root, and it speaks `get`/`set` (JSON values) or `dir()` (an artifact
+* tree it manages itself, like git checkouts) — never filesystem paths. Where things persist is this
+* MODULE's concern: `node_modules/.ogygia/<namespace>/…` — inside `node_modules` deliberately,
+* because build platforms cache that whole tree, so a warm CI build re-derives nothing (no clone,
+* no shiki, no twoslash).
+*
+* Everything is best-effort: any FS error disables the cache for the session rather than failing a
+* build — a cache must never be the reason a build breaks.
+*/
+let root;
+let configured;
+/** Point the cache at a project (the Vite plugin calls this with the app root at config time). */
+function configure_build_cache(project_root) {
+	if (configured === project_root) return;
+	configured = project_root;
+	root = void 0;
+}
+/** Test hook: force the cache root (or `null` to disable, `undefined` to re-probe). */
+function __set_build_cache_root(dir) {
+	root = dir;
+	if (dir === void 0) configured = void 0;
+}
+function cache_root() {
+	if (root !== void 0) return root;
+	try {
+		const d = path.join(configured ?? process.cwd(), "node_modules", ".ogygia");
+		fs.mkdirSync(d, { recursive: true });
+		root = d;
+	} catch {
+		root = null;
+	}
+	return root;
+}
+var BuildCache = class {
+	namespace;
+	constructor(namespace) {
+		this.namespace = namespace;
+	}
+	/** This namespace's DIRECTORY, for artifact trees the consumer manages itself (git checkouts).
+	*  Returns the ensured absolute path, or `null` when the cache is unavailable. */
+	dir() {
+		const r = cache_root();
+		if (!r) return null;
+		try {
+			const d = path.join(r, this.namespace);
+			fs.mkdirSync(d, { recursive: true });
+			return d;
+		} catch {
+			return null;
+		}
+	}
+	get(key) {
+		const d = this.dir();
+		if (!d) return null;
+		try {
+			return JSON.parse(fs.readFileSync(path.join(d, key + ".json"), "utf8"));
+		} catch {
+			return null;
+		}
+	}
+	set(key, value) {
+		const d = this.dir();
+		if (!d) return;
+		try {
+			const tmp = path.join(d, key + "." + process.pid + ".tmp");
+			fs.writeFileSync(tmp, JSON.stringify(value));
+			fs.renameSync(tmp, path.join(d, key + ".json"));
+		} catch {}
+	}
+};
+export { BuildCache, __set_build_cache_root, configure_build_cache };

package/dist/compiler/blank-styles.d.ts

@@ -0,0 +1 @@
+export declare function blank_styles(code: string): string;

package/dist/compiler/blank-styles.js

@@ -0,0 +1,63 @@
+// src/compiler/blank-styles.ts
+/**
+* A component's source with every `<style>` block's CONTENT blanked: each character a space,
+* newlines kept, so every offset is the source's own (edits made from the parse land on the
+* original, and a `source.slice(ast.css.start, ast.css.end)` still reads the real style).
+*
+* For the passes that parse a RAW component (before any preprocessor) and never read its styles:
+* Svelte's parser reads `<style>` as plain CSS, and a valid `<style lang="scss">` with SCSS-only
+* syntax (`#{$i}`, `@each`, `@for`) throws `css_expected_identifier`. Those passes then skipped the
+* file in silence: the barrel rewrite left its imports on their barrels (the island shipped the
+* whole barrel), the island transform left its region imports untransformed.
+*
+* A `<style>` inside a `<script>` (a template string) is script text and is left alone. String
+* scanning, no regex: it runs over every component.
+*/
+/** Where the closing `</tag` is from `from`, or -1. Case-insensitive. */
+function close_of(code, tag, from) {
+	const close = `</${tag}`;
+	for (let i = code.indexOf("</", from); i !== -1; i = code.indexOf("</", i + 2)) if (code.slice(i, i + close.length).toLowerCase() === close) return i;
+	return -1;
+}
+/** At `i`, an opening `<tag` (followed by whitespace, `>` or `/`)? */
+function opens(code, i, tag) {
+	if (code.slice(i + 1, i + 1 + tag.length).toLowerCase() !== tag) return false;
+	const c = code[i + 1 + tag.length];
+	return c === ">" || c === "/" || c === " " || c === "	" || c === "\n" || c === "\r";
+}
+function blank_styles(code) {
+	if (!code.includes("<style") && !code.includes("<STYLE")) return code;
+	let out = "";
+	let at = 0;
+	let i = code.indexOf("<");
+	while (i !== -1) {
+		if (opens(code, i, "script")) {
+			const gt = code.indexOf(">", i);
+			const close = gt === -1 ? -1 : close_of(code, "script", gt + 1);
+			if (close === -1) break;
+			i = code.indexOf("<", close + 2);
+			continue;
+		}
+		if (opens(code, i, "style")) {
+			const gt = code.indexOf(">", i);
+			const close = gt === -1 ? -1 : close_of(code, "style", gt + 1);
+			if (close === -1) break;
+			out += code.slice(at, gt + 1);
+			let run = 0;
+			for (let k = gt + 1; k < close; k++) {
+				const c = code[k];
+				if (c === "\n" || c === "\r") {
+					out += " ".repeat(run) + c;
+					run = 0;
+				} else run++;
+			}
+			out += " ".repeat(run);
+			at = close;
+			i = code.indexOf("<", close + 2);
+			continue;
+		}
+		i = code.indexOf("<", i + 1);
+	}
+	return at === 0 ? code : out + code.slice(at);
+}
+export { blank_styles };

package/dist/compiler/bom.d.ts

@@ -0,0 +1,2 @@
+/** `source` without a leading byte-order mark (the same string when there is none). */
+export declare function strip_bom(source: string): string;

package/dist/compiler/bom.js

@@ -0,0 +1,15 @@
+// src/compiler/bom.ts
+/**
+* A leading UTF-8 byte-order mark is invisible text. Svelte's `parse` drops it, so every AST offset
+* it reports is one short of the raw source, and a pass that edits the raw source by those offsets
+* (MagicString) lands one character early — splitting a tag name (`<qds-butto data-og-opaquen`, a
+* field build). The compiler therefore takes the mark off at the doors where source comes in (the
+* per-file transform, the barrel rewrite, the file reader), so every pass sees exactly the text its
+* parser saw. Dropping it changes nothing a browser or a bundler reads.
+*/
+const BOM = 65279;
+/** `source` without a leading byte-order mark (the same string when there is none). */
+function strip_bom(source) {
+	return source.charCodeAt(0) === BOM ? source.slice(1) : source;
+}
+export { strip_bom };

package/dist/compiler/browser-full.d.ts

@@ -0,0 +1,8 @@
+import { Compiler, Profiler } from "./driver.js";
+import { Program, RegisterResult, host_key, strip_id } from "./program.js";
+import { CompileCtx, CompileCtxInit } from "./ctx.js";
+import { CompilerHost, HostCrypto, HostDirent, HostFs, HostHasher, HostPath, HostStats, set_host } from "./host.js";
+import { ParseResult, RawParse, set_parser } from "./parse/oxc.js";
+import { CLIENT_BINDING_STUB, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
+import { islandVirtualId } from "./ids.js";
+export { CLIENT_BINDING_STUB, CompileCtx, type CompileCtxInit, Compiler, type CompilerHost, type HostCrypto, type HostDirent, type HostFs, type HostHasher, type HostPath, type HostStats, type ParseResult, type Profiler, Program, type RawParse, type RegisterResult, host_key, islandVirtualId, set_host, set_parser, strip_id, transformHost, transformTsRegions, wrapperVirtualId };

package/dist/compiler/browser-full.js

@@ -0,0 +1,8 @@
+import { Compiler } from "./driver.js";
+import { Program, host_key, strip_id } from "./program.js";
+import { CompileCtx } from "./ctx.js";
+import { set_host } from "./host.js";
+import { set_parser } from "./parse/oxc.js";
+import { CLIENT_BINDING_STUB, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
+import { islandVirtualId } from "./ids.js";
+export { CLIENT_BINDING_STUB, CompileCtx, Compiler, Program, host_key, islandVirtualId, set_host, set_parser, strip_id, transformHost, transformTsRegions, wrapperVirtualId };

package/dist/compiler/browser.d.ts

@@ -0,0 +1,11 @@
+import { CLIENT_BINDING_STUB, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
+import { islandVirtualId } from "./ids.js";
+import { ParseResult, RawParse, parse_module, set_parser } from "./parse/oxc.js";
+import { CompilerHost, createHash, fs, path, set_host } from "./host.js";
+import { JsRegion, OgCall, find_og_calls, is_js_module, og_js_regions, split_first_string } from "./parse/scan.js";
+import { og_member } from "./macros/wire.js";
+import { BuildCache, __set_build_cache_root, configure_build_cache } from "../build-cache.js";
+import { contentCssKey as content_css_key } from "../plugin/utils.js";
+import { dedent } from "./macros/dedent.js";
+import { run_browser_macros } from "./macros/browser.js";
+export { BuildCache, CLIENT_BINDING_STUB, type CompilerHost, type JsRegion, type OgCall, type ParseResult, type RawParse, __set_build_cache_root, configure_build_cache, content_css_key, createHash, dedent, find_og_calls, fs, is_js_module, islandVirtualId, og_js_regions, og_member, parse_module, path, run_browser_macros, set_host, set_parser, split_first_string, transformHost, transformTsRegions, wrapperVirtualId };

package/dist/compiler/browser.js

@@ -0,0 +1,11 @@
+import { CLIENT_BINDING_STUB, transformHost, transformTsRegions, wrapperVirtualId } from "./region/transform.js";
+import { islandVirtualId } from "./ids.js";
+import { parse_module, set_parser } from "./parse/oxc.js";
+import { createHash, fs, path, set_host } from "./host.js";
+import { find_og_calls, is_js_module, og_js_regions, split_first_string } from "./parse/scan.js";
+import { og_member } from "./macros/wire.js";
+import { BuildCache, __set_build_cache_root, configure_build_cache } from "../build-cache.js";
+import { contentCssKey as content_css_key } from "../plugin/utils.js";
+import { dedent } from "./macros/dedent.js";
+import { run_browser_macros } from "./macros/browser.js";
+export { BuildCache, CLIENT_BINDING_STUB, __set_build_cache_root, configure_build_cache, content_css_key, createHash, dedent, find_og_calls, fs, is_js_module, islandVirtualId, og_js_regions, og_member, parse_module, path, run_browser_macros, set_host, set_parser, split_first_string, transformHost, transformTsRegions, wrapperVirtualId };

package/dist/compiler/content/transportables.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Does this module define an exported class carrying a transportable codec? Used to build
+ * the eager-registration manifest so islands never need a manual `import` of the class.
+ *
+ * Signal: an exported class with a `static` member whose key is COMPUTED (`static [x] = …` /
+ * `static [x]() {}`) — every rewritten wire member is exactly that — OR, pre-rewrite, the
+ * `import.meta.og.wire` construct marker (prescan reads RAW source, where the blessed spelling
+ * `static wire = import.meta.og.wire()` is not yet a computed member). A false positive (an
+ * unrelated computed static, the marker in a comment) only eagerly loads one extra module; a
+ * transportable class is never missed.
+ */
+export declare function moduleHasTransportable(code: string, id_n: string): boolean;
+/**
+ * Append `__register_transportable` calls for every exported class in this module. Returns
+ * the augmented code, or null when there is no exported class. Append-only — the module's
+ * existing sourcemap stays valid.
+ */
+export declare function appendTransportRegistrations(code: string, id_n: string, root: string, pathModule: {
+  relative: (from: string, to: string) => string;
+}): string | null;
+/** True if a `.svelte` file's `<script module>` exports a transportable class. */
+export declare function svelteModuleHasTransportable(code: string, id_n: string): boolean;
+/** Inject registration for a `.svelte` module script's exported transportable classes. */
+export declare function appendSvelteModuleRegistrations(code: string, id_n: string, root: string, pathModule: {
+  relative: (from: string, to: string) => string;
+}): string | null;