@ogygia/core 0.0.0 → 0.11.1

package/dist/compiler/macros/source.js

@@ -0,0 +1,127 @@
+import { find_og_calls, og_js_regions } from "../parse/scan.js";
+import { parse_module } from "../parse/oxc.js";
+import { og_member } from "./wire.js";
+// src/compiler/macros/source.ts
+/**
+* `import.meta.og.source(fn)` — declared data sources, as a compile construct (the postrender
+* reverse index; internal/notes/freeze.md §L2):
+*
+*   export const loadBuilderContent = import.meta.og.source(async (event, category) => { … });
+*
+* The macro stamps the id from THIS definition's `file#export` (root-relative; the ogygia.files
+* identity rail applies to package paths upstream) and rewrites to
+* `__og_source('<id>', fn, opts?)` with the runtime-wrapper import injected. Loads stay
+* untouched plain TS forever; `postrender.invalidate(loadBuilderContent, [args])` reads the stamp
+* off the function — no strings anywhere.
+*
+* STRICT BY CONSTRUCTION — legal in exactly ONE position:
+*   • a top-level `export const <name> = import.meta.og.source(fn)` (or `(fn, { key })`);
+*   • 1 or 2 arguments; the first is the function.
+* Anything else — un-exported, nested, bare access, argument-less — is a BUILD ERROR naming the
+* file and line (the wire/asRegion macro laws).
+*/
+const EXPORT_CONST_TAIL_RE = /\bexport\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*$/;
+const MARKER = "import.meta.og.source";
+const IMPORT_LINE = `import { __og_source } from 'ogygia/internal';\n`;
+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.source is legal in exactly one position: \`export const <name> = import.meta.og.source(fn)\` (optionally \`(fn, { key })\`) at module top level. The compiler stamps the source id from that export's identity.`);
+}
+function walk(node, visit) {
+	visit(node);
+	for (const key in node) {
+		if (key === "type" || key === "start" || key === "end") continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const c of child) if (c && typeof c === "object" && typeof c.type === "string") walk(c, visit);
+		} else if (child && typeof child === "object" && typeof child.type === "string") walk(child, visit);
+	}
+}
+/** AST pass over one JS region; null when it doesn't parse (caller uses the scanner fallback). */
+function ast_edits(src, region, id, rel) {
+	const { program, ok } = parse_module(region.code, id);
+	if (!ok || !program) return null;
+	const edits = [];
+	const claimed = /* @__PURE__ */ new Set();
+	for (const stmt of program.body ?? []) {
+		if (stmt.type !== "ExportNamedDeclaration") continue;
+		const decl = stmt.declaration;
+		if (!decl || decl.type !== "VariableDeclaration") continue;
+		for (const d of decl.declarations ?? []) {
+			const init = d.init;
+			if (init?.type !== "CallExpression" || og_member(init.callee) !== "source") continue;
+			const abs = region.offset + init.start;
+			if (decl.kind !== "const") misuse(id, src, abs, `a source must be \`export const\` (got \`${decl.kind}\`)`);
+			const name = d.id?.type === "Identifier" ? d.id.name : null;
+			if (!name) misuse(id, src, abs, `a source export must be a plain identifier (no destructuring)`);
+			const args = init.arguments ?? [];
+			if (args.length < 1 || args.length > 2) misuse(id, src, abs, `source() takes the function (+ optional { key }) — got ${args.length} args`);
+			claimed.add(init);
+			claimed.add(init.callee);
+			const callee = init.callee;
+			edits.push({
+				start: region.offset + callee.start,
+				end: region.offset + callee.end,
+				text: `__og_source`
+			});
+			edits.push({
+				start: region.offset + args[0].start,
+				end: region.offset + args[0].start,
+				text: `${JSON.stringify(`${rel}#${name}`)}, `
+			});
+		}
+	}
+	walk(program, (n) => {
+		if (n.type === "CallExpression" && og_member(n.callee) === "source" && !claimed.has(n)) misuse(id, src, region.offset + n.start, `source() outside an \`export const\` initializer`);
+		if (og_member(n) === "source" && !claimed.has(n)) misuse(id, src, region.offset + n.start, `bare import.meta.og.source used as a value`);
+	});
+	edits.sort((a, b) => a.start - b.start);
+	return edits;
+}
+/** Scanner fallback for mid-edit source: rewrite only the exact legal spelling; strictness is
+*  enforced by the next parseable state's AST pass. */
+function scan_edits(src, region, rel) {
+	const edits = [];
+	const code = region.code;
+	for (const call of find_og_calls(code, "import.meta.og.")) {
+		if (call.method !== "source") continue;
+		const before = code.slice(0, call.start);
+		const m = EXPORT_CONST_TAIL_RE.exec(before);
+		if (!m) continue;
+		const inner = call.args.trim();
+		if (!inner) continue;
+		edits.push({
+			start: region.offset + call.start,
+			end: region.offset + call.end,
+			text: `__og_source(${JSON.stringify(`${rel}#${m[1]}`)}, ${inner})`
+		});
+	}
+	return edits;
+}
+/**
+* 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.
+*/
+function rewrite_source(src, id, rel, markup_exts) {
+	if (!src.includes(MARKER)) return src;
+	const regions = og_js_regions(src, id, markup_exts);
+	if (!regions) return src;
+	const edits = [];
+	for (const region of regions) edits.push(...ast_edits(src, region, id, rel) ?? scan_edits(src, region, rel));
+	if (!edits.length) return src;
+	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 IMPORT_LINE + out;
+}
+export { rewrite_source };

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

@@ -0,0 +1,17 @@
+/** Rewrite every `import.meta.og.store` mark. Same-reference return when nothing to do. */
+export declare function rewrite_store(src: string, id: string, rel_id: string, markup_exts: readonly string[]): string;
+/**
+ * AUTO-DETECT tier: brand exported factories whose body PROVABLY returns a store, with zero
+ * authoring. v1 scope (deliberately narrow — no guessing, under-branding is always safe since
+ * the generic writable tier still carries the value):
+ *
+ *   export const createX = (seed) => ({ subscribe, … })          // object literal w/ subscribe
+ *   export const createY = (seed) => writable(seed)              // direct writable()/readable()
+ *   export const createZ = (seed) => { … return { subscribe } }  // every return provable
+ *
+ * Skipped (→ generic tier / the og.store assert): function declarations, re-exports, factories
+ * returning call results (`return make(x)`), mixed/ambiguous returns, non-exported consts.
+ * Requires the module to import from 'svelte/store' when the proof is a writable()/readable()
+ * call (a local function named `writable` must not count).
+ */
+export declare function auto_brand_stores(src: string, id: string, rel_id: string, markup_exts: readonly string[]): string;

package/dist/compiler/macros/store.js

@@ -0,0 +1,244 @@
+import { og_js_regions } from "../parse/scan.js";
+import { parse_module } from "../parse/oxc.js";
+import { og_member } from "./wire.js";
+// src/compiler/macros/store.ts
+/**
+* `import.meta.og.store()` — the store-factory assert mark, as a compile construct.
+*
+* The store kind's registered-factory tier needs a build tag ↔ factory pairing so decode can
+* rebuild a store THROUGH its factory (custom methods survive the wire). Provable factories
+* can be auto-branded later; this construct is the floor that always works — the author
+* asserts "this returns a store", and the compiler does the mechanical part:
+*
+*   export const createCart = import.meta.og.store((seed = []) => { … });
+*     ↓
+*   export const createCart = __og_store('src/lib/cart.ts#store0', (seed = []) => { … });
+*
+* `__og_store` (store-transport.ts) registers the factory at module load (the island importing
+* the factory module IS what fills decode's registry) and brands every product with the tag.
+* The factory's FIRST PARAMETER is the seed: decode calls `factory(currentValue)`.
+*
+* STRICT BY CONSTRUCTION (og-wire's playbook): legal in exactly ONE shape — a direct call
+* `import.meta.og.store(<inline function or identifier>)`. Bare access, aliasing, zero/multiple
+* arguments, or a non-function argument are BUILD ERRORS naming file:line. AST-precise over
+* the module's JS regions; a mid-edit unparseable file doesn't transform (the marker then
+* fails loudly at runtime — `import.meta.og` is undefined without the transform).
+*/
+const MARKER = "import.meta.og.store";
+function walk(node, visit) {
+	visit(node);
+	for (const key in node) {
+		if (key === "type" || key === "start" || key === "end") continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const c of child) if (c && typeof c === "object" && typeof c.type === "string") walk(c, visit);
+		} else if (child && typeof child === "object" && typeof child.type === "string") walk(child, visit);
+	}
+}
+function line_of(src, offset) {
+	let line = 1;
+	for (let i = 0; i < offset && i < src.length; i++) if (src[i] === "\n") line++;
+	return line;
+}
+function misuse(id, src, offset, what) {
+	throw new Error(`[ogygia] ${id}:${line_of(src, offset)} — ${what}. import.meta.og.store is legal in exactly one shape: a direct call wrapping a store factory — import.meta.og.store((seed) => ({ subscribe, … })). It registers the factory under a build tag so islands rebuild the store THROUGH it (custom methods survive); the factory's first parameter is the seed value.`);
+}
+/** Unwrap oxc's preserved parens. */
+function unparen(v) {
+	while (v && v.type === "ParenthesizedExpression") v = v.expression;
+	return v;
+}
+/** Provably NOT a store — the literal tier only: bare return, undefined, void, null, primitive
+*  literals. Identifiers, calls, members, ternaries are never flagged: they could be stores, the
+*  mark is the author's assertion, and dynamic values get the runtime floor instead. */
+function literal_non_store(v) {
+	v = unparen(v);
+	if (!v) return true;
+	if (v.type === "Identifier") return v.name === "undefined";
+	if (v.type === "UnaryExpression") return v.operator === "void";
+	return v.type === "NullLiteral" || v.type === "BooleanLiteral" || v.type === "NumericLiteral" || v.type === "StringLiteral" || v.type === "BigIntLiteral" || v.type === "TemplateLiteral";
+}
+/** First provably-non-store return inside an EXPLICITLY marked inline factory (top-level returns
+*  only — nested functions' returns are theirs). Region-relative offset, or undefined. */
+function first_non_store_return(fn) {
+	const body = fn.body;
+	if (body.type !== "BlockStatement") return literal_non_store(body) ? body.start : void 0;
+	let found;
+	(function collect(n) {
+		for (const key in n) {
+			if (found !== void 0) return;
+			if (key === "type" || key === "start" || key === "end") continue;
+			const child = n[key];
+			const kids = Array.isArray(child) ? child : child && typeof child === "object" && typeof child.type === "string" ? [child] : [];
+			for (const c of kids) {
+				if (c.type === "ArrowFunctionExpression" || c.type === "FunctionExpression" || c.type === "FunctionDeclaration") continue;
+				if (c.type === "ReturnStatement" && literal_non_store(c.argument)) {
+					found = c.start;
+					return;
+				}
+				collect(c);
+			}
+		}
+	})(body);
+	return found;
+}
+/** Rewrite every `import.meta.og.store` mark. Same-reference return when nothing to do. */
+function rewrite_store(src, id, rel_id, markup_exts) {
+	if (!src.includes(MARKER)) return src;
+	const regions = og_js_regions(src, id, markup_exts);
+	if (!regions) return src;
+	const edits = [];
+	let seq = 0;
+	let needs_import = false;
+	for (const region of regions) {
+		const { program, ok } = parse_module(region.code, id);
+		if (!ok || !program) continue;
+		const claimed = /* @__PURE__ */ new Set();
+		walk(program, (n) => {
+			if (n.type === "CallExpression" && og_member(n.callee) === "store") {
+				const abs = region.offset + n.start;
+				const args = n.arguments;
+				if (!args || args.length !== 1) misuse(id, src, abs, `store() takes exactly one argument — the factory`);
+				const fn = args[0];
+				if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression" && fn.type !== "Identifier") misuse(id, src, abs, `store()'s argument must be a function expression or an identifier (got ${fn.type})`);
+				claimed.add(n);
+				claimed.add(n.callee);
+				if (fn.type !== "Identifier") {
+					const bad = first_non_store_return(fn);
+					if (bad !== void 0 && typeof console !== "undefined") console.warn(`[ogygia] ${id}:${line_of(src, region.offset + bad)} — this import.meta.og.store factory has a return that is provably not a store (undefined/null/primitive). Where that branch runs, the product crosses as plain data, unbranded. If it is an environment guard, return a store there too (e.g. writable(seed)) and guard the side effects inside the factory instead.`);
+				}
+				const fn_text = region.code.slice(fn.start, fn.end);
+				const tag = `${rel_id}#store${seq++}`;
+				needs_import = true;
+				edits.push({
+					start: abs,
+					end: region.offset + n.end,
+					text: `__og_store(${JSON.stringify(tag)}, ${fn_text})`
+				});
+				return;
+			}
+			if (og_member(n) === "store" && !claimed.has(n)) misuse(id, src, region.offset + n.start, `bare import.meta.og.store used as a value`);
+		});
+		if (needs_import && !edits.some((e) => e.text.startsWith("import"))) {
+			edits.push({
+				start: region.offset,
+				end: region.offset,
+				text: `import { __og_store } from 'ogygia/internal';`
+			});
+			needs_import = false;
+		}
+	}
+	if (!edits.length) return src;
+	edits.sort((a, b) => a.start - b.start);
+	let out = "";
+	let last = 0;
+	for (const e of edits) {
+		out += src.slice(last, e.start) + e.text;
+		last = e.end;
+	}
+	out += src.slice(last);
+	return out;
+}
+/**
+* AUTO-DETECT tier: brand exported factories whose body PROVABLY returns a store, with zero
+* authoring. v1 scope (deliberately narrow — no guessing, under-branding is always safe since
+* the generic writable tier still carries the value):
+*
+*   export const createX = (seed) => ({ subscribe, … })          // object literal w/ subscribe
+*   export const createY = (seed) => writable(seed)              // direct writable()/readable()
+*   export const createZ = (seed) => { … return { subscribe } }  // every return provable
+*
+* Skipped (→ generic tier / the og.store assert): function declarations, re-exports, factories
+* returning call results (`return make(x)`), mixed/ambiguous returns, non-exported consts.
+* Requires the module to import from 'svelte/store' when the proof is a writable()/readable()
+* call (a local function named `writable` must not count).
+*/
+function auto_brand_stores(src, id, rel_id, markup_exts) {
+	if (!src.includes("subscribe") && !src.includes("writable") && !src.includes("readable")) return src;
+	const regions = og_js_regions(src, id, markup_exts);
+	if (!regions) return src;
+	const edits = [];
+	let seq = 0;
+	let needs_import = false;
+	const has_subscribe_prop = (obj) => (obj.properties ?? []).some((p) => {
+		if (p.type !== "Property" && p.type !== "ObjectProperty") return false;
+		const k = p.key;
+		return !p.computed && k?.type === "Identifier" && k.name === "subscribe" || k?.type === "StringLiteral" && k.value === "subscribe" || p.shorthand === true && k?.type === "Identifier" && k.name === "subscribe";
+	});
+	for (const region of regions) {
+		const { program, ok } = parse_module(region.code, id);
+		if (!ok || !program) continue;
+		const store_fns = /* @__PURE__ */ new Set();
+		for (const node of program.body ?? []) {
+			if (node.type !== "ImportDeclaration" || node.source?.value !== "svelte/store") continue;
+			for (const sp of node.specifiers ?? []) if (sp.type === "ImportSpecifier" && (sp.imported?.name === "writable" || sp.imported?.name === "readable")) store_fns.add(sp.local?.name ?? sp.imported.name);
+		}
+		const provable_value = (v) => {
+			while (v && v.type === "ParenthesizedExpression") v = v.expression;
+			if (!v) return false;
+			if (v.type === "ObjectExpression") return has_subscribe_prop(v);
+			if (v.type === "CallExpression" && v.callee?.type === "Identifier") return store_fns.has(v.callee.name);
+			return false;
+		};
+		const provable_factory = (fn) => {
+			if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression") return false;
+			const body = fn.body;
+			if (body.type !== "BlockStatement") return provable_value(body);
+			const returns = [];
+			(function collect(n) {
+				for (const key in n) {
+					if (key === "type" || key === "start" || key === "end") continue;
+					const child = n[key];
+					const kids = Array.isArray(child) ? child : child && typeof child === "object" && typeof child.type === "string" ? [child] : [];
+					for (const c of kids) {
+						if (c.type === "ArrowFunctionExpression" || c.type === "FunctionExpression" || c.type === "FunctionDeclaration") continue;
+						if (c.type === "ReturnStatement") returns.push(c);
+						collect(c);
+					}
+				}
+			})(body);
+			return returns.length > 0 && returns.every((r) => provable_value(r.argument));
+		};
+		for (const node of program.body ?? []) {
+			if (node.type !== "ExportNamedDeclaration") continue;
+			const decl = node.declaration;
+			if (decl?.type !== "VariableDeclaration") continue;
+			for (const d of decl.declarations ?? []) {
+				const init = d.init;
+				if (!init || !provable_factory(init)) continue;
+				const tag = `${rel_id}#auto:${d.id?.type === "Identifier" ? d.id.name : `auto`}${seq ? seq : ""}`;
+				seq++;
+				needs_import = true;
+				edits.push({
+					start: region.offset + init.start,
+					end: region.offset + init.start,
+					text: `__og_store(${JSON.stringify(tag)}, `
+				});
+				edits.push({
+					start: region.offset + init.end,
+					end: region.offset + init.end,
+					text: `)`
+				});
+			}
+		}
+		if (needs_import && !edits.some((e) => e.text.startsWith("import"))) {
+			edits.push({
+				start: region.offset,
+				end: region.offset,
+				text: `import { __og_store } from 'ogygia/internal';`
+			});
+			needs_import = false;
+		}
+	}
+	if (!edits.length) return src;
+	edits.sort((a, b) => a.start - b.start);
+	let out = "";
+	let last = 0;
+	for (const e of edits) {
+		out += src.slice(last, e.start) + e.text;
+		last = e.end;
+	}
+	out += src.slice(last);
+	return out;
+}
+export { auto_brand_stores, rewrite_store };

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

@@ -0,0 +1,14 @@
+import { AstNode } from "../parse/oxc.js";
+/** The key expression a wire member rewrites to — the same symbol the runtime registry uses. */
+export declare const WIRE_EXPR = "Symbol.for('ogygia.wire')";
+type Node = AstNode;
+/** If `node` is the member expression `import.meta.og.<name>`, return `<name>`; else null. */
+export declare function og_member(node: Node | undefined): string | null;
+/**
+ * Rewrite every wire mark in `src`, enforcing the strict position rules. Extension-aware:
+ * whole-file for JS/TS, `<script>` blocks for `.svelte`. Returns the input unchanged (same
+ * reference) when there is nothing to do. Throws (build-error voice, file:line) on any misuse.
+ * `markup_exts` is the resolved construct-host set (the plugin passes `['.svelte']`).
+ */
+export declare function rewrite_wire(src: string, id: string, markup_exts: readonly string[]): string;
+export {};

package/dist/compiler/macros/wire.js

@@ -0,0 +1,160 @@
+import { find_og_calls, og_js_regions } from "../parse/scan.js";
+import { parse_module } from "../parse/oxc.js";
+// src/compiler/macros/wire.ts
+/**
+* `import.meta.og.wire()` — the transportable mark, as a compile construct. A class opts into
+* crossing island boundaries by declaring how it travels:
+*
+*   export class Cart {
+*     items = $state<Item[]>([]);
+*     static wire = import.meta.og.wire({
+*       encode: (c) => ({ items: $state.snapshot(c.items) }),
+*       decode: (d) => new Cart(d.items)
+*     });
+*   }
+*
+* The macro CONSUMES the member and MINTS the key: the compiled output is
+* `static [Symbol.for('ogygia.wire')] = <codec>` — a symbol-keyed protocol member the runtime
+* looks codecs up by. The symbol never exists in source, so there is nothing to import, alias,
+* or leak. (A literal `static [import.meta.og.wire]` KEY is grammatically impossible in
+* TypeScript — TS1166: a computed class key must be a plain dotted name, and `import.meta` is
+* meta-syntax. The call form is the strict, typechecked equivalent.)
+*
+* STRICT BY CONSTRUCTION — the construct is legal in exactly ONE position:
+*   • a static member named exactly `wire`, initialized with the call, inside a class body;
+*   • with exactly one argument, the codec (`{ encode, decode, id?, merge? }`).
+* Anything else — another member name, a variable, an argument, a bare `import.meta.og.wire`
+* access, an arg-less call — is a BUILD ERROR naming the file and line. And if the transform
+* somehow never runs, `import.meta.og` is undefined at runtime, so it fails on load rather than
+* half-working.
+*
+* Detection is AST-precise over the module's JS regions (whole file for `.ts`/`.js`, each
+* `<script>` block for `.svelte`), with a string scanner as the fallback for source that doesn't
+* parse mid-edit — so the marker in a comment or string is never rewritten.
+*/
+const STATIC_WIRE_TAIL_RE = /\bstatic\s+wire\s*=\s*$/;
+/** The key expression a wire member rewrites to — the same symbol the runtime registry uses. */
+const WIRE_EXPR = "Symbol.for('ogygia.wire')";
+const MARKER = "import.meta.og.wire";
+/** If `node` is the member expression `import.meta.og.<name>`, return `<name>`; else null. */
+function og_member(node) {
+	if (!node || node.type !== "MemberExpression" || node.computed) return null;
+	const name = node.property?.name;
+	if (typeof name !== "string") return null;
+	const og = node.object;
+	if (og?.type !== "MemberExpression" || og.computed || og.property?.name !== "og") return null;
+	const meta = og.object;
+	if (meta?.type !== "MetaProperty" || meta.meta?.name !== "import" || meta.property?.name !== "meta") return null;
+	return name;
+}
+/** Depth-first walk of an oxc AST, visiting every node object. */
+function walk(node, visit) {
+	visit(node);
+	for (const key in node) {
+		if (key === "type" || key === "start" || key === "end") continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const c of child) if (c && typeof c === "object" && typeof c.type === "string") walk(c, visit);
+		} else if (child && typeof child === "object" && typeof child.type === "string") walk(child, visit);
+	}
+}
+/** 1-based line of an absolute offset in `src` — for build-error voice. */
+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;
+}
+/** The strict-position build error. `id` + line point at the offending spelling. */
+function misuse(id, src, offset, what) {
+	throw new Error(`[ogygia] ${id}:${line_of(src, offset)} — ${what}. import.meta.og.wire is legal in exactly one position: \`static wire = import.meta.og.wire({ encode, decode })\` inside a class body. The macro consumes that member and mints the symbol key; the construct is not a value.`);
+}
+/**
+* AST pass over one JS region. The ONLY legal shape rewrites; every other appearance of the
+* construct throws the strict-position error. Returns null when the region doesn't parse
+* (caller falls back to the scanner).
+*/
+function ast_edits(src, region, id) {
+	const { program, ok } = parse_module(region.code, id);
+	if (!ok || !program) return null;
+	const edits = [];
+	const claimed = /* @__PURE__ */ new Set();
+	walk(program, (n) => {
+		if ((n.type === "PropertyDefinition" || n.type === "ClassProperty") && n.static === true) {
+			const v = n.value;
+			if (v?.type === "CallExpression" && og_member(v.callee) === "wire") {
+				const abs = region.offset + n.start;
+				const key = n.key;
+				const name = !n.computed && key?.type === "Identifier" ? key.name : null;
+				if (name !== "wire") misuse(id, src, abs, `the wire member must be named exactly \`wire\` (got \`${name ?? "<computed>"}\`)`);
+				const args = v.arguments;
+				if (!args || args.length !== 1) misuse(id, src, abs, `wire() takes exactly one argument — the codec ({ encode, decode })`);
+				claimed.add(v);
+				claimed.add(v.callee);
+				const a = args[0];
+				edits.push({
+					start: abs,
+					end: region.offset + a.start,
+					text: `static [${WIRE_EXPR}] = `
+				});
+				edits.push({
+					start: region.offset + a.end,
+					end: region.offset + v.end,
+					text: ""
+				});
+			}
+			return;
+		}
+		if (n.type === "CallExpression" && og_member(n.callee) === "wire" && !claimed.has(n)) misuse(id, src, region.offset + n.start, `wire() called outside a static class member`);
+		if (og_member(n) === "wire" && !claimed.has(n)) misuse(id, src, region.offset + n.start, `bare import.meta.og.wire used as a value`);
+	});
+	edits.sort((a, b) => a.start - b.start);
+	return edits;
+}
+/** Scanner fallback for source that doesn't parse mid-edit: rewrite only the exact legal spelling
+*  (`static wire = import.meta.og.wire(…)`). Uses the STRING-AWARE {@link find_og_calls} to locate
+*  the wire CALL — so a marker inside a string/comment/regex is never a hit (a naive regex here once
+*  corrupted `"static wire = import.meta.og.wire({})"` inside a string) — then confirms the call is
+*  the initializer of a `static wire =` member by inspecting the immediately-preceding tokens. Misuse
+*  isn't judged here — the next parseable state goes through the AST pass, which enforces strictness. */
+function scan_edits(src, region) {
+	const edits = [];
+	const code = region.code;
+	for (const call of find_og_calls(code, "import.meta.og.")) {
+		if (call.method !== "wire") continue;
+		const before = code.slice(0, call.start);
+		const m = STATIC_WIRE_TAIL_RE.exec(before);
+		if (!m) continue;
+		const inner = call.args.trim();
+		if (!inner) continue;
+		edits.push({
+			start: region.offset + m.index,
+			end: region.offset + call.end,
+			text: `static [${WIRE_EXPR}] = ${inner}`
+		});
+	}
+	return edits;
+}
+/**
+* Rewrite every wire mark in `src`, enforcing the strict position rules. Extension-aware:
+* whole-file for JS/TS, `<script>` blocks for `.svelte`. Returns the input unchanged (same
+* reference) when there is nothing to do. Throws (build-error voice, file:line) on any misuse.
+* `markup_exts` is the resolved construct-host set (the plugin passes `['.svelte']`).
+*/
+function rewrite_wire(src, id, markup_exts) {
+	if (!src.includes(MARKER)) return src;
+	const regions = og_js_regions(src, id, markup_exts);
+	if (!regions) return src;
+	const edits = [];
+	for (const region of regions) edits.push(...ast_edits(src, region, id) ?? scan_edits(src, region));
+	if (!edits.length) return src;
+	edits.sort((a, b) => a.start - b.start);
+	let out = "";
+	let last = 0;
+	for (const e of edits) {
+		out += src.slice(last, e.start) + e.text;
+		last = e.end;
+	}
+	out += src.slice(last);
+	return out;
+}
+export { WIRE_EXPR, og_member, rewrite_wire };

package/dist/compiler/ownership-stamps.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `source` with every opaque element stamped, or `null` when there is nothing to stamp (or the file
+ * does not parse — the real compile reports that). Outermost wins: nothing is stamped inside a stamped
+ * element (the repair never enters it anyway).
+ */
+export declare function stamp_opaque(raw: string, filename: string): string | null;