@rozie/cli 0.1.0 → 0.1.1

package/dist/{src-WZKv4m5y.mjs → src-DrhJa-BU.mjs}

@@ -9994,6 +9994,66 @@ function subtreeReads(node, accessor, name) {
 	return found;
 }
 /**
+* Returns true if the subtree rooted at `node` contains a BARE Identifier READ of
+* `name` — the exact shape the Vue `$computed` lowering wraps to `<name>.value`.
+*
+* The Vue trigger condition for the `$computed` shadow bug: a `$computed` name is
+* read as a BARE identifier in source (there is NO `$computed.<name>` accessor
+* member to gate on), and the downstream Identifier visitor `.value`-wraps every
+* such bare read. A colliding param/local only mis-captures that wrap when it
+* actually performs a bare read of `name` within its scope — so a `binding`
+* trigger (mere existence) would over-apply (renaming an unused same-named param
+* → corpus drift), and the `accessor` trigger cannot fire (no member access).
+*
+* Excludes the SAME non-read positions the Vue Identifier visitor skips, so the
+* gate matches the rewrite exactly: declaration ids, non-computed member
+* properties, object keys (shorthand or not), TS type positions, function names,
+* function params, and import/export specifier ids. A computed member property
+* (`obj[name]`) IS a bare read and counts.
+*
+* Hand-rolled own-child walk (the `subtreeReads` twin): a direct walk with
+* parent-context tracking is simpler than a Program-rooted Babel traverse and
+* has no rooting constraint.
+*/
+function subtreeReadsBareIdentifier(node, name) {
+	if (!node) return false;
+	let found = false;
+	function walk(n, parent) {
+		if (found || !n || typeof n !== "object" || !("type" in n)) return;
+		if (t.isIdentifier(n) && n.name === name) {
+			if (isBareRead(n, parent)) {
+				found = true;
+				return;
+			}
+		}
+		if (n.type.startsWith("TS") && n.type !== "TSNonNullExpression" && n.type !== "TSAsExpression" && n.type !== "TSSatisfiesExpression" && n.type !== "TSTypeAssertion") return;
+		for (const key of Object.keys(n)) {
+			if (key === "loc" || key === "start" || key === "end" || key === "leadingComments" || key === "trailingComments" || key === "innerComments") continue;
+			const v = n[key];
+			if (Array.isArray(v)) {
+				for (const item of v) if (item && typeof item === "object" && "type" in item) walk(item, n);
+			} else if (v && typeof v === "object" && "type" in v) walk(v, n);
+		}
+	}
+	function isBareRead(id, parent) {
+		if (!parent) return true;
+		if (t.isVariableDeclarator(parent) && parent.id === id) return false;
+		if ((t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) && parent.property === id && !parent.computed) return false;
+		if (t.isObjectProperty(parent) && parent.key === id && !parent.computed) return false;
+		if (t.isFunctionDeclaration(parent) && parent.id === id) return false;
+		if (t.isFunctionExpression(parent) && parent.id === id) return false;
+		if (t.isFunction(parent) && parent.params.includes(id)) return false;
+		if (t.isImportSpecifier(parent)) return false;
+		if (t.isImportDefaultSpecifier(parent)) return false;
+		if (t.isImportNamespaceSpecifier(parent)) return false;
+		if (t.isExportSpecifier(parent)) return false;
+		if (t.isLabeledStatement(parent) && parent.label === id) return false;
+		return true;
+	}
+	walk(node, null);
+	return found;
+}
+/**
 * THE UNIFIED PASS. Renames any USER binding (function param or
 * `const`/`let`/`var` declarator) that collides with a generated symbol to
 * `<name>$local`, atomically across its binding scope, gated only-on-collision
@@ -10013,6 +10073,7 @@ function deconflictGeneratedSymbols(program, groups, protectedNames = /* @__PURE
 		if (!group.names.has(name)) return false;
 		if (protectedNames.has(name)) return false;
 		if (group.trigger.kind === "binding") return true;
+		if (group.trigger.kind === "bare-read") return subtreeReadsBareIdentifier(scopeBlock, name);
 		return subtreeReads(scopeBlock, group.trigger.accessor, name);
 	};
 	traverse$19(program, {
@@ -10026,6 +10087,7 @@ function deconflictGeneratedSymbols(program, groups, protectedNames = /* @__PURE
 				if (!patternIntroducesBinding$3(id, name)) continue;
 				const binding = path.scope.getBinding(name);
 				const ownerScope = binding ? binding.scope : path.scope;
+				if (group.trigger.kind === "bare-read" && t.isProgram(ownerScope.block)) continue;
 				if (collides(group, name, ownerScope.block)) ownerScope.rename(name, alias(name));
 			}
 		},
@@ -18651,17 +18713,53 @@ function bindingNames(stmt) {
 function importLocalNames(imp) {
 	return imp.specifiers.map((s) => s.local.name);
 }
+/**
+* Root identifier of a TS entity name (`Foo` or `Foo.Bar.Baz` → `Foo`). A
+* `TSImportType` (`import('pkg').Foo`) has no root local identifier — returns
+* null (its module surface is already self-contained, never a hoist target).
+*/
+function rootTypeIdentifier(name) {
+	let node = name;
+	while (node && t.isTSQualifiedName(node)) node = node.left;
+	return node && t.isIdentifier(node) ? node.name : null;
+}
 /** Referenced identifier names within a statement (excludes bindings/keys). */
 function referencedNames(stmt) {
 	const out = /* @__PURE__ */ new Set();
 	try {
-		traverse$18(t.file(t.program([stmt])), { ReferencedIdentifier(path) {
-			out.add(path.node.name);
-		} });
+		traverse$18(t.file(t.program([stmt])), {
+			ReferencedIdentifier(path) {
+				out.add(path.node.name);
+			},
+			TSTypeReference(path) {
+				const root = rootTypeIdentifier(path.node.typeName);
+				if (root) out.add(root);
+			},
+			TSTypeQuery(path) {
+				const root = rootTypeIdentifier(path.node.exprName);
+				if (root) out.add(root);
+			}
+		});
 	} catch {}
 	return out;
 }
 /**
+* Effective import kind of a single specifier. A specifier is type-only when
+* EITHER the declaration is `import type { … }` (declKind === 'type', in which
+* case Babel reports the per-specifier `importKind` as `'value'`) OR the
+* specifier itself is the inline `import { type X }` form (spec.importKind ===
+* 'type'). The old `spec.importKind ? spec.importKind : declKind` form let the
+* `'value'` per-specifier kind of a declaration-level `import type` mask the
+* declaration's type-ness, so a hoisted `import type { T }` lost its type-only
+* marker and emitted as a runtime `import { T }` (IN-02). Value imports are
+* unaffected (both kinds are `'value'`).
+*/
+function effectiveImportKind(declKind, spec) {
+	if (declKind === "type") return "type";
+	if (t.isImportSpecifier(spec) && spec.importKind === "type") return "type";
+	return "value";
+}
+/**
 * Dedup key for a single import specifier per the R4 tuple:
 * (source, importKind, default|namespace|named:imported, local). Including the
 * LOCAL name keeps `import { thing }` and `import { thing as aliased }` distinct
@@ -18669,7 +18767,7 @@ function referencedNames(stmt) {
 * host and partial collapses to ONE statement.
 */
 function specifierKey(source, declKind, spec) {
-	const kind = (t.isImportSpecifier(spec) && spec.importKind ? spec.importKind : declKind) || "value";
+	const kind = effectiveImportKind(declKind, spec);
 	if (t.isImportDefaultSpecifier(spec)) return `${source}\0${kind}\0default\0${spec.local.name}`;
 	if (t.isImportNamespaceSpecifier(spec)) return `${source}\0${kind}\0namespace\0${spec.local.name}`;
 	return `${source}\0${kind}\0named:${t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value}\0${spec.local.name}`;
@@ -18679,12 +18777,12 @@ function specifierKey(source, declKind, spec) {
 * deduped by {@link specifierKey} and grouped by (source, importKind) so the
 * splice produces idiomatic merged `import { a, b } from 'src'` statements.
 */
-function hoistSpecifier(ctx, sourceNode, declKind, spec) {
+function hoistSpecifier(ctx, sourceNode, declKind, spec, sourceImport) {
 	const source = sourceNode.value;
 	const key = specifierKey(source, declKind, spec);
 	if (ctx.hoistKeys.has(key)) return;
 	ctx.hoistKeys.add(key);
-	const groupKind = (t.isImportSpecifier(spec) && spec.importKind ? spec.importKind : declKind) || "value";
+	const groupKind = effectiveImportKind(declKind, spec);
 	const groupKey = `${source}\0${groupKind}`;
 	const existing = ctx.hoistGroups.get(groupKey);
 	if (existing) {
@@ -18693,9 +18791,427 @@ function hoistSpecifier(ctx, sourceNode, declKind, spec) {
 	}
 	const decl = t.importDeclaration([spec], sourceNode);
 	if (groupKind === "type") decl.importKind = "type";
+	if (sourceImport) {
+		if (sourceImport.loc) decl.loc = sourceImport.loc;
+		if (sourceImport.trailingComments) decl.trailingComments = sourceImport.trailingComments;
+		if (sourceImport.innerComments) decl.innerComments = sourceImport.innerComments;
+	}
 	ctx.hoistGroups.set(groupKey, decl);
 	ctx.hoistImports.push(decl);
 }
+/**
+* Shift a single Babel `Position` object's `.line` by `offset`, exactly once.
+*
+* CRITICAL (Phase 55-04 bug fix): `@babel/parser` SHARES one `Position` object
+* across the `loc.start`/`loc.end` of nested nodes that begin/end at the same
+* source position — e.g. a `const f = () => {...}` shares ONE `loc.end` object
+* between the VariableDeclaration, VariableDeclarator, ArrowFunctionExpression
+* and BlockStatement (verified: all four `.loc.end` are `===`). The earlier
+* `seen`-keyed-on-the-`loc`-WRAPPER dedupe therefore shifted such a shared
+* `Position` once PER wrapping node (4× for the example above), corrupting
+* `loc.end.line` to `original + 4·offset` (~13985 for a host-line-3502 decl).
+* That blew the trailing-comment delta hugely negative, collapsing a between-
+* declaration comment onto the prior closing brace (`}; // comment`). Deduping on
+* the `Position` object itself shifts each unique position exactly once. Never
+* throws (D-04).
+*/
+function shiftPositionLine(pos, offset, shifted) {
+	if (!pos || shifted.has(pos)) return;
+	shifted.add(pos);
+	pos.line += offset;
+}
+/**
+* Stash a node's `.rzts` origin (once, idempotent) then shift its `loc` lines by
+* `offset`. Byte offsets (`loc.start.index`/`loc.end.index`) and `loc.filename`
+* are NEVER touched. `shifted` dedupes shared `Position` objects (see
+* {@link shiftPositionLine}) so a position aliased across nested nodes — or a
+* comment attached to two adjacent statements — is shifted exactly once
+* (Pitfall 2). Never throws (D-04).
+*/
+function stashAndShiftNode(node, offset, shifted) {
+	const loc = node.loc;
+	if (!loc) return;
+	const extra = node.extra ?? {};
+	if (!("__roziePartialOrigin" in extra)) {
+		const startAlreadyShifted = shifted.has(loc.start);
+		node.extra = {
+			...extra,
+			__roziePartialOrigin: {
+				line: loc.start.line - (startAlreadyShifted ? offset : 0),
+				column: loc.start.column,
+				filename: loc.filename
+			}
+		};
+	}
+	shiftPositionLine(loc.start, offset, shifted);
+	shiftPositionLine(loc.end, offset, shifted);
+}
+/** As {@link stashAndShiftNode} but for a comment (origin stashed on the comment). */
+function stashAndShiftComment(comment, offset, shifted) {
+	const loc = comment.loc;
+	if (!loc) return;
+	const c = comment;
+	if (c.__roziePartialOrigin === void 0) {
+		const startAlreadyShifted = shifted.has(loc.start);
+		c.__roziePartialOrigin = {
+			line: loc.start.line - (startAlreadyShifted ? offset : 0),
+			column: loc.start.column,
+			filename: loc.filename
+		};
+	}
+	shiftPositionLine(loc.start, offset, shifted);
+	shiftPositionLine(loc.end, offset, shifted);
+}
+/** Shift every leading/trailing/inner comment attached to `node`. */
+function shiftAttachedComments(node, offset, shifted) {
+	for (const c of node.leadingComments ?? []) stashAndShiftComment(c, offset, shifted);
+	for (const c of node.trailingComments ?? []) stashAndShiftComment(c, offset, shifted);
+	for (const c of node.innerComments ?? []) stashAndShiftComment(c, offset, shifted);
+}
+/** The line a block's first emitted token occupies: its banner comment if it has
+*  leading comments, else the node itself. */
+function blockFirstEmitLine(firstNode) {
+	const firstLeading = firstNode.leadingComments?.[0]?.loc;
+	return firstLeading ? firstLeading.start.line : firstNode.loc.start.line;
+}
+/**
+* Phase 56-R10 — true when `stmt` is a sigil DIRECTIVE that every target's residual-body
+* emit STRIPS (it is consumed into a non-residual section: lifecycle / context / computed /
+* expose / watch). Mirrors the strip lists in each `emitResidualScriptBody`
+* (`$onMount`/`$onUnmount`/`$onUpdate`/`$watch`/`$expose`/`$provide` ExpressionStatements,
+* and `$computed`/`$inject` VariableDeclarations).
+*
+* USED ONLY to decide whether a spliced LEADING-comment run's IMMEDIATE source predecessor
+* survives in the residual body. When that predecessor is STRIPPED (e.g. the real DataTable
+* `exposeStateVerbs` run sits below a `$provide(...)`), the inline-authored form attaches the
+* boundary comment to the predecessor's `trailingComments` + the spliced decl's
+* `leadingComments` (shared object), but per-statement generation drops the predecessor's
+* trailing copy WITH the stripped statement → the comment SINGLE-emits. The vue/svelte splice
+* mirror would otherwise re-create that prev-trailing copy and DOUBLE it (the R10 bug). When
+* the predecessor SURVIVES (a plain `let`/`const`, e.g. `let expandedTouched` above
+* `groupingActiveDefault`), both copies survive → the inline form DOUBLES and the mirror must
+* keep doing so. Never throws.
+*/
+function isStrippedSigilDirective(stmt) {
+	if (t.isExpressionStatement(stmt) && t.isCallExpression(stmt.expression)) {
+		const callee = stmt.expression.callee;
+		if (t.isIdentifier(callee)) return callee.name === "$onMount" || callee.name === "$onUnmount" || callee.name === "$onUpdate" || callee.name === "$watch" || callee.name === "$expose" || callee.name === "$provide";
+		return false;
+	}
+	if (t.isVariableDeclaration(stmt) && stmt.declarations.length > 0) return stmt.declarations.every((d) => d.init !== null && d.init !== void 0 && t.isCallExpression(d.init) && t.isIdentifier(d.init.callee) && (d.init.callee.name === "$computed" || d.init.callee.name === "$inject"));
+	return false;
+}
+/**
+* Measure the ORIGINAL source gap above a decl run's first emit token (D-02, R2).
+*
+* Returns the `prevEnd + gap` delta the run should flow at: the distance, in source
+* lines, from the run's first emit token (its banner comment if any, else its first
+* node) DOWN from the END of the nearest preceding node IN THE SAME SOURCE FILE — a
+* same-file freshly-hoisted import (`sameFileHoists`) or the prior same-file decl run's
+* last node (`prevRunLastNode`). `gap = firstEmitLine − precedingEnd` so a zero-blank
+* adjacency yields `1` (next line) and N blanks yield `N+1` (no clamp). All `loc`s are
+* still PARTIAL-LOCAL here (the normalize shift runs later), so this reproduces the
+* partial's own pre-extraction layout — which, by the extraction rule, equals the host
+* adjacency the inline oracle has (Pitfall 3: measure source-side, NOT the host seam).
+*
+* When the run's first decl has NO same-file predecessor (a file-top nested-partial
+* decl, e.g. HostD's `inner` at the top of its own file), there is no source delta to
+* measure, so this falls back to the legacy default `2` — preserving the pre-D-02
+* behavior for that shape (no regression). Never throws.
+*/
+function measureOriginalGap(firstNode, sameFileHoists, prevRunLastNode) {
+	const loc = firstNode.loc;
+	if (!loc) return 2;
+	const firstEmitLine = blockFirstEmitLine(firstNode);
+	const fname = loc.filename;
+	let precedingEnd = 0;
+	for (const h of sameFileHoists) {
+		const hl = h.loc;
+		if (hl && hl.filename === fname && hl.end.line < firstEmitLine) precedingEnd = Math.max(precedingEnd, hl.end.line);
+	}
+	const pl = prevRunLastNode?.loc;
+	if (pl && pl.filename === fname && pl.end.line < firstEmitLine) precedingEnd = Math.max(precedingEnd, pl.end.line);
+	if (precedingEnd === 0) return 2;
+	return Math.max(1, firstEmitLine - precedingEnd);
+}
+/**
+* Shift every node + attached comment in a block by `offset`, deduping on the
+* underlying `Position` objects (see {@link shiftPositionLine}). Never throws.
+*
+* WR-01: `shifted` is supplied by the CALLER and SHARED across every block in one
+* normalize pass. A between-statement comment can be aliased across two blocks —
+* `@babel/parser` attaches the comment between a hoisted import and the first decl
+* to BOTH the import's `trailingComments` and the decl's `leadingComments` (the
+* SAME `Position` objects). When the hoist and that decl run land in separate
+* blocks, a per-block `shifted` set would shift the aliased comment TWICE (once per
+* block), corrupting its emit line. A shared set shifts each unique `Position`
+* exactly once. The adjacent hoist/decl offsets are equal by construction (the
+* sequential decl anchor is derived from the shifted hoist end + the same gap the
+* partial's import→decl delta encodes), so first-touch-wins is the correct offset.
+*/
+function shiftBlock(block, offset, shifted) {
+	for (const top of block.nodes) {
+		stashAndShiftNode(top, offset, shifted);
+		shiftAttachedComments(top, offset, shifted);
+		try {
+			traverse$18(t.file(t.program([top])), { enter(path) {
+				stashAndShiftNode(path.node, offset, shifted);
+				shiftAttachedComments(path.node, offset, shifted);
+			} });
+		} catch {}
+	}
+}
+/** Shift a single comment's loc lines by `offset` WITHOUT stashing a partial origin. */
+function shiftCommentLinesOnly(comment, offset, shifted) {
+	const loc = comment.loc;
+	if (!loc) return;
+	shiftPositionLine(loc.start, offset, shifted);
+	shiftPositionLine(loc.end, offset, shifted);
+}
+/**
+* Phase 56-R8 — shift a HOST node's loc + attached/nested comments by `offset`,
+* deduping on the underlying `Position` objects (shared `shifted` set, like
+* {@link shiftBlock}). Never throws (D-04).
+*
+* Unlike {@link shiftBlock} / {@link stashAndShiftNode}, this does NOT stash a
+* `__roziePartialOrigin`: a host statement belongs to the HOST `.rozie` file, so its
+* `loc` is the host source-map anchor and must NOT be re-keyed onto a partial origin
+* (`buildPartialLineOffsets` is per-FILE first-stash-wins and would mis-offset every
+* other host segment). This is invoked ONLY for an after-side host run that carries a
+* GENUINE intended blank below a spliced run (`afterGap >= 2`) — the gap-1 trailing
+* seam. Such runs never appear in any built source-map gate today (dist-parity compiles
+* with `sourceMap: false`; the R5 smoke fixtures have no `afterGap >= 2` host run), so
+* the line shift is invisible to the source-map gates while making the @babel/generator
+* blank-line delta reproduce the source's after-side blank on vue/svelte/solid. The
+* host node's residual source-map LINE imperfection for such runs is the same class of
+* `userCodeLineOffset` limitation already documented in deferred-items.md (#1).
+*/
+function shiftHostNodeLines(node, offset, shifted) {
+	if (offset === 0) return;
+	const apply = (n) => {
+		if (n.loc) {
+			shiftPositionLine(n.loc.start, offset, shifted);
+			shiftPositionLine(n.loc.end, offset, shifted);
+		}
+		for (const c of n.leadingComments ?? []) shiftCommentLinesOnly(c, offset, shifted);
+		for (const c of n.trailingComments ?? []) shiftCommentLinesOnly(c, offset, shifted);
+		for (const c of n.innerComments ?? []) shiftCommentLinesOnly(c, offset, shifted);
+	};
+	apply(node);
+	try {
+		traverse$18(t.file(t.program([node])), { enter(path) {
+			apply(path.node);
+		} });
+	} catch {}
+}
+/**
+* FINAL inline-pass step (Phase 55) — decouple the line `@babel/generator` reads
+* for blank-line/comment placement from the line it reads for the source-map
+* origin, for every spliced partial node.
+*
+* Rationale (RESEARCH Key Finding 1): under `retainLines:false` the generator's
+* comment-adjacency + blank-line math reads `node.loc.start.line` and
+* `comment.loc.start.line` only as DELTAS; only the host↔partial (and
+* partial↔partial) BOUNDARY deltas are wrong (a spliced node carries a small
+* `.rzts`-local line discontinuous with its host neighbour). A CONSTANT per-block
+* offset preserves each block's intra deltas; the right boundary delta is restored
+* by anchoring each block SEQUENTIALLY in residual-body order.
+*
+* SEQUENTIAL ANCHOR (Phase 55-04): each block's first emitted line (its banner
+* comment, else its first node) is anchored ONE blank line below the PRECEDING
+* statement in the final body. Anchoring every block at its own replaced import
+* line (Plan 02's approach) collapsed multi-partial hosts: three consecutive
+* mid-body imports made expand/group/facet pile onto adjacent host lines, so each
+* 30-45-line block overlapped the next and the partial↔partial comment deltas went
+* negative (`}; // banner` collapse). Flowing the blocks sequentially reproduces the
+* inline-authored contiguous layout. The first block (or any block preceded only by
+* un-located content) falls back to its replaced import's host line.
+*
+* WR-01 (whole-program byte-identity): the walk runs over the FULL emit body
+* (`[...hoistImports, ...residualBody]`), NOT just the residual body, so a
+* freshly-hoisted import flows in true emit order ahead of the decls. Consecutive
+* IMPORT blocks anchor CONTIGUOUSLY (gap 1 — no blank between imports); every other
+* run anchors one blank line below the preceding statement (gap 2). Because each
+* source-file decl run is now its OWN block (see {@link SplicedEmitBlock}), a
+* nested-partial decl run flows one blank line below the parent decl run rather than
+* inheriting the hoist's incommensurate file-top offset.
+*
+* TWO PASSES (WR-01): a between-statement comment is aliased across blocks — the
+* `Position` that is a hoisted import's `trailingComments[i]` is the SAME object as
+* the next decl's `leadingComments[i]`. If offsets were applied while walking, the
+* hoist block would shift that comment, and the decl block's `blockFirstEmitLine`
+* would then read the ALREADY-SHIFTED comment line and derive a wrong offset
+* (collapsing the comment onto the decl). So PASS 1 MEASURES every block's offset
+* from ORIGINAL (unmutated) lines, tracking the running emit end arithmetically;
+* PASS 2 MUTATES, applying every offset with ONE shared dedup set so each aliased
+* `Position` shifts exactly once (adjacent hoist/decl offsets are equal by
+* construction, so first-touch-wins is the correct line).
+*
+* Runs AFTER all diagnostics are collected (they captured true `.rzts` byte loc via
+* `nodeLoc`, which reads `node.start`/`node.end`, NOT `loc.{line,column}`), so the
+* R7 error-frame path is untouched (Pitfall 1). Never throws (D-04).
+*/
+function normalizeSplicedEmitLines(body, blocks) {
+	const nodeToBlock = /* @__PURE__ */ new Map();
+	for (const b of blocks) for (const n of b.nodes) nodeToBlock.set(n, b);
+	const measured = /* @__PURE__ */ new Set();
+	const plan = [];
+	let prevEnd = 0;
+	let prevWasImport = false;
+	let prevWasBlock = false;
+	let prevBlockAnchorLine = 0;
+	let hostRunOffset = 0;
+	let seamAfterGap;
+	let prevWasHostStmt = false;
+	let prevHostOrigEnd = 0;
+	let prevHostStmt = null;
+	for (const stmt of body) {
+		const block = nodeToBlock.get(stmt);
+		if (block) {
+			if (measured.has(block)) continue;
+			measured.add(block);
+			const firstNode = block.nodes.find((n) => n.loc);
+			if (!firstNode?.loc) continue;
+			const isImportBlock = t.isImportDeclaration(block.nodes[0]);
+			let gap = isImportBlock && prevWasImport ? 1 : block.originalGap;
+			let stampLeadingSeamStripped = false;
+			if (!isImportBlock && prevWasHostStmt) {
+				const beforeGap = block.anchorLine - prevHostOrigEnd;
+				if (blockFirstEmitLine(firstNode) < firstNode.loc.start.line) {
+					if (beforeGap >= 1 && beforeGap < gap) gap = beforeGap;
+					if (prevHostStmt && isStrippedSigilDirective(prevHostStmt)) stampLeadingSeamStripped = true;
+				}
+			}
+			const offset = (prevEnd > 0 ? prevEnd + gap : block.anchorLine) - blockFirstEmitLine(firstNode);
+			let maxEnd = 0;
+			for (const n of block.nodes) if (n.loc) maxEnd = Math.max(maxEnd, n.loc.end.line);
+			prevEnd = maxEnd + offset;
+			prevWasImport = isImportBlock;
+			prevWasBlock = true;
+			prevWasHostStmt = false;
+			prevHostStmt = null;
+			prevBlockAnchorLine = block.anchorLine;
+			plan.push(stampLeadingSeamStripped ? {
+				block,
+				offset,
+				leadingSeamPrevStripped: true
+			} : {
+				block,
+				offset
+			});
+			continue;
+		}
+		if (stmt.loc) {
+			const firstEmit = blockFirstEmitLine(stmt);
+			let offset;
+			if (prevWasBlock) {
+				const afterGap = firstEmit - prevBlockAnchorLine;
+				if (afterGap >= 2) {
+					offset = prevEnd + afterGap - firstEmit;
+					seamAfterGap = afterGap;
+				} else offset = 0;
+				hostRunOffset = offset;
+			} else offset = hostRunOffset;
+			if (offset !== 0) plan.push(seamAfterGap !== void 0 ? {
+				hostNode: stmt,
+				offset,
+				afterGap: seamAfterGap
+			} : {
+				hostNode: stmt,
+				offset
+			});
+			prevEnd = stmt.loc.end.line + offset;
+			seamAfterGap = void 0;
+			prevWasImport = t.isImportDeclaration(stmt);
+			prevWasBlock = false;
+			prevWasHostStmt = true;
+			prevHostOrigEnd = stmt.loc.end.line;
+			prevHostStmt = stmt;
+		}
+	}
+	for (const block of blocks) {
+		if (measured.has(block)) continue;
+		measured.add(block);
+		const firstNode = block.nodes.find((n) => n.loc);
+		if (!firstNode?.loc) continue;
+		plan.push({
+			block,
+			offset: block.anchorLine - blockFirstEmitLine(firstNode)
+		});
+	}
+	const shifted = /* @__PURE__ */ new Set();
+	for (const entry of plan) if ("block" in entry) {
+		shiftBlock(entry.block, entry.offset, shifted);
+		if (entry.leadingSeamPrevStripped) {
+			const firstNode = entry.block.nodes.find((n) => n.loc);
+			if (firstNode) firstNode.extra = {
+				...firstNode.extra ?? {},
+				__rozieLeadingSeamPrevStripped: true
+			};
+		}
+	} else {
+		shiftHostNodeLines(entry.hostNode, entry.offset, shifted);
+		if (entry.afterGap !== void 0) {
+			const extra = entry.hostNode.extra ?? {};
+			entry.hostNode.extra = {
+				...extra,
+				__rozieAfterGap: entry.afterGap
+			};
+		}
+	}
+}
+/**
+* Phase 56 (Shape-3, R4) — un-FLOAT a hoisted import's between-statement comment that
+* has separated from its owning declaration.
+*
+* `hoistSpecifier` copies a partial import's `trailingComments` onto the HOISTED import
+* node so a comment authored BETWEEN that import and the next surviving decl rides the
+* import to the host module-top (Phase 55 byte-identity). @babel/parser attaches such a
+* between-statement comment to BOTH neighbours: the import's `trailingComments` AND the
+* following decl's `leadingComments` (the SAME comment object). That copy is CORRECT
+* only when the import and its decl stay ADJACENT in the final body (e.g. HostC: the
+* hoisted `clamp` import is immediately followed by the `double` decl it shares the
+* comment with — the inline oracle ALSO has the comment on both neighbours, so
+* per-statement targets double it identically).
+*
+* When the spliced decl lands NON-adjacent to its hoisted import — a host statement
+* (e.g. a reassigned module-`let`) sits between them (HostH/the DataTable P15
+* `editTransition` after-`let` seam) — the import's copy FLOATS the comment to
+* module-top, away from the decl. The inline oracle keeps the comment ONLY on the decl
+* (its import is authored far above, never adjacent), so the float is a partial-vs-inline
+* divergence on ALL six targets (svelte/vue double it at the wrong place, react/angular/
+* lit drop it, solid dedups). This pass restores the inline placement by STRIPPING the
+* floated comment from the import's `trailingComments`; the decl keeps it on its
+* `leadingComments` (object identity preserved), and the per-target emitters then handle
+* the decl-attached comment exactly as they do for the inline oracle (svelte/vue's
+* `mirrorSpliceBoundaryComments` restores the doubling at the decl seam).
+*
+* Runs BEFORE `normalizeSplicedEmitLines` so the corrected attachment is in place when
+* the emit-line shift runs. A comment is treated as FLOATED iff it is shared (object
+* identity) with some body node's `leadingComments` whose owner is NOT the import's
+* immediate body-successor; a genuine import-only trailing comment (owned by no decl's
+* leadingComments) and the adjacent-decl case (HostC) are both left untouched. Never
+* throws (D-04).
+*/
+function defloatHoistedImportComments(body, hoistImports) {
+	if (hoistImports.length === 0) return;
+	const hoistSet = new Set(hoistImports);
+	const leadOwnerIndex = /* @__PURE__ */ new Map();
+	for (let i = 0; i < body.length; i++) for (const c of body[i].leadingComments ?? []) if (!leadOwnerIndex.has(c)) leadOwnerIndex.set(c, i);
+	for (let hi = 0; hi < body.length; hi++) {
+		const node = body[hi];
+		if (!hoistSet.has(node)) continue;
+		const trailing = node.trailingComments;
+		if (!trailing || trailing.length === 0) continue;
+		const kept = trailing.filter((c) => {
+			const owner = leadOwnerIndex.get(c);
+			if (owner === void 0) return true;
+			if (owner === hi + 1) return true;
+			return false;
+		});
+		if (kept.length !== trailing.length) node.trailingComments = kept.length > 0 ? kept : null;
+	}
+}
 /** Build the named imported-name list for a (host or nested) partial import. */
 function namedImports(imp) {
 	const out = [];
@@ -18758,6 +19274,7 @@ function inlineResolvedPartial(absPath, importedNames, importStmt, importerFile,
 		const nestedImports = [];
 		/** local name -> nested partial resolved path + the imported name. */
 		const nestedLocalMap = /* @__PURE__ */ new Map();
+		const reExports = [];
 		let order = 0;
 		for (const stmt of partialBody) {
 			if (t.isImportDeclaration(stmt)) {
@@ -18783,9 +19300,47 @@ function inlineResolvedPartial(absPath, importedNames, importStmt, importerFile,
 				} else moduleImports.push(stmt);
 				continue;
 			}
+			if (t.isExportNamedDeclaration(stmt) && !stmt.declaration && stmt.source) {
+				const src = stmt.source;
+				const declTypeOnly = stmt.exportKind === "type";
+				for (const spec of stmt.specifiers) if (t.isExportSpecifier(spec)) {
+					const exportedName = t.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value;
+					const kind = declTypeOnly || spec.exportKind === "type" ? "type" : "value";
+					const localId = spec.local;
+					reExports.push({
+						exportedName,
+						source: src,
+						kind,
+						build: () => t.importSpecifier(t.identifier(exportedName), t.identifier(localId.name))
+					});
+				} else if (t.isExportNamespaceSpecifier(spec)) {
+					const nsName = spec.exported.name;
+					reExports.push({
+						exportedName: nsName,
+						source: src,
+						kind: declTypeOnly ? "type" : "value",
+						build: () => t.importNamespaceSpecifier(t.identifier(nsName))
+					});
+				}
+				continue;
+			}
+			if (t.isExportAllDeclaration(stmt)) {
+				ctx.diagnostics.push({
+					code: RozieErrorCode.PARTIAL_UNSUPPORTED_IMPORT_FORM,
+					severity: "error",
+					message: `Script partial '${absPath}' uses \`export * from '${stmt.source.value}'\`. A star re-export has no statically-known named surface to inline — a partial is a compile-time inline, so each re-exported symbol must be named (e.g. \`export { foo } from '${stmt.source.value}'\`).`,
+					loc: nodeLoc(stmt),
+					...absPath ? { filename: absPath } : {},
+					hint: `Replace the star re-export with explicit named re-exports: export { foo, bar } from '${stmt.source.value}'.`
+				});
+				continue;
+			}
 			let bare = null;
-			if (t.isExportNamedDeclaration(stmt) && stmt.declaration) bare = stmt.declaration;
-			else if (t.isVariableDeclaration(stmt) || t.isFunctionDeclaration(stmt) || t.isClassDeclaration(stmt) || t.isTSInterfaceDeclaration(stmt) || t.isTSTypeAliasDeclaration(stmt) || t.isTSEnumDeclaration(stmt) || t.isTSDeclareFunction(stmt)) bare = stmt;
+			if (t.isExportNamedDeclaration(stmt) && stmt.declaration) {
+				bare = stmt.declaration;
+				const prevStmt = partialBody[partialBody.indexOf(stmt) - 1];
+				if ((prevStmt && t.isImportDeclaration(prevStmt) && !PARTIAL_EXT.test(prevStmt.source.value) && prevStmt.trailingComments && stmt.leadingComments ? stmt.leadingComments.some((c) => prevStmt.trailingComments.includes(c)) : false) && stmt.leadingComments && stmt.leadingComments.length > 0 && (!bare.leadingComments || bare.leadingComments.length === 0)) bare.leadingComments = stmt.leadingComments;
+			} else if (t.isVariableDeclaration(stmt) || t.isFunctionDeclaration(stmt) || t.isClassDeclaration(stmt) || t.isTSInterfaceDeclaration(stmt) || t.isTSTypeAliasDeclaration(stmt) || t.isTSEnumDeclaration(stmt) || t.isTSDeclareFunction(stmt)) bare = stmt;
 			if (!bare) continue;
 			const names = bindingNames(bare);
 			if (names.length === 0) continue;
@@ -18838,8 +19393,9 @@ function inlineResolvedPartial(absPath, importedNames, importStmt, importerFile,
 		}
 		for (const imp of moduleImports) {
 			const declKind = imp.importKind ?? "value";
-			for (const spec of imp.specifiers) if (referencedAll.has(spec.local.name)) hoistSpecifier(ctx, imp.source, declKind, spec);
+			for (const spec of imp.specifiers) if (referencedAll.has(spec.local.name)) hoistSpecifier(ctx, imp.source, declKind, spec, imp);
 		}
+		for (const re of reExports) if (importedNames.includes(re.exportedName) || referencedAll.has(re.exportedName)) hoistSpecifier(ctx, re.source, re.kind, re.build());
 		const out = [];
 		for (const decl of includedSorted) {
 			const collidingNames = [];
@@ -18929,6 +19485,7 @@ function inlineScriptPartials(file, opts = {}) {
 		}
 	}
 	const splicedAbs = /* @__PURE__ */ new Set();
+	const splicedBlocks = [];
 	const newBody = [];
 	for (const stmt of file.program.body) if (t.isImportDeclaration(stmt) && PARTIAL_EXT.test(stmt.source.value)) {
 		const absPath = hostPartialAbs.get(stmt) ?? null;
@@ -18957,9 +19514,38 @@ function inlineScriptPartials(file, opts = {}) {
 		if (splicedAbs.has(absPath)) continue;
 		splicedAbs.add(absPath);
 		const unionNames = hostPartialNames.get(absPath) ?? namedImports(stmt);
-		newBody.push(...inlineResolvedPartial(absPath, unionNames, stmt, fromFile, ctx));
+		const hoistBefore = ctx.hoistImports.length;
+		const spliced = inlineResolvedPartial(absPath, unionNames, stmt, fromFile, ctx);
+		const newHoists = ctx.hoistImports.slice(hoistBefore);
+		if (stmt.loc) {
+			const anchorLine = stmt.loc.start.line;
+			for (const hoist of newHoists) splicedBlocks.push({
+				nodes: [hoist],
+				anchorLine,
+				originalGap: 1
+			});
+			let runStart = 0;
+			let prevRunLastNode = null;
+			while (runStart < spliced.length) {
+				const fname = spliced[runStart].loc?.filename ?? null;
+				let runEnd = runStart + 1;
+				while (runEnd < spliced.length && (spliced[runEnd].loc?.filename ?? null) === fname) runEnd++;
+				const nodes = spliced.slice(runStart, runEnd);
+				const originalGap = measureOriginalGap(nodes.find((n) => n.loc) ?? nodes[0], newHoists, prevRunLastNode);
+				splicedBlocks.push({
+					nodes,
+					anchorLine,
+					originalGap
+				});
+				prevRunLastNode = nodes[nodes.length - 1] ?? prevRunLastNode;
+				runStart = runEnd;
+			}
+		}
+		newBody.push(...spliced);
 	} else newBody.push(stmt);
 	file.program.body = [...ctx.hoistImports, ...newBody];
+	defloatHoistedImportComments(file.program.body, ctx.hoistImports);
+	normalizeSplicedEmitLines(file.program.body, splicedBlocks);
 	return {
 		ast: file,
 		diagnostics
@@ -21266,6 +21852,27 @@ function rewriteRozieIdentifiers$4(program, ir, diagnostics) {
 		loc: ref.sourceLoc
 	});
 	normalizeModelAccessor$4(program);
+	const vueProtected = new Set((ir.expose ?? []).map((e) => e.name));
+	deconflictGeneratedSymbols(program, [
+		{
+			names: modelProps,
+			trigger: {
+				kind: "accessor",
+				accessor: "$props"
+			}
+		},
+		{
+			names: dataNames,
+			trigger: {
+				kind: "accessor",
+				accessor: "$data"
+			}
+		},
+		{
+			names: computedNames,
+			trigger: { kind: "bare-read" }
+		}
+	], vueProtected);
 	traverse$17(program, {
 		MemberExpression(path) {
 			/* v8 ignore next -- defensive: MemberExpression nodes do not occur in TS type position */
@@ -21786,6 +22393,80 @@ function arrowBody$4(body) {
 	return genCode$9(t.arrowFunctionExpression([], body));
 }
 /**
+* Phase 55-04 (literal byte-identity) — reproduce the inline-authored comment
+* doubling at a script-partial splice boundary.
+*
+* In an inline-authored `<script>`, a comment block BETWEEN two statements is
+* attached by `@babel/parser` to BOTH neighbours (the earlier statement's
+* `trailingComments` AND the later statement's `leadingComments`). The `.rzts`
+* script-partial splice attaches the boundary banner ONLY to the spliced node's
+* `leadingComments` — the preceding statement lives in a different source file and
+* carries no matching trailing comment. Vue emits the residual body one statement
+* at a time (`stmts.map((s) => genCode(s)).join('\n')`), so each `genCode` call has
+* its own comment-dedup set: in the inline form the boundary banner therefore
+* prints TWICE (once as the previous statement's trailing, once as the next
+* statement's leading), with a blank line after the previous closing brace.
+* Re-mirroring the spliced node's leading comments back onto the preceding
+* statement's trailing comments restores that byte-for-byte.
+*
+* Fires at a genuine splice boundary in EITHER direction (Phase 56 R1 broadened
+* the trigger): the CURRENT statement is spliced (`cur.extra.__roziePartialOrigin`
+* — the Phase 55 leading seam) OR the PREVIOUS statement is spliced and CUR is an
+* inline host successor carrying the leading comment (the R1 TRAILING seam). In
+* both cases CUR's leading comments are mirrored onto PREV's trailing comments
+* UNLESS already shared (within-partial statement pairs share the same comment
+* objects; host-only pairs — neither node spliced — are left exactly as authored).
+* `normalizeSplicedEmitLines` (core) has already anchored the seam spacing, so the
+* mirrored trailing copy spaces correctly.
+*/
+function mirrorSpliceBoundaryComments$2(stmts) {
+	for (let i = 1; i < stmts.length; i++) {
+		const cur = stmts[i];
+		const prev = stmts[i - 1];
+		const curExtra = cur.extra;
+		const prevExtra = prev.extra;
+		const curSpliced = curExtra?.__roziePartialOrigin !== void 0;
+		const prevSpliced = prevExtra?.__roziePartialOrigin !== void 0;
+		if (!curSpliced && !prevSpliced) continue;
+		const lead = cur.leadingComments;
+		const prevTrail = prev.trailingComments;
+		if (curSpliced && !prevSpliced && (!lead || lead.length === 0) && prevTrail && prevTrail.length > 0) {
+			cur.leadingComments = [...prevTrail];
+			continue;
+		}
+		if (!lead || lead.length === 0) continue;
+		if (curSpliced && curExtra?.__rozieLeadingSeamPrevStripped === true) continue;
+		const lastLead = lead[lead.length - 1];
+		if (prevTrail && prevTrail.length > 0 && prevTrail[prevTrail.length - 1] === lastLead) continue;
+		let toAppend = lead;
+		if (prevSpliced && !curSpliced) {
+			const afterGap = curExtra?.__rozieAfterGap;
+			const anchorLine = (prev.loc?.end.line ?? 0) + (typeof afterGap === "number" ? afterGap : 1);
+			const baseLine = lead[0]?.loc?.start.line;
+			toAppend = lead.map((c) => {
+				if (!c.loc) return { ...c };
+				const startLine = baseLine === void 0 ? anchorLine : anchorLine + (c.loc.start.line - baseLine);
+				const endLine = baseLine === void 0 ? anchorLine : anchorLine + (c.loc.end.line - baseLine);
+				return {
+					...c,
+					loc: {
+						...c.loc,
+						start: {
+							...c.loc.start,
+							line: startLine
+						},
+						end: {
+							...c.loc.end,
+							line: endLine
+						}
+					}
+				};
+			});
+		}
+		prev.trailingComments = [...prevTrail ?? [], ...toAppend];
+	}
+}
+/**
 * Render a PropTypeAnnotation as a TypeScript type string.
 *
 * Reference examples produce these patterns:
@@ -22240,6 +22921,7 @@ function emitResidualScriptBody$1(clonedProgram, consumedLifecycleIndices) {
 		}
 		stmts.push(stmt);
 	}
+	mirrorSpliceBoundaryComments$2(stmts);
 	return {
 		code: stmts.map((s) => genCode$9(s)).join("\n"),
 		stmts
@@ -24881,7 +25563,8 @@ function remapping$1(input, loader, options) {
 * (the "parent" map) via @ampproject/remapping. Result: a single Source Map
 * v3 that resolves emitted-output positions all the way back to .rozie.
 *
-* Used by all 4 target compose.ts files. Replaces the per-target
+* Used by all 6 target compose.ts files (react/vue/svelte/solid/lit/angular).
+* Replaces the per-target
 * single-segment re-projection hack (Phase 3 WR-01 / Phase 4 Plan 04-05
 * Task 1) removed in P2 (D-109).
 *
@@ -24894,7 +25577,114 @@ function remapping$1(input, loader, options) {
 * @experimental — shape may change before v1.0
 */
 const remapping = typeof remapping$1 === "function" ? remapping$1 : remapping$1.default;
+/** Source-file extension test: a spliced script partial origin (Phase 54/55). */
+function isPartialSource(src) {
+	return !!src && (src.endsWith(".rzts") || src.endsWith(".rzjs"));
+}
+/**
+* Recover a partial source's constant emit-line offset from the table. The table
+* is keyed by the absolute `loc.filename` stashed at splice time; a child map's
+* `sources` entry is the same absolute path, so an EXACT lookup is tried first.
+*
+* WR-03: the defensive fallback is restricted to a path-SEGMENT-BOUNDARY match
+* (`src.endsWith('/' + file) || file.endsWith('/' + src)`) so a partial whose path
+* is a bare substring of another's (e.g. `xa.rzts` vs `a.rzts`) never collides, and
+* — critically — if TWO OR MORE table entries match the boundary test (an ambiguous
+* bare basename shared across nested dirs) the lookup BAILS (returns `undefined`)
+* rather than mis-attributing one partial's offset to another. Returns `undefined`
+* when no unambiguous offset is known (mapping left as-is — D-04).
+*/
+function lookupPartialOffset(src, offsets) {
+	if (!src || !offsets || offsets.size === 0) return void 0;
+	const exact = offsets.get(src);
+	if (exact !== void 0) return exact;
+	let match;
+	let matchCount = 0;
+	for (const [file, off] of offsets) if (src.endsWith(`/${file}`) || file.endsWith(`/${src}`)) {
+		match = off;
+		matchCount++;
+	}
+	return matchCount === 1 ? match : void 0;
+}
+/**
+* Phase 55 Plan 03 (SC-2) — build the per-partial-file constant emit-line offset
+* table from the lowered script AST.
+*
+* Plan 02 shifted each spliced node's `loc.start.line` to a host-contiguous emit
+* value while stashing the true `.rzts` origin on `extra.__roziePartialOrigin`.
+* The per-partial offset is therefore the (constant) delta
+* `loc.start.line − __roziePartialOrigin.line`; subtracting it from a mapping's
+* original line restores the `.rzts`-local line. The offset is constant per
+* spliced block (Plan 02 anchored it), so one entry per partial `source` file
+* suffices — the first stashed node per file wins.
+*
+* Walks `scriptAst.program.body` (the spliced statements sit at top level) and
+* their attached leading/trailing/inner comments (comments carry the stash
+* directly). Never throws (D-04): a missing/zero stash is skipped, a null AST
+* yields an empty table.
+*
+* IN-02: the `innerComments` loop mirrors `shiftAttachedComments`
+* (inlineScriptPartials.ts) which walks leading/trailing/inner. In practice the
+* offset is per-file and first-stash-wins, so a leading/trailing comment or the
+* decl itself almost always supplies it — the inner loop is additive and harmless,
+* kept only so the stash-channel scan is symmetric with where stashes are written.
+*/
+function buildPartialLineOffsets(scriptAst) {
+	const out = /* @__PURE__ */ new Map();
+	const body = scriptAst?.program?.body;
+	if (!body) return out;
+	const record = (carrier, locLine) => {
+		const origin = carrier?.__roziePartialOrigin;
+		if (!origin || locLine === void 0) return;
+		const key = origin.filename;
+		if (!key || out.has(key)) return;
+		out.set(key, locLine - origin.line);
+	};
+	for (const node of body) {
+		const extra = node.extra;
+		record(extra, node.loc?.start.line);
+		for (const c of node.leadingComments ?? []) record(c, c.loc?.start.line);
+		for (const c of node.trailingComments ?? []) record(c, c.loc?.start.line);
+		for (const c of node.innerComments ?? []) record(c, c.loc?.start.line);
+	}
+	return out;
+}
 /**
+* Phase 55 Plan 03 — per-target script-map flow survey (Task 1, Assumption A3).
+*
+* SURVEY RESULT (confirmed on disk 2026-06-20):
+*
+*  1. CONVERGENCE — all SIX per-target `sourcemap/compose.ts` wrappers
+*     (react/vue/svelte/solid/lit/angular) import THIS `composeMaps` and route
+*     their @babel/generator <script> child map through it as `children[0]`. No
+*     target hand-rolls a second map merge; `composeMaps` is the single
+*     convergence point, so the spliced-line restore arithmetic lives here ONCE
+*     (D-03/D-05 uniformity) — never in a per-target wrapper or `emitScript.ts`.
+*
+*  2. ACTIVE MAP PATH — the five map-EMITTING targets (react/vue/svelte/solid/
+*     angular) all pass a defined `userCodeLineOffset`, so each takes the
+*     `userCodeLineOffset` branch below (step 3). Empirically, that branch
+*     discarded the child map's per-node `sources` (it hardcoded `[opts.filename]`),
+*     collapsing a spliced node's `.rzts` origin to the host `.rozie` — which is
+*     exactly why the SC-2 line-fidelity smoke test was red/skipped. The restore
+*     therefore lives in step 3. The step-4 remapping path is NOT exercised by
+*     partials (every map-emitting target passes `userCodeLineOffset`), so it is
+*     deliberately left untouched rather than carrying speculative dead code.
+*
+*  3. TABLE BUILD SITE — each of those five `emitXxx.ts` holds the lowered `ir`
+*     (whose `ir.setupBody.scriptProgram` script AST carries the spliced nodes'
+*     `extra.__roziePartialOrigin` stashes from Plan 02). Each builds the
+*     `partialLineOffsets` table via {@link buildPartialLineOffsets} and threads
+*     it into the `ComposeOpts` it already constructs. The table derives from the
+*     IR, NOT from generator output — so NO `emitScript.ts` (the @babel/generator
+*     caller) is touched (D-03).
+*
+*  4. LIT EXCEPTION — `packages/targets/lit/src/emitLit.ts` returns `map: null`
+*     in v1 and does NOT call `composeSourceMap` (the wrapper is implemented but
+*     dead until Phase 7 wires it). Lit therefore has no build+set site; its
+*     wrapper still receives the `partialLineOffsets` field for forward-compat so
+*     the restore flows automatically once Lit's map path is connected.
+*
 * Merge the shell map + zero-or-more child maps into a single Source Map v3
 * anchored to .rozie. Defensively re-asserts sources/sourcesContent per
 * Pitfall 2 mitigation.
@@ -24913,6 +25703,27 @@ function composeMaps(opts) {
 	}
 	if (opts.userCodeLineOffset !== void 0) {
 		const childMap = opts.children[0].map;
+		const childSources = childMap.sources ?? [];
+		if (childSources.some((s) => isPartialSource(s)) && !!opts.partialLineOffsets && opts.partialLineOffsets.size > 0) {
+			const decoded = decode(childMap.mappings);
+			for (const line of decoded) for (const seg of line) if (seg.length >= 4) {
+				const full = seg;
+				const src = childSources[full[1]];
+				const off = lookupPartialOffset(src, opts.partialLineOffsets);
+				if (off !== void 0) full[2] = Math.max(0, full[2] - off);
+			}
+			const restoredMappings = encode(decoded);
+			const sources = childSources.slice();
+			const sourcesContent = sources.map((s, i) => s === opts.filename ? opts.source : childMap.sourcesContent?.[i] ?? null);
+			return {
+				version: 3,
+				file: `${opts.filename}${opts.fileExt}`,
+				sources,
+				sourcesContent,
+				names: childMap.names ?? [],
+				mappings: ";".repeat(opts.userCodeLineOffset) + restoredMappings
+			};
+		}
 		return {
 			version: 3,
 			file: `${opts.filename}${opts.fileExt}`,
@@ -24946,7 +25757,8 @@ function composeSourceMap$4(ms, opts) {
 			outputOffset: opts.scriptOutputOffset
 		}] : [],
 		fileExt: ".vue",
-		userCodeLineOffset: opts.userCodeLineOffset
+		userCodeLineOffset: opts.userCodeLineOffset,
+		partialLineOffsets: opts.partialLineOffsets
 	});
 }
 //#endregion
@@ -25131,7 +25943,8 @@ function emitVue(ir, opts = {}) {
 			source: opts.source,
 			scriptMap: shellScriptMap,
 			scriptOutputOffset,
-			userCodeLineOffset
+			userCodeLineOffset,
+			partialLineOffsets: buildPartialLineOffsets(ir.setupBody.scriptProgram)
 		}) : null,
 		diagnostics: [
 			...scriptDiags,
@@ -29072,7 +29885,8 @@ function composeClassName(attrs, ctx) {
 	});
 	else segments.push({
 		kind: "plainBinding",
-		expr: a.expression
+		expr: a.expression,
+		wrapForDisplay: a.wrapForDisplay
 	});
 	else if (a.kind === "spreadBinding") throw new Error(`React target: spreadBinding not valid in class array context (Phase 14).`);
 	else segments.push({
@@ -29094,6 +29908,10 @@ function composeClassName(attrs, ctx) {
 		const seg = segments[0];
 		const staticSegs = decomposeStaticClassExpr(seg.expr);
 		if (staticSegs) return renderInterpolatedClass(staticSegs, ctx);
+		if (seg.wrapForDisplay) {
+			ctx.collectors.runtime.add("clsx");
+			return `clsx(${renderExpr$1(seg.expr, ir)})`;
+		}
 		return renderExpr$1(seg.expr, ir);
 	}
 	if (segments.length === 1 && segments[0].kind === "interpolated") {
@@ -34928,7 +35746,8 @@ function composeSourceMap$3(ms, opts) {
 			outputOffset: opts.scriptOutputOffset
 		}] : [],
 		fileExt: ".tsx",
-		userCodeLineOffset: opts.userCodeLineOffset
+		userCodeLineOffset: opts.userCodeLineOffset,
+		partialLineOffsets: opts.partialLineOffsets
 	});
 }
 //#endregion
@@ -35031,7 +35850,8 @@ function emitReact(ir, opts = {}) {
 			source: opts.source,
 			scriptMap: shellScriptMap,
 			scriptOutputOffset,
-			userCodeLineOffset
+			userCodeLineOffset,
+			partialLineOffsets: buildPartialLineOffsets(ir.setupBody.scriptProgram)
 		}) : null,
 		diagnostics: [
 			...scriptDiags,
@@ -36025,6 +36845,80 @@ function arrowBody$2(body) {
 	return genCode$5(t.arrowFunctionExpression([], body));
 }
 /**
+* Phase 55-04 (literal byte-identity) — reproduce the inline-authored comment
+* doubling at a script-partial splice boundary.
+*
+* In an inline-authored `<script>`, a comment block BETWEEN two statements is
+* attached by `@babel/parser` to BOTH neighbours (the earlier statement's
+* `trailingComments` AND the later statement's `leadingComments`). The `.rzts`
+* script-partial splice attaches the boundary banner ONLY to the spliced node's
+* `leadingComments` — the preceding statement lives in a different source file and
+* carries no matching trailing comment. Svelte emits the residual body one
+* statement at a time (`stmts.map((s) => genCode(s)).join('\n')`), so each
+* `genCode` call has its own comment-dedup set: in the inline form the boundary
+* banner therefore prints TWICE (once as the previous statement's trailing, once
+* as the next statement's leading), with a blank line after the previous closing
+* brace. Re-mirroring the spliced node's leading comments back onto the preceding
+* statement's trailing comments restores that byte-for-byte.
+*
+* Fires at a genuine splice boundary in EITHER direction (Phase 56 R1 broadened
+* the trigger): the CURRENT statement is spliced (`cur.extra.__roziePartialOrigin`
+* — the Phase 55 leading seam) OR the PREVIOUS statement is spliced and CUR is an
+* inline host successor carrying the leading comment (the R1 TRAILING seam). In
+* both cases CUR's leading comments are mirrored onto PREV's trailing comments
+* UNLESS already shared (within-partial statement pairs share the same comment
+* objects; host-only pairs — neither node spliced — are left exactly as authored).
+* `normalizeSplicedEmitLines` (core) has already anchored the seam spacing, so the
+* mirrored trailing copy spaces correctly.
+*/
+function mirrorSpliceBoundaryComments$1(stmts) {
+	for (let i = 1; i < stmts.length; i++) {
+		const cur = stmts[i];
+		const prev = stmts[i - 1];
+		const curExtra = cur.extra;
+		const prevExtra = prev.extra;
+		const curSpliced = curExtra?.__roziePartialOrigin !== void 0;
+		const prevSpliced = prevExtra?.__roziePartialOrigin !== void 0;
+		if (!curSpliced && !prevSpliced) continue;
+		const lead = cur.leadingComments;
+		const prevTrail = prev.trailingComments;
+		if (curSpliced && !prevSpliced && (!lead || lead.length === 0) && prevTrail && prevTrail.length > 0) {
+			cur.leadingComments = [...prevTrail];
+			continue;
+		}
+		if (!lead || lead.length === 0) continue;
+		if (curSpliced && curExtra?.__rozieLeadingSeamPrevStripped === true) continue;
+		const lastLead = lead[lead.length - 1];
+		if (prevTrail && prevTrail.length > 0 && prevTrail[prevTrail.length - 1] === lastLead) continue;
+		let toAppend = lead;
+		if (prevSpliced && !curSpliced) {
+			const afterGap = curExtra?.__rozieAfterGap;
+			const anchorLine = (prev.loc?.end.line ?? 0) + (typeof afterGap === "number" ? afterGap : 1);
+			const baseLine = lead[0]?.loc?.start.line;
+			toAppend = lead.map((c) => {
+				if (!c.loc) return { ...c };
+				const startLine = baseLine === void 0 ? anchorLine : anchorLine + (c.loc.start.line - baseLine);
+				const endLine = baseLine === void 0 ? anchorLine : anchorLine + (c.loc.end.line - baseLine);
+				return {
+					...c,
+					loc: {
+						...c.loc,
+						start: {
+							...c.loc.start,
+							line: startLine
+						},
+						end: {
+							...c.loc.end,
+							line: endLine
+						}
+					}
+				};
+			});
+		}
+		prev.trailingComments = [...prevTrail ?? [], ...toAppend];
+	}
+}
+/**
 * Render a PropTypeAnnotation as a TypeScript type string. Mirrors the Vue
 * target's renderType helper.
 */
@@ -36463,6 +37357,7 @@ function emitResidualScriptBody(clonedProgram, consumedLifecycleIndices, exposeN
 		}
 		stmts.push(stmt);
 	}
+	mirrorSpliceBoundaryComments$1(stmts);
 	return {
 		code: stmts.map((s) => {
 			if (exposeNames.size > 0 && isExposedTopLevelDecl(s, exposeNames)) {
@@ -37126,6 +38021,14 @@ function emitSingleAttr$1(attr, ctx) {
 		if (styleObjectLowered !== null) return styleObjectLowered;
 		const expr = rewriteTemplateExpression$3(attr.expression, ir);
 		const outName = resolveAttrName(attr.name, ctx);
+		if (attr.name === "style") {
+			ctx.runtimeImports?.add("rozieStyle");
+			return `${outName}={rozieStyle(${expr})}`;
+		}
+		if (attr.name === "class" && attr.wrapForDisplay && !t.isObjectExpression(attr.expression) && !t.isTemplateLiteral(attr.expression) && shouldWrapSvelteAttrBinding(attr.name, attr.expression, ctx)) {
+			ctx.runtimeImports?.add("rozieClass");
+			return `${outName}={rozieClass(${expr})}`;
+		}
 		if (attr.wrapForDisplay && shouldWrapSvelteAttrBinding(attr.name, attr.expression, ctx)) {
 			ctx.runtimeImports?.add("rozieAttr");
 			return `${outName}={rozieAttr(${expr})}`;
@@ -37153,12 +38056,16 @@ function emitSingleAttr$1(attr, ctx) {
 * Convert a single AttributeBinding into a JS expression string suitable for
 * inclusion in an array (used by class/style merge below).
 */
-function attrToArraySegment$1(attr, ir, runtimeImports) {
+function attrToArraySegment$1(attr, ir, runtimeImports, isClass = false) {
 	if (attr.kind === "twoWayBinding") throw new Error(`Svelte target: twoWayBinding not valid in class/style array context (Phase 07.3 Wave 3 Plan 07.3-04).`);
 	if (attr.kind === "static") return JSON.stringify(attr.value);
 	if (attr.kind === "binding") {
 		const code = rewriteTemplateExpression$3(attr.expression, ir);
 		if (attr.wrapForDisplay && !t.isObjectExpression(attr.expression)) {
+			if (isClass && !t.isTemplateLiteral(attr.expression)) {
+				runtimeImports?.add("rozieClass");
+				return `rozieClass(${code})`;
+			}
 			runtimeImports?.add("rozieDisplay");
 			return `rozieDisplay(${code})`;
 		}
@@ -37249,7 +38156,7 @@ function emitAttributes$2(attrs, ctx) {
 					if (synthetic) merged.push(synthetic);
 				} else if (src.name === a.name && !isLiteralStyleObjectBinding(src)) merged.push(src);
 				for (const x of merged) consumed.add(x);
-				const segments = merged.map((x) => attrToArraySegment$1(x, ctx.ir, ctx.runtimeImports));
+				const segments = merged.map((x) => attrToArraySegment$1(x, ctx.ir, ctx.runtimeImports, a.name === "class"));
 				if (hasOpaqueMerge) for (const readExpr of opaqueSpreadClassReads) segments.push(readExpr);
 				if (hasOpaqueMerge) deferredMergedClassStyle.push(`${a.name}={[${segments.join(", ")}]}`);
 				else out.push(`${a.name}={[${segments.join(", ")}]}`);
@@ -38741,7 +39648,8 @@ function composeSourceMap$2(ms, opts) {
 			outputOffset: opts.scriptOutputOffset
 		}] : [],
 		fileExt: ".svelte",
-		userCodeLineOffset: opts.userCodeLineOffset
+		userCodeLineOffset: opts.userCodeLineOffset,
+		partialLineOffsets: opts.partialLineOffsets
 	});
 }
 //#endregion
@@ -38845,7 +39753,8 @@ function emitSvelte(ir, opts = {}) {
 			source: opts.source,
 			scriptMap: shellScriptMap,
 			scriptOutputOffset,
-			userCodeLineOffset
+			userCodeLineOffset,
+			partialLineOffsets: buildPartialLineOffsets(ir.setupBody.scriptProgram)
 		}) : null,
 		diagnostics: [
 			...scriptDiags,
@@ -40116,7 +41025,15 @@ function buildSlotCtx(slot) {
 */
 function buildNgTemplateContextGuard(componentName, slots) {
 	if (slots.length === 0) return null;
-	const unionType = slots.map((s) => slotCtxName(s.name)).join(" | ");
+	const seenCtxNames = /* @__PURE__ */ new Set();
+	const ctxNames = [];
+	for (const s of slots) {
+		const ctxName = slotCtxName(s.name);
+		if (seenCtxNames.has(ctxName)) continue;
+		seenCtxNames.add(ctxName);
+		ctxNames.push(ctxName);
+	}
+	const unionType = ctxNames.join(" | ");
 	return [
 		`static ngTemplateContextGuard(`,
 		`  _dir: ${componentName},`,
@@ -40908,7 +41825,10 @@ function emitScript$2(ir, opts = {}) {
 	const interfaceDecls = [];
 	for (const typeDecl of hoistedTypeDecls) interfaceDecls.push(genCode$3(typeDecl));
 	const slotFieldDecls = [];
+	const seenSlotNames = /* @__PURE__ */ new Set();
 	for (const slot of ir.slots) {
+		if (seenSlotNames.has(slot.name)) continue;
+		seenSlotNames.add(slot.name);
 		const ctx = buildSlotCtx(slot);
 		interfaceDecls.push(ctx.interfaceDecl);
 		slotFieldDecls.push(ctx.fieldDecl);
@@ -41871,6 +42791,7 @@ function shouldWrapAttrBinding$1(name, expr, ctx, elementTagName) {
 	if (BOOLEAN_HTML_ATTRS$1.has(name.toLowerCase())) return false;
 	if ((name === "value" || name === "checked") && FORM_INPUT_TAGS$2.has(elementTagName.toLowerCase())) return false;
 	if (name === "style") return false;
+	if (name === "class") return false;
 	if (t.isObjectExpression(expr)) return false;
 	return true;
 }
@@ -44639,7 +45560,8 @@ function composeSourceMap$1(ms, opts) {
 			outputOffset: opts.scriptOutputOffset
 		}] : [],
 		fileExt: ".ts",
-		userCodeLineOffset: opts.userCodeLineOffset
+		userCodeLineOffset: opts.userCodeLineOffset,
+		partialLineOffsets: opts.partialLineOffsets
 	});
 }
 //#endregion
@@ -45025,7 +45947,8 @@ function emitAngular(ir, opts = {}) {
 			source: opts.source,
 			scriptMap: shellScriptMap,
 			scriptOutputOffset,
-			userCodeLineOffset
+			userCodeLineOffset,
+			partialLineOffsets: buildPartialLineOffsets(ir.setupBody.scriptProgram)
 		}) : null,
 		diagnostics: [
 			...scriptResult.diagnostics,
@@ -45969,6 +46892,56 @@ function tryHoistArrowToFunction(stmt) {
 	return t.inherits(fn, stmt);
 }
 /**
+* Phase 55-04 (literal byte-identity) — reproduce the inline-authored comment
+* doubling at a script-partial splice boundary.
+*
+* In an inline-authored `<script>`, a comment block BETWEEN two statements is
+* attached by `@babel/parser` to BOTH neighbours (the earlier statement's
+* `trailingComments` AND the later statement's `leadingComments`). The `.rzts`
+* script-partial splice instead attaches the boundary banner ONLY to the spliced
+* node's `leadingComments` — the preceding statement lives in a different source
+* file and so carries no matching trailing comment. Re-mirroring the spliced
+* node's leading comments back onto the preceding statement's trailing comments
+* restores the inline form byte-for-byte:
+*   - whole-program generation (Solid here) prints the (deduped) banner once AND
+*     gets the boundary blank line from `@babel/generator`'s `printJoin`
+*     `_lastCommentLine` path — a trailing comment on the previous statement is
+*     exactly what triggers the loc-delta blank-line insertion; and
+*   - per-statement generation (Vue/Svelte) doubles the banner (one copy as the
+*     previous statement's trailing, one as the next statement's leading).
+*
+* Fires ONLY at a genuine splice boundary: the current statement carries
+* `extra.__roziePartialOrigin` AND its leading comments are not ALREADY shared as
+* the previous statement's trailing comments (within-partial statement pairs
+* already share the same comment objects; host-only pairs are left exactly as
+* authored). MUST run before the arrow→function hoist — `t.inherits` does not
+* copy `extra`, so the spliced marker is only visible on the original nodes.
+*/
+function mirrorSpliceBoundaryComments(stmts) {
+	for (let i = 1; i < stmts.length; i++) {
+		const cur = stmts[i];
+		const prev = stmts[i - 1];
+		const lead = cur.leadingComments;
+		if (!lead || lead.length === 0) continue;
+		const extra = cur.extra;
+		const curSpliced = extra?.__roziePartialOrigin !== void 0;
+		const prevSpliced = prev.extra?.__roziePartialOrigin !== void 0;
+		if (!curSpliced) {
+			if (prevSpliced && extra?.__rozieAfterGap !== void 0) {
+				const prevTrail = prev.trailingComments;
+				const lastLead = lead[lead.length - 1];
+				if (prevTrail && prevTrail.length > 0 && prevTrail[prevTrail.length - 1] === lastLead) continue;
+				prev.trailingComments = [...prevTrail ?? [], ...lead];
+			}
+			continue;
+		}
+		const prevTrail = prev.trailingComments;
+		const lastLead = lead[lead.length - 1];
+		if (prevTrail && prevTrail.length > 0 && prevTrail[prevTrail.length - 1] === lastLead) continue;
+		prev.trailingComments = [...prevTrail ?? [], ...lead];
+	}
+}
+/**
 * WR-01 ROOT CAUSE 2 — re-project an author function-type annotation written
 * on a `VariableDeclarator` `id` (`const f: (e: E) => R = …`) onto a rebuilt
 * `FunctionDeclaration` (which has no annotatable `id`). Each declarator-type
@@ -46094,7 +47067,7 @@ function emitScript$1(ir, collectors, _registry) {
 		}
 	}
 	for (const ref of ir.refs) hookLines.push(`let ${ref.name}Ref: HTMLElement | null = null;`);
-	const filteredStmts = [];
+	const residualStmts = [];
 	for (const stmt of rewriteResult.rewrittenProgram.program.body) {
 		if (t.isVariableDeclaration(stmt)) {
 			if (stmt.declarations.every((d) => d.init && t.isCallExpression(d.init) && t.isIdentifier(d.init.callee) && d.init.callee.name === "$computed")) continue;
@@ -46104,8 +47077,10 @@ function emitScript$1(ir, collectors, _registry) {
 			const callee = stmt.expression.callee;
 			if (t.isIdentifier(callee) && (callee.name === "$onMount" || callee.name === "$onUnmount" || callee.name === "$onUpdate" || callee.name === "$watch" || callee.name === "$expose" || callee.name === "$provide")) continue;
 		}
-		filteredStmts.push(tryHoistArrowToFunction(stmt) ?? stmt);
+		residualStmts.push(stmt);
 	}
+	mirrorSpliceBoundaryComments(residualStmts);
+	const filteredStmts = residualStmts.map((stmt) => tryHoistArrowToFunction(stmt) ?? stmt);
 	let userArrowsSection = "";
 	let scriptMap = null;
 	if (filteredStmts.length > 0) {
@@ -46806,6 +47781,10 @@ function composeClassValue(attrs, ir, exprOpts, runtime) {
 	if (attrs.length === 1 && attrs[0].kind === "binding") {
 		const a = attrs[0];
 		if (t.isObjectExpression(a.expression)) return renderExpr(a.expression, ir, exprOpts);
+		if (a.wrapForDisplay && !t.isTemplateLiteral(a.expression)) {
+			runtime?.add("rozieClass");
+			return `rozieClass(${renderExpr(a.expression, ir, exprOpts)})`;
+		}
 		return renderExpr(a.expression, ir, exprOpts);
 	}
 	if (attrs.length === 1 && attrs[0].kind === "interpolated") {
@@ -46824,7 +47803,10 @@ function composeClassValue(attrs, ir, exprOpts, runtime) {
 	const parts = [];
 	for (const a of attrs) if (a.kind === "twoWayBinding") throw new Error(`Solid target: twoWayBinding not valid in class array context (Phase 07.3 Wave 3 Plan 07.3-07).`);
 	else if (a.kind === "static") parts.push(renderStaticClassValue(a.value));
-	else if (a.kind === "binding") parts.push(`(${renderExpr(a.expression, ir, exprOpts)})`);
+	else if (a.kind === "binding") if (a.wrapForDisplay && !t.isTemplateLiteral(a.expression)) {
+		runtime?.add("rozieClass");
+		parts.push(`rozieClass(${renderExpr(a.expression, ir, exprOpts)})`);
+	} else parts.push(`(${renderExpr(a.expression, ir, exprOpts)})`);
 	else if (a.kind === "spreadBinding") throw new Error(`Solid target: spreadBinding not valid in class array context (Phase 14).`);
 	else {
 		let lit = "";
@@ -49475,7 +50457,8 @@ function composeSourceMap(ms, opts) {
 			outputOffset: opts.scriptOutputOffset
 		}] : [],
 		fileExt: ".tsx",
-		userCodeLineOffset: opts.userCodeLineOffset
+		userCodeLineOffset: opts.userCodeLineOffset,
+		partialLineOffsets: opts.partialLineOffsets
 	});
 }
 //#endregion
@@ -49581,7 +50564,8 @@ function emitSolid(ir, opts = {}) {
 		source: opts.source,
 		scriptMap: shell.scriptMap,
 		scriptOutputOffset: shell.scriptOutputOffset,
-		userCodeLineOffset: shell.userCodeLineOffset
+		userCodeLineOffset: shell.userCodeLineOffset,
+		partialLineOffsets: buildPartialLineOffsets(ir.setupBody.scriptProgram)
 	}) : null;
 	const diagnostics = [
 		...scriptResult.diagnostics,
@@ -52453,6 +53437,10 @@ function emitAttribute(attr, ir, tagName, tagKind = "html", opts) {
 			return `style=\${styleMap(${expr})}`;
 		}
 		const expr = rewriteTemplateExpression(attr.expression, ir);
+		if (attr.name === "style") {
+			opts?.runtime.add("rozieStyle");
+			return `style=\${rozieStyle(${expr})}`;
+		}
 		if (tagKind === "component" || tagKind === "self") {
 			const propName = attr.name.includes("-") ? attr.name.replace(/-([a-z])/g, (_, ch) => ch.toUpperCase()) : attr.name;
 			if (opts?._state && (t.isArrayExpression(attr.expression) || t.isObjectExpression(attr.expression)) && isPureLiteral(attr.expression)) {
@@ -52872,9 +53860,12 @@ function emitElementOpenTag(node, ir, irName, opts) {
 			const expr = rewriteTemplateExpression(bindingClass.expression, ir);
 			const staticPart = staticClassValues.length > 0 ? `${staticClassValues.join(" ")} ` : "";
 			let classExpr = expr;
-			if (bindingClass.wrapForDisplay) {
+			if (bindingClass.wrapForDisplay) if (t.isTemplateLiteral(bindingClass.expression)) {
 				opts.runtime.add("rozieDisplay");
 				classExpr = `rozieDisplay(${expr})`;
+			} else {
+				opts.runtime.add("rozieClass");
+				classExpr = `rozieClass(${expr})`;
 			}
 			parts.push(`class="${staticPart}\${(${classExpr})}"`);
 		} else if (bindingClass.kind === "interpolated") {