@rozie/babel-plugin 0.1.4 → 0.2.0

package/dist/index.cjs

@@ -1592,7 +1592,12 @@ const RozieErrorCode = {
 	KEYNAV_ORPHAN_ITEM: "ROZ984",
 	KEYNAV_BAD_FOCUS_MODEL: "ROZ985",
 	KEYNAV_MULTIPLE_ROOTS: "ROZ986",
-	KEYNAV_SOURCE_UNRESOLVED: "ROZ987"
+	KEYNAV_SOURCE_UNRESOLVED: "ROZ987",
+	MANIFEST_SCHEMA_VERSION_MISMATCH: "ROZ988",
+	MALFORMED_MANIFEST: "ROZ989",
+	PORTAL_DIRECTIVE_ON_SLOT: "ROZ990",
+	PORTAL_DIRECTIVE_ON_COMPONENT: "ROZ991",
+	PORTAL_DIRECTIVE_EMPTY_VALUE: "ROZ992"
 };
 //#endregion
 //#region ../core/src/splitter/splitBlocks.ts
@@ -19047,8 +19052,8 @@ var require_source_map$1 = /* @__PURE__ */ __commonJSMin(((exports) => {
 //#endregion
 //#region ../../node_modules/.pnpm/postcss@8.5.13/node_modules/postcss/lib/previous-map.js
 var require_previous_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	let { existsSync: existsSync$1, readFileSync: readFileSync$3 } = require("fs");
-	let { dirname: dirname$4, join: join$1 } = require("path");
+	let { existsSync: existsSync$1, readFileSync: readFileSync$4 } = require("fs");
+	let { dirname: dirname$5, join: join$2 } = require("path");
 	let { SourceMapConsumer, SourceMapGenerator } = require_source_map$1();
 	function fromBase64(str) {
 		if (Buffer) return Buffer.from(str, "base64").toString();
@@ -19065,7 +19070,7 @@ var require_previous_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			let prev = opts.map ? opts.map.prev : void 0;
 			let text = this.loadMap(opts.from, prev);
 			if (!this.mapFile && opts.from) this.mapFile = opts.from;
-			if (this.mapFile) this.root = dirname$4(this.mapFile);
+			if (this.mapFile) this.root = dirname$5(this.mapFile);
 			if (text) this.text = text;
 		}
 		consumer() {
@@ -19102,10 +19107,10 @@ var require_previous_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			if (!trusted && !this.unsafeMap) {
 				if (!/\.map$/i.test(path$5)) return;
 			}
-			this.root = dirname$4(path$5);
+			this.root = dirname$5(path$5);
 			if (existsSync$1(path$5)) {
 				this.mapFile = path$5;
-				return readFileSync$3(path$5, "utf-8").toString().trim();
+				return readFileSync$4(path$5, "utf-8").toString().trim();
 			}
 		}
 		loadMap(file, prev) {
@@ -19125,7 +19130,7 @@ var require_previous_map = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			else if (this.inline) return this.decodeInline(this.annotation);
 			else if (this.annotation) {
 				let map = this.annotation;
-				if (file) map = join$1(dirname$4(file), map);
+				if (file) map = join$2(dirname$5(file), map);
 				let unknown = this.loadFile(map, file, false);
 				if (unknown) try {
 					/* c8 ignore next 4 */
@@ -19497,12 +19502,12 @@ var require_fromJSON = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region ../../node_modules/.pnpm/postcss@8.5.13/node_modules/postcss/lib/map-generator.js
 var require_map_generator = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	let { dirname: dirname$3, relative, resolve: resolve$1, sep } = require("path");
+	let { dirname: dirname$4, relative, resolve: resolve$1, sep } = require("path");
 	let { SourceMapConsumer, SourceMapGenerator } = require_source_map$1();
 	let { pathToFileURL } = require("url");
 	let Input = require_input();
 	let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
-	let pathAvailable = Boolean(dirname$3 && resolve$1 && relative && sep);
+	let pathAvailable = Boolean(dirname$4 && resolve$1 && relative && sep);
 	var MapGenerator = class {
 		constructor(stringify, root, opts, cssString) {
 			this.stringify = stringify;
@@ -19529,7 +19534,7 @@ var require_map_generator = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 		applyPrevMaps() {
 			for (let prev of this.previous()) {
 				let from = this.toUrl(this.path(prev.file));
-				let root = prev.root || dirname$3(prev.file);
+				let root = prev.root || dirname$4(prev.file);
 				let map;
 				if (this.mapOpts.sourcesContent === false) {
 					map = new SourceMapConsumer(prev.text);
@@ -19694,8 +19699,8 @@ var require_map_generator = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 			if (/^\w+:\/\//.test(file)) return file;
 			let cached = this.memoizedPaths.get(file);
 			if (cached) return cached;
-			let from = this.opts.to ? dirname$3(this.opts.to) : ".";
-			if (typeof this.mapOpts.annotation === "string") from = dirname$3(resolve$1(from, this.mapOpts.annotation));
+			let from = this.opts.to ? dirname$4(this.opts.to) : ".";
+			if (typeof this.mapOpts.annotation === "string") from = dirname$4(resolve$1(from, this.mapOpts.annotation));
 			let path$2 = relative(from, file);
 			this.memoizedPaths.set(file, path$2);
 			return path$2;
@@ -41266,6 +41271,13 @@ function lowerBareElement(el, bindings, depGraph, registry, diagnostics, templat
 		const args = [];
 		for (const attr of el.attributes) if (attr.kind === "static" && attr.name === "name" && attr.value !== null) slotName = attr.value;
 		else if (attr.kind === "static" && attr.name === "portal" && attr.value === null) isPortal = true;
+		else if (attr.kind === "directive" && attr.name === "portal") diagnostics.push({
+			code: RozieErrorCode.PORTAL_DIRECTIVE_ON_SLOT,
+			severity: "error",
+			message: "r-portal is not valid on <slot> — use the boolean `portal` attribute for slot-content portalling (r-portal is a distinct directive for portalling an ordinary element's own rendered subtree).",
+			loc: attr.loc,
+			hint: "Use <slot portal /> (no r-, boolean form) to portal slot content into an engine-owned container; r-portal=\"<expr>\" portals an ordinary element out to a container."
+		});
 		else if (attr.kind === "binding" && attr.value !== null) {
 			if (attr.name === "params") continue;
 			const expr = tryParseExpression(attr.value);
@@ -41296,6 +41308,8 @@ function lowerBareElement(el, bindings, depGraph, registry, diagnostics, templat
 	let keynavItem;
 	let keynavActiveClassExpression;
 	let keynavActiveClassDeps;
+	let portalToExpression;
+	let portalToDeps;
 	for (const attr of el.attributes) {
 		if (attr.kind === "event") {
 			const handlerExpr = attr.value !== null ? tryParseExpression(attr.value) : null;
@@ -41505,6 +41519,34 @@ function lowerBareElement(el, bindings, depGraph, registry, diagnostics, templat
 				isExternal = true;
 				continue;
 			}
+			if (attr.name === "portal") {
+				if (attr.value === null || attr.value.trim() === "") {
+					diagnostics.push({
+						code: RozieErrorCode.PORTAL_DIRECTIVE_EMPTY_VALUE,
+						severity: "error",
+						message: "r-portal requires a container expression (e.g. r-portal=\"$props.appendTo\") — an empty value is not a valid portal target.",
+						loc: attr.loc,
+						hint: "Provide an expression that evaluates to an Element (or a falsy value / null to render in place)."
+					});
+					continue;
+				}
+				if (elementIsComponent) {
+					diagnostics.push({
+						code: RozieErrorCode.PORTAL_DIRECTIVE_ON_COMPONENT,
+						severity: "error",
+						message: "r-portal is not supported on a <components>-registered child component element (v1 limitation) — only plain/host elements can be portalled.",
+						loc: attr.loc,
+						hint: "Wrap the component in a plain host element and put r-portal on that wrapper instead."
+					});
+					continue;
+				}
+				const expr = tryParseExpression(attr.value);
+				if (expr) {
+					portalToExpression = expr;
+					portalToDeps = computeExpressionDeps(expr, bindings);
+				}
+				continue;
+			}
 			if ((attr.name === "model" || attr.name === "show" || attr.name === "html" || attr.name === "text") && attr.value !== null) {
 				const expr = tryParseExpression(attr.value);
 				const modifiers = attr.name === "model" ? resolveModelModifiers(attr.chain, registry, diagnostics) : [];
@@ -41556,7 +41598,11 @@ function lowerBareElement(el, bindings, depGraph, registry, diagnostics, templat
 		...isExternal ? { isExternal: true } : {},
 		...remountKeyExpression !== void 0 ? { remountKeyExpression } : {},
 		...keynavRoot !== void 0 ? { keynavRoot } : {},
-		...keynavItem !== void 0 ? { keynavItem } : {}
+		...keynavItem !== void 0 ? { keynavItem } : {},
+		...portalToExpression !== void 0 ? { portalTo: {
+			expression: portalToExpression,
+			deps: portalToDeps ?? []
+		} } : {}
 	};
 }
 /**
@@ -55882,6 +55928,340 @@ var IRCache = class {
 	}
 };
 //#endregion
+//#region ../core/src/manifest/buildManifest.ts
+var import_lib = /* @__PURE__ */ __toESM(require_lib$6(), 1);
+typeof import_lib.default === "function" ? import_lib.default : import_lib.default.default;
+//#endregion
+//#region ../core/src/manifest/readManifest.ts
+/**
+* parseManifest(raw) — validate + deserialize a published-primitive manifest
+* into a producer slot/prop/expose surface (Phase 75, D-04).
+*
+* Fails CLOSED on any trust-boundary violation (T-75-01): an unknown or
+* mismatched `schemaVersion` — or any structurally malformed field — never
+* silently degrades into a partial/best-effort surface. Both failure modes
+* return `{ surface: null, error }`; parseManifest NEVER throws (T-75-02: a
+* crafted/oversized paramType source string is dropped per-entry, not fatal).
+*
+* Per T-75-03, every field is read via explicit key access into a FRESH
+* object — parseManifest never `Object.assign`/spreads the parsed JSON into
+* a shared target, so a `__proto__`/`constructor`-keyed manifest cannot
+* pollute anything beyond the literal-keyed surface it produces.
+*
+* @experimental — shape may change before v1.0
+*/
+function malformed(message) {
+	return {
+		surface: null,
+		error: {
+			code: RozieErrorCode.MALFORMED_MANIFEST,
+			message
+		}
+	};
+}
+function schemaMismatch(message) {
+	return {
+		surface: null,
+		error: {
+			code: RozieErrorCode.MANIFEST_SCHEMA_VERSION_MISMATCH,
+			message
+		}
+	};
+}
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+* Deserialize one paramType SOURCE STRING back into a `TSType` by parsing
+* `type __RozieParam = <src>;` and lifting the type-alias's typeAnnotation.
+* Wrapped in try/catch — a garbage/oversized string is dropped (returns
+* `null`) rather than throwing out of parseManifest (T-75-02).
+*/
+function deserializeParamType(src) {
+	try {
+		const stmt = (0, import_lib$3.parse)(`type __RozieParam = ${src};`, {
+			sourceType: "module",
+			plugins: ["typescript"]
+		}).program.body[0];
+		if (!stmt || !_babel_types.isTSTypeAliasDeclaration(stmt)) return null;
+		return stmt.typeAnnotation;
+	} catch {
+		return null;
+	}
+}
+/** Validate + rebuild one manifest prop entry. Returns null on structural violation. */
+function readProp(raw) {
+	if (!isPlainObject(raw)) return null;
+	const name = raw.name;
+	const isModel = raw.isModel;
+	if (typeof name !== "string") return null;
+	if (typeof isModel !== "boolean") return null;
+	return {
+		name,
+		isModel
+	};
+}
+/** Validate + rebuild one manifest slot-param entry. Returns null on structural violation. */
+function readSlotParam(raw) {
+	if (!isPlainObject(raw)) return null;
+	const name = raw.name;
+	if (typeof name !== "string") return null;
+	return {
+		type: "ParamDecl",
+		name,
+		valueExpression: _babel_types.identifier(name),
+		sourceLoc: {
+			start: 0,
+			end: 0
+		}
+	};
+}
+/** Validate + rebuild one manifest slot entry into a minimal SlotDecl. */
+function readSlot(raw) {
+	if (!isPlainObject(raw)) return null;
+	const name = raw.name;
+	const paramsRaw = raw.params;
+	const paramTypesRaw = raw.paramTypes;
+	const isPortal = raw.isPortal;
+	const isReactive = raw.isReactive;
+	if (typeof name !== "string") return null;
+	if (!Array.isArray(paramsRaw)) return null;
+	if (paramTypesRaw !== null && !Array.isArray(paramTypesRaw)) return null;
+	if (typeof isPortal !== "boolean") return null;
+	if (typeof isReactive !== "boolean") return null;
+	const params = [];
+	for (const p of paramsRaw) {
+		const param = readSlotParam(p);
+		if (param === null) return null;
+		params.push(param);
+	}
+	let paramTypes;
+	if (paramTypesRaw !== null) {
+		const deserialized = [];
+		for (const src of paramTypesRaw) {
+			if (typeof src !== "string") continue;
+			const ty = deserializeParamType(src);
+			if (ty !== null) deserialized.push(ty);
+		}
+		paramTypes = deserialized;
+	}
+	return {
+		type: "SlotDecl",
+		name,
+		defaultContent: null,
+		params,
+		...paramTypes !== void 0 ? { paramTypes } : {},
+		presence: "always",
+		nestedSlots: [],
+		sourceLoc: {
+			start: 0,
+			end: 0
+		},
+		isPortal,
+		isReactive
+	};
+}
+/** Validate + rebuild one manifest expose entry. Returns null on structural violation. */
+function readExposeMember(raw) {
+	if (!isPlainObject(raw)) return null;
+	const name = raw.name;
+	if (typeof name !== "string") return null;
+	return { name };
+}
+/**
+* Validate a manifest's `schemaVersion` FIRST (fail closed, D-04), then
+* shape-validate props/slots/emits/expose and deserialize into a
+* `ProducerSurface` consumable by `threadParamTypes` / `validateTwoWayBindings`.
+* Never throws (T-75-01/T-75-02).
+*/
+function parseManifest(raw, _opts) {
+	if (!isPlainObject(raw)) return malformed("Manifest is not a JSON object.");
+	const schemaVersion = raw.schemaVersion;
+	if (typeof schemaVersion !== "number") return malformed("Manifest is missing a numeric \"schemaVersion\" field.");
+	if (schemaVersion !== 1) return schemaMismatch(`Manifest schemaVersion ${schemaVersion} is incompatible with the compiler's MANIFEST_SCHEMA_VERSION 1. Reinstall a compatible version of the published primitive.`);
+	const propsRaw = raw.props;
+	const slotsRaw = raw.slots;
+	const emitsRaw = raw.emits;
+	const exposeRaw = raw.expose;
+	if (!Array.isArray(propsRaw)) return malformed("Manifest \"props\" is not an array.");
+	if (!Array.isArray(slotsRaw)) return malformed("Manifest \"slots\" is not an array.");
+	if (!Array.isArray(emitsRaw)) return malformed("Manifest \"emits\" is not an array.");
+	if (!Array.isArray(exposeRaw)) return malformed("Manifest \"expose\" is not an array.");
+	const props = [];
+	for (const p of propsRaw) {
+		const prop = readProp(p);
+		if (prop === null) return malformed("Manifest \"props\" entry is malformed.");
+		props.push(prop);
+	}
+	const slots = [];
+	for (const s of slotsRaw) {
+		const slot = readSlot(s);
+		if (slot === null) return malformed("Manifest \"slots\" entry is malformed.");
+		slots.push(slot);
+	}
+	for (const e of emitsRaw) if (typeof e !== "string") return malformed("Manifest \"emits\" entry is not a string.");
+	const expose = [];
+	for (const m of exposeRaw) {
+		const member = readExposeMember(m);
+		if (member === null) return malformed("Manifest \"expose\" entry is malformed.");
+		expose.push(member);
+	}
+	return {
+		surface: {
+			slots,
+			props,
+			expose
+		},
+		error: null
+	};
+}
+//#endregion
+//#region ../core/src/manifest/resolveManifestProducer.ts
+/**
+* resolveManifestProducer — Phase 75 Plan 02 (D-08/D-09/D-10).
+*
+* Wires the manifest contract (Plan 01's `buildManifest`/`parseManifest`)
+* into `@rozie/core`'s producer-resolution seam so a PUBLISHED cross-package
+* `<components>` specifier resolves a producer contract from a compiled
+* `rozie-manifest.json` instead of a `.rozie` source file.
+*
+* **COMP-04 bounded exception**: local `.rozie` composition (relative /
+* tsconfig-alias specifiers) still needs NO cross-`.rozie` IR type info and
+* keeps reading on-disk `.rozie` source unchanged via the existing
+* `resolver.resolveProducerPath` + `IRCache.getIRComponent` path. ONLY
+* published cross-PACKAGE specifiers (D-08's `@scope/pkg/Component.rozie`
+* shape) read this compiled manifest artifact. This module and its two
+* call-sites (threadParamTypes.ts, validateTwoWayBindings.ts) are the entire
+* surface of that exception.
+*
+* Convention-based per-target package derivation (D-08): for a published
+* specifier `@scope/pkg/Component.rozie`, the trailing `/Component.rozie`
+* segment is stripped to yield the base package `@scope/pkg`, then
+* `-${target}` is appended to yield the derived per-target package name
+* (e.g. `@rozie-ui/combobox` + `-react` → `@rozie-ui/combobox-react`).
+*
+* Location (D-10): the derived package is located via the SAME
+* `enhanced-resolve` layer `ProducerResolver` already uses for `.rozie`
+* producer resolution — walking `node_modules` from the consumer file's
+* directory (NOT from `ResolverOptions.root`, which feeds only the
+* tsconfig-paths matcher). Because a real per-target leaf's `package.json`
+* `exports` map does not (and need not) list `"./package.json"` or
+* `"./rozie-manifest.json"` as exported subpaths, this resolver deliberately
+* resolves the package's bare `"."` export entry (its normal `import`
+* condition target, e.g. `dist/index.mjs`) and then walks UP from that
+* resolved file to the nearest ancestor directory whose `package.json`
+* `name` matches the derived package name (T-75-04/T-75-05 — bounded walk,
+* name-verified, never an unauthenticated `../` traversal). The manifest is
+* then read at a FIXED literal relative path inside that directory
+* (`rozie-manifest.json`) — no specifier-derived path segment ever reaches
+* `readFileSync` (T-75-04).
+*
+* @experimental — shape may change before v1.0
+*/
+/** Tsconfig-alias-shaped prefix (empty npm scope, e.g. `@/components/Modal.rozie`). */
+const TSCONFIG_ALIAS_PREFIX$1 = "@/";
+/**
+* True iff `specifier` is a PUBLISHED cross-package `<components>` specifier
+* (D-08 shape): ends in `.rozie`, is neither a relative/absolute path nor a
+* tsconfig `paths`-alias-shaped specifier.
+*
+* `isPublishedSpecifier` is a pure, syntactic classifier — it does not itself
+* consult a real tsconfig (that happens inside `ProducerResolver`'s local
+* COMP-04 path when this returns `false`). A leading `@/` is NOT a valid npm
+* scoped-package prefix (npm scopes require at least one character between
+* `@` and the following `/`), so it is the reliable syntactic signal that a
+* `@/...` specifier is tsconfig-alias-shaped rather than a real scoped
+* package — matching `ProducerResolver`'s own documented `@/components/Modal.rozie`
+* example of a tsconfig-paths alias.
+*/
+function isPublishedSpecifier$1(specifier) {
+	if (!specifier.endsWith(".rozie")) return false;
+	if (specifier.startsWith(".") || specifier.startsWith("/")) return false;
+	if (specifier.startsWith(TSCONFIG_ALIAS_PREFIX$1)) return false;
+	return true;
+}
+/**
+* Strip the trailing `/<Component>.rozie` leaf off a published specifier to
+* derive the base package name (e.g. `@rozie-ui/combobox/Combobox.rozie` →
+* `@rozie-ui/combobox`). Returns `null` when the specifier has no `/`
+* separating a package from a leaf (malformed — never a valid published
+* specifier in practice, since `isPublishedSpecifier` requires `.rozie`).
+*/
+function deriveBasePackageName(specifier) {
+	const lastSlash = specifier.lastIndexOf("/");
+	if (lastSlash <= 0) return null;
+	return specifier.slice(0, lastSlash);
+}
+/**
+* Walk UP from a resolved entry-file path to the nearest ancestor directory
+* whose `package.json` `name` field equals `expectedName` AND which carries a
+* sibling `rozie-manifest.json`. Bounded to 10 levels (T-75-05 — a real
+* per-target leaf's package root sits 1-3 levels above its resolved `dist/*`
+* entry; 10 is a generous, still-finite bound that can never escape into an
+* unrelated ancestor tree undetected, since EVERY level is name-verified
+* before being accepted).
+*
+* Requiring the manifest sibling (not just a name match) is deliberate: some
+* per-target build tooling generates a SECONDARY `package.json` inside the
+* `dist/` output with the SAME `name` field as the real package root (e.g.
+* `ng-packagr`'s Angular `Package Format v9+` legacy-entry-point convention
+* emits `dist/package.json`). A name-only match would stop at that inner
+* duplicate — one level too shallow — and never reach the real package root
+* where `rozie-manifest.json` actually lives (only shipped at the root,
+* sibling to the AUTHORED `package.json`, never duplicated into `dist/`).
+* Continuing the walk past a name-matched-but-manifest-less directory finds
+* the correct root for every current `@rozie-ui/*-<target>` leaf shape.
+*/
+function findPackageRoot(entryFilePath, expectedName) {
+	let dir = (0, node_path.dirname)(entryFilePath);
+	for (let i = 0; i < 10; i++) {
+		try {
+			const raw = JSON.parse((0, node_fs.readFileSync)((0, node_path.join)(dir, "package.json"), "utf-8"));
+			if (typeof raw === "object" && raw !== null && raw.name === expectedName) try {
+				(0, node_fs.readFileSync)((0, node_path.join)(dir, "rozie-manifest.json"), "utf-8");
+				return dir;
+			} catch {}
+		} catch {}
+		const parent = (0, node_path.dirname)(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+	return null;
+}
+function lookupFailed(pkgLabel) {
+	return {
+		surface: null,
+		error: {
+			code: RozieErrorCode.CROSS_PACKAGE_LOOKUP_FAILED,
+			message: `Cannot locate a published manifest for '${pkgLabel}'. Verify the per-target package is installed as a dependency reachable from the consumer file and ships a rozie-manifest.json.`
+		}
+	};
+}
+/**
+* Derive the per-target package for a published `<components>` specifier,
+* locate its installed `rozie-manifest.json` via node module resolution, and
+* validate + deserialize it into a `ProducerSurface` (D-08/D-09/D-10/D-04).
+*
+* Never throws — every failure mode returns `{ surface: null, error }`.
+*/
+function resolveManifestProducer(args) {
+	const { specifier, target, fromFile, resolver } = args;
+	const basePkg = deriveBasePackageName(specifier);
+	if (basePkg === null) return lookupFailed(specifier);
+	const derivedPkg = `${basePkg}-${target}`;
+	const entryFilePath = resolver.resolveProducerPath(derivedPkg, fromFile);
+	if (entryFilePath === null) return lookupFailed(derivedPkg);
+	const packageDir = findPackageRoot(entryFilePath, derivedPkg);
+	if (packageDir === null) return lookupFailed(derivedPkg);
+	let raw;
+	try {
+		raw = JSON.parse((0, node_fs.readFileSync)((0, node_path.join)(packageDir, "rozie-manifest.json"), "utf-8"));
+	} catch {
+		return lookupFailed(derivedPkg);
+	}
+	return parseManifest(raw, { packageName: derivedPkg });
+}
+//#endregion
 //#region ../core/src/ir/threadParamTypes.ts
 /**
 * Recursive template walker: visit every TemplateNode in source order.
@@ -55966,9 +56346,11 @@ function bodyContainsReprojection(body) {
 *   the cache reverse-dep edge + resolver `fromFile` argument)
 * @param cache         - per-compiler-instance IRCache (D-01)
 * @param resolver      - per-compiler-instance ProducerResolver (D-02 / D-12)
+* @param target        - the per-call compile target (Phase 75 Plan 02 —
+*   selects the derived per-target package for a PUBLISHED specifier; D-09)
 * @param diagnostics   - accumulator
 */
-function threadParamTypes(ir, consumerPath, cache, resolver, diagnostics) {
+function threadParamTypes(ir, consumerPath, cache, resolver, target, diagnostics) {
 	const declaredSlotNames = new Set(ir.slots.map((s) => s.name));
 	const { reprojections } = collectSlotInvocationsByContext(ir.template);
 	for (const reproj of reprojections) if (!declaredSlotNames.has(reproj.slotName)) diagnostics.push({
@@ -55988,6 +56370,26 @@ function threadParamTypes(ir, consumerPath, cache, resolver, diagnostics) {
 		if (node.tagKind === "self") {
 			producerSlots = ir.slots;
 			producerProps = ir.props;
+		} else if (isPublishedSpecifier$1(node.componentRef.importPath)) {
+			const { surface, error } = resolveManifestProducer({
+				specifier: node.componentRef.importPath,
+				target,
+				fromFile: consumerPath,
+				resolver
+			});
+			if (error !== null) {
+				diagnostics.push({
+					code: error.code,
+					severity: "error",
+					message: error.message,
+					loc: node.componentRef.sourceLoc,
+					hint: "Verify the per-target package is installed as a dependency and ships a compatible rozie-manifest.json."
+				});
+				return;
+			}
+			if (surface === null) return;
+			producerSlots = surface.slots;
+			producerProps = surface.props;
 		} else {
 			const resolvedPath = resolver.resolveProducerPath(node.componentRef.importPath, consumerPath);
 			if (resolvedPath === null) {
@@ -56192,9 +56594,11 @@ function walkTemplate(node, visit) {
 * @param cache         - per-compiler-instance IRCache (D-01) — shared with
 *   threadParamTypes so producers parsed once during threading are reused here
 * @param resolver      - per-compiler-instance ProducerResolver (D-02 / D-12)
+* @param target        - the per-call compile target (Phase 75 Plan 02 —
+*   selects the derived per-target package for a PUBLISHED specifier; D-09)
 * @param diagnostics   - accumulator (mutated in place; ROZ949/950/951/945 pushed)
 */
-function validateTwoWayBindings(ir, consumerPath, cache, resolver, diagnostics) {
+function validateTwoWayBindings(ir, consumerPath, cache, resolver, target, diagnostics) {
 	walkTemplate(ir.template, (node) => {
 		if (node.type !== "TemplateElement") return;
 		const twoWayAttrs = node.attributes.filter((a) => a.kind === "twoWayBinding");
@@ -56209,6 +56613,27 @@ function validateTwoWayBindings(ir, consumerPath, cache, resolver, diagnostics)
 				return producerProps;
 			}
 			if (node.tagKind !== "component" || !node.componentRef) return null;
+			if (isPublishedSpecifier$1(node.componentRef.importPath)) {
+				const { surface, error } = resolveManifestProducer({
+					specifier: node.componentRef.importPath,
+					target,
+					fromFile: consumerPath,
+					resolver
+				});
+				if (error !== null) {
+					diagnostics.push({
+						code: error.code,
+						severity: "error",
+						message: error.message,
+						loc: node.componentRef.sourceLoc,
+						hint: "Verify the per-target package is installed as a dependency and ships a compatible rozie-manifest.json."
+					});
+					return null;
+				}
+				if (surface === null) return null;
+				producerProps = surface.props;
+				return producerProps;
+			}
 			const resolvedPath = resolver.resolveProducerPath(node.componentRef.importPath, consumerPath);
 			if (resolvedPath === null) {
 				diagnostics.push({
@@ -56263,6 +56688,7 @@ function validateTwoWayBindings(ir, consumerPath, cache, resolver, diagnostics)
 			if (producerProp === void 0) continue;
 			if (!producerProp.isModel) {
 				const producerImportPath = node.tagKind === "self" ? "(self-reference)" : node.componentRef?.importPath ?? "(unknown)";
+				const relatedLoc = producerProp.sourceLoc ?? node.componentRef?.sourceLoc ?? attr.sourceLoc;
 				diagnostics.push({
 					code: RozieErrorCode.TWO_WAY_PROP_NOT_MODEL,
 					severity: "error",
@@ -56271,7 +56697,7 @@ function validateTwoWayBindings(ir, consumerPath, cache, resolver, diagnostics)
 					hint: `Add 'model: true' to the '${attr.name}' prop declaration on ${producerImportPath}, or pass a one-way value via :${attr.name}="…" instead.`,
 					related: [{
 						message: `'${attr.name}' declared here without model: true`,
-						loc: producerProp.sourceLoc
+						loc: relatedLoc
 					}]
 				});
 				continue;
@@ -56582,10 +57008,37 @@ const TARGET_EXT_MAP = {
 	lit: ""
 };
 const ROZIE_EXT$1 = ".rozie";
+/** Tsconfig-alias-shaped prefix (empty npm scope, e.g. `@/components/Modal.rozie`). */
+const TSCONFIG_ALIAS_PREFIX = "@/";
+/**
+* True iff `importPath` is a PUBLISHED cross-package `<components>`
+* specifier (D-08 shape): ends in `.rozie`, is neither a relative/absolute
+* path nor a tsconfig `paths`-alias-shaped specifier. Mirrors
+* `resolveManifestProducer.ts`'s `isPublishedSpecifier` (kept duplicated,
+* not imported, so this module stays dependency-free — both are tiny, pure,
+* syntactic classifiers over the same D-08 specifier shape and must be kept
+* in lockstep if that shape ever changes).
+*
+* Exported so callers that do NOT already route an import path through
+* `rewriteRozieImport` (e.g. the Lit emitter's side-effect/type-only
+* composed-component imports, which deliberately leave a LOCAL `.rozie`
+* specifier verbatim for the unplugin-consumer-coexist flow) can still
+* gate a published-specifier rewrite without duplicating this check.
+*/
+function isPublishedSpecifier(importPath) {
+	if (!importPath.endsWith(ROZIE_EXT$1)) return false;
+	if (importPath.startsWith(".") || importPath.startsWith("/")) return false;
+	if (importPath.startsWith(TSCONFIG_ALIAS_PREFIX)) return false;
+	return true;
+}
 function rewriteRozieImport(importPath, target) {
 	if (!importPath.endsWith(ROZIE_EXT$1)) return importPath;
 	const targetExt = TARGET_EXT_MAP[target];
 	if (targetExt === void 0) throw new Error(`rewriteRozieImport: unknown target '${target}' — expected one of vue|react|svelte|angular|solid|lit`);
+	if (isPublishedSpecifier(importPath)) {
+		const lastSlash = importPath.lastIndexOf("/");
+		if (lastSlash > 0) return `${importPath.slice(0, lastSlash)}-${target}`;
+	}
 	return importPath.slice(0, -6) + targetExt;
 }
 //#endregion
@@ -56977,7 +57430,6 @@ function deconflictVueRefSuffix(ir, topLevelBindingNames) {
 }
 //#endregion
 //#region ../core/src/codegen/buildPropJsdoc.ts
-var import_lib = /* @__PURE__ */ __toESM(require_lib$6(), 1);
 /**
 * Neutralize the JSDoc comment terminator inside an author-controlled string so
 * it cannot prematurely close the emitted comment block (T-58-04). Replaces each
@@ -57869,6 +58321,22 @@ function renderComputedArrow$3(body, cast) {
 * `normalizeSplicedEmitLines` (core) has already anchored the seam spacing, so the
 * mirrored trailing copy spaces correctly.
 */
+/**
+* Quick task 260714-orv — compare two Babel comment nodes by SOURCE POSITION
+* (type + starting line/column) rather than object reference. A comment
+* shared between two adjacent statements' trailing/leading arrays sometimes
+* IS the exact same object, but an earlier pipeline pass (hoistModuleLet /
+* rewriteRozieIdentifiers / etc.) may clone an individual statement, minting
+* a content-identical comment object at a different reference. Two distinct,
+* independently-authored comments can never share a starting source
+* position, so this is a safe substitute for `===` this late in the
+* pipeline.
+*/
+function isSameSourceComment$1(a, b) {
+	if (a === b) return true;
+	if (!a.loc || !b.loc) return false;
+	return a.type === b.type && a.loc.start.line === b.loc.start.line && a.loc.start.column === b.loc.start.column;
+}
 function mirrorSpliceBoundaryComments$2(stmts) {
 	for (let i = 1; i < stmts.length; i++) {
 		const cur = stmts[i];
@@ -57877,7 +58345,15 @@ function mirrorSpliceBoundaryComments$2(stmts) {
 		const prevExtra = prev.extra;
 		const curSpliced = curExtra?.__roziePartialOrigin !== void 0;
 		const prevSpliced = prevExtra?.__roziePartialOrigin !== void 0;
-		if (!curSpliced && !prevSpliced) continue;
+		if (!curSpliced && !prevSpliced) {
+			const prevTrail = prev.trailingComments;
+			const curLead = cur.leadingComments;
+			if (prevTrail && prevTrail.length > 0 && curLead && curLead.length > 0) {
+				const deduped = prevTrail.filter((c) => !curLead.some((lc) => isSameSourceComment$1(c, lc)));
+				prev.trailingComments = deduped.length > 0 ? deduped : null;
+			}
+			continue;
+		}
 		const lead = cur.leadingComments;
 		const prevTrail = prev.trailingComments;
 		if (curSpliced && !prevSpliced && (!lead || lead.length === 0) && prevTrail && prevTrail.length > 0) {
@@ -59988,7 +60464,61 @@ function emitElement$5(node, ctx) {
 * (`<template #header="{ close }">…</template>`); default-shorthand
 * (`{ name: '' }`) emits as bare children inside the component tag.
 */
+/**
+* command-palette-portal-overlay phase — `r-portal="<expr>"` element
+* teleport. Wraps the element in Vue's NATIVE `<Teleport :to :disabled>`
+* component — authors cannot write `<Teleport>` directly (ROZ926 rejects
+* it), but the EMITTER may synthesize it as the lowering target for
+* `r-portal` (ROZ926 gates author input, not emit output). `<Teleport>`
+* tolerates a `v-if`/`v-for` child, so `extraDirective` (the r-if/r-for
+* directive the parent conditional/loop walker wants to inject) is applied
+* to the INNER element, not the `<Teleport>` wrapper — the wrapper is
+* unconditional; when `disabled` the child's own `v-if` still governs
+* whether anything renders at all.
+*
+* `:disabled="!(<expr>)"` — a falsy container renders in place (Vue's
+* Teleport skips target resolution/warnings entirely when disabled; see
+* `resolveTarget`/`mountToTarget` in @vue/runtime-core — no console warning,
+* no throw, for a falsy `to` when `disabled` is true).
+*
+* Finding 4 (R2) — the container expression is HOISTED into a single Vue
+* `computed` (the same D-04 hoist pattern `r-match` uses) instead of being
+* spliced verbatim into both `:to` and `:disabled`. This fixes three
+* defects at once:
+*   1. SSR guard — the computed body wraps the expression in the SAME
+*      `typeof document === 'undefined' ? null : (...)` guard the React and
+*      Solid targets emit, so a container expression that touches `document`
+*      (e.g. `document.querySelector(...)`) is null on the server rather
+*      than throwing; a null container makes `:disabled` truthy → renders
+*      in place (parity with React's ternary / Solid's <Show> fallback).
+*   2. single evaluation — a Vue computed caches, so a side-effecting
+*      selector runs once per render, not twice (`:to` + `:disabled`).
+*   3. escaping — the raw expression now lives in the script (where
+*      @babel/generator escapes JS strings), and `:to`/`:disabled` bind a
+*      bare computed identifier, so an expression containing a `"` can no
+*      longer break the double-quoted attribute (obviating a per-attribute
+*      escapeAttrValue call at the interpolation site).
+*/
+function emitPortalElement$1(node, extraDirective, ctx) {
+	const { expression } = node.portalTo;
+	if (ctx.elementPortalFlag) ctx.elementPortalFlag.seen = true;
+	const containerCode = rewriteTemplateExpression$5(expression, ctx.ir);
+	const hoistName = `__roziePortalTo${ctx.injectionCounter.next++}`;
+	ctx.scriptInjections.push({
+		wrapName: hoistName,
+		import: {
+			from: "vue",
+			name: "computed"
+		},
+		decl: `const ${hoistName} = computed(() => (typeof document === 'undefined' ? null : (${containerCode})));`
+	});
+	return `<Teleport :to="${hoistName}" :disabled="!${hoistName}">${emitElementWithExtraDirectiveInner(node, extraDirective, ctx)}</Teleport>`;
+}
 function emitElementWithExtraDirective(origNode, extraDirective, ctx) {
+	if (origNode.portalTo) return emitPortalElement$1(origNode, extraDirective, ctx);
+	return emitElementWithExtraDirectiveInner(origNode, extraDirective, ctx);
+}
+function emitElementWithExtraDirectiveInner(origNode, extraDirective, ctx) {
 	const node = stripKeynavCommitEvent$5(origNode);
 	const rHtml = findRHtml$2(node.attributes);
 	const attrText = emitMergedAttributes(rHtml ? node.attributes.filter((a) => !(a.kind === "binding" && a.name === "r-html")) : node.attributes, {
@@ -65085,6 +65615,20 @@ function genBlockInner(block, indent) {
 	}).join("\n");
 }
 /**
+* Quick task 260714-orv — render hoisted user imports in ONE
+* @babel/generator pass so a comment shared between two adjacent imports
+* (Babel attaches it as BOTH the earlier import's `trailingComments` AND the
+* later import's `leadingComments`) prints exactly once. Mirrors
+* `genBlockInner`'s single-pass precedent — generating imports one at a time
+* (`nodes.map(genCode).join`) gives each import its OWN comment-dedup set,
+* doubling any shared comment. `t.program(nodes)` prints only its body
+* statements (no wrapping braces/`File` boilerplate), so non-comment cases
+* stay byte-identical.
+*/
+function genImportsBlock$2(nodes) {
+	return generate$21(_babel_types.program(nodes), GEN_OPTS$19).code;
+}
+/**
 * Phase 14.1 follow-up — does any element in the IR template carry a
 * `spreadBinding` attribute? The Plan 14-05 gate at `emitScript` only
 * synthesises `const attrs = ...` (the source for the `$attrs` rewrite at
@@ -65936,7 +66480,7 @@ function emitScript$4(ir, collectors, opts = {}) {
 	const cloned = cloneScriptProgram$4(ir.setupBody.scriptProgram);
 	const { userImports: userImportNodes, hoistedTypeDecls: hoistedTypeNodes, bodyStmts } = partitionUserImports$3(cloned);
 	cloned.program.body = bodyStmts;
-	const userImports = userImportNodes.length > 0 ? userImportNodes.map((imp) => genCode$7(imp)).join("\n") + "\n" : "";
+	const userImports = userImportNodes.length > 0 ? genImportsBlock$2(userImportNodes) + "\n" : "";
 	const hoistedTypeDecls = hoistedTypeNodes.map((decl) => genCode$7(decl));
 	deconflictDeclareThenAssignRef(cloned, ir);
 	const hoistResult = hoistModuleLet(cloned, ir);
@@ -69320,7 +69864,42 @@ function scopeAttrForElement$1(node, ctx) {
 * declarations are hoisted within their containing scope). Both emit the tag
 * verbatim PascalCase below; no template AST rewrite needed.
 */
+/**
+* command-palette-portal-overlay phase — `r-portal="<expr>"` element
+* teleport. Wraps the normal element emit (`emitElementInner`) in a
+* `container ? createPortal(tree, container) : tree` check, using React's
+* native `createPortal` (react-dom) — NEVER the P33 `emitPortals.ts`
+* createRoot-into-container machinery (that is the INVERSE direction: slot-
+* content mounted INTO an engine-owned container, not a component's own
+* subtree relocated OUT).
+*
+* SSR guard: the container expression is evaluated ONLY when `document`
+* exists — some author expressions call `document.querySelector` internally
+* (see `resolveAppendTo`/`resolveTo` in the authoring convention), so simply
+* checking the RESULT for null is not enough; the whole resolution must be
+* skipped on the server. Falsy/null container falls back to rendering the
+* subtree in place — this is what makes `appendTo:false` byte-behavior-
+* identical to no directive at emit time (the lower-time field is always
+* present per Task 1; this is the runtime decision point).
+*
+* Returns a `{...}` JSX-expression-container mustache — valid directly in
+* JSX children position, and `renderBranchBody` (emitConditional.ts) strips
+* the outer braces via `stripBalancedMustache` when this is a single-child
+* r-if branch body, so `r-portal` + `r-if` on the same element compose for
+* free with zero special-casing in the conditional emitter.
+*/
+function emitPortalElement(node, ctx) {
+	const { expression } = node.portalTo;
+	if (ctx.elementPortalFlag) ctx.elementPortalFlag.seen = true;
+	const containerCode = rewriteTemplateExpression$4(expression, ctx.ir);
+	const treeJsx = emitElementInner$4(node, ctx);
+	return `{(() => { const __rozieContainer = typeof document === 'undefined' ? null : (${containerCode}); return __rozieContainer ? createPortal(${treeJsx}, __rozieContainer) : (${treeJsx}); })()}`;
+}
 function emitElement$4(origNode, ctx) {
+	if (origNode.portalTo) return emitPortalElement(origNode, ctx);
+	return emitElementInner$4(origNode, ctx);
+}
+function emitElementInner$4(origNode, ctx) {
 	let node = stripKeynavCommitEvent$4(origNode);
 	const pendingKey = ctx.pendingKey ?? null;
 	const childCtx = {
@@ -69870,9 +70449,11 @@ function emitTemplate$4(ir, collectors, registry, opts = {}) {
 		scriptInjections: [],
 		slotPropFields: slotResult.slotPropFields,
 		slotCtxInterfaces: slotResult.slotCtxInterfaces,
-		diagnostics: []
+		diagnostics: [],
+		hasElementPortal: false
 	};
 	const keynav = resolveKeynavPlan$4(ir);
+	const elementPortalFlag = { seen: false };
 	const ctx = {
 		ir,
 		collectors,
@@ -69881,7 +70462,8 @@ function emitTemplate$4(ir, collectors, registry, opts = {}) {
 		scriptInjections,
 		injectionCounter: { next: 0 },
 		...opts.scopeAttr !== void 0 ? { scopeAttr: opts.scopeAttr } : {},
-		keynav
+		keynav,
+		elementPortalFlag
 	};
 	const jsx = emitNode$4(ir.template, ctx);
 	if (keynav !== null) scriptInjections.push(...buildKeynavScriptInjections$2(keynav, ir, collectors));
@@ -69890,7 +70472,8 @@ function emitTemplate$4(ir, collectors, registry, opts = {}) {
 		scriptInjections,
 		slotPropFields: slotResult.slotPropFields,
 		slotCtxInterfaces: slotResult.slotCtxInterfaces,
-		diagnostics
+		diagnostics,
+		hasElementPortal: elementPortalFlag.seen
 	};
 }
 //#endregion
@@ -73810,11 +74393,11 @@ function emitReact(ir, opts = {}) {
 		runtime: runtimeImports,
 		filename: opts.filename
 	}, scriptOpts);
-	const portalImport = hasPortals ? "import { createRoot, type Root } from 'react-dom/client';\nimport { flushSync } from 'react-dom';\n" : "";
 	const tmpl = emitTemplate$4(ir, {
 		react: reactImports,
 		runtime: runtimeImports
 	}, registry, { scopeAttr });
+	const portalImport = (hasPortals ? "import { createRoot, type Root } from 'react-dom/client';\nimport { flushSync } from 'react-dom';\n" : "") + (tmpl.hasElementPortal ? "import { createPortal } from 'react-dom';\n" : "");
 	const listeners = emitListeners$4(ir, {
 		react: reactImports,
 		runtime: runtimeImports
@@ -74015,11 +74598,11 @@ function renderPropType(ann) {
 		case "Boolean": return "boolean";
 		case "Array": return "unknown[]";
 		case "Object": return "Record<string, unknown>";
-		case "Function": return "(...args: unknown[]) => unknown";
+		case "Function": return "(...args: any[]) => any";
 		default: return ann.name;
 	}
 	if (ann.kind === "literal") switch (ann.value) {
-		case "function": return "(...args: unknown[]) => unknown";
+		case "function": return "(...args: any[]) => any";
 		case "object": return "Record<string, unknown>";
 		case "array": return "unknown[]";
 		case "string": return "string";
@@ -75305,6 +75888,22 @@ function arrowBody$2(body) {
 * `normalizeSplicedEmitLines` (core) has already anchored the seam spacing, so the
 * mirrored trailing copy spaces correctly.
 */
+/**
+* Quick task 260714-orv — compare two Babel comment nodes by SOURCE POSITION
+* (type + starting line/column) rather than object reference. A comment
+* shared between two adjacent statements' trailing/leading arrays sometimes
+* IS the exact same object, but an earlier pipeline pass (hoistModuleLet /
+* rewriteRozieIdentifiers / etc.) may clone an individual statement, minting
+* a content-identical comment object at a different reference. Two distinct,
+* independently-authored comments can never share a starting source
+* position, so this is a safe substitute for `===` this late in the
+* pipeline.
+*/
+function isSameSourceComment(a, b) {
+	if (a === b) return true;
+	if (!a.loc || !b.loc) return false;
+	return a.type === b.type && a.loc.start.line === b.loc.start.line && a.loc.start.column === b.loc.start.column;
+}
 function mirrorSpliceBoundaryComments$1(stmts) {
 	for (let i = 1; i < stmts.length; i++) {
 		const cur = stmts[i];
@@ -75313,7 +75912,15 @@ function mirrorSpliceBoundaryComments$1(stmts) {
 		const prevExtra = prev.extra;
 		const curSpliced = curExtra?.__roziePartialOrigin !== void 0;
 		const prevSpliced = prevExtra?.__roziePartialOrigin !== void 0;
-		if (!curSpliced && !prevSpliced) continue;
+		if (!curSpliced && !prevSpliced) {
+			const prevTrail = prev.trailingComments;
+			const curLead = cur.leadingComments;
+			if (prevTrail && prevTrail.length > 0 && curLead && curLead.length > 0) {
+				const deduped = prevTrail.filter((c) => !curLead.some((lc) => isSameSourceComment(c, lc)));
+				prev.trailingComments = deduped.length > 0 ? deduped : null;
+			}
+			continue;
+		}
 		const lead = cur.leadingComments;
 		const prevTrail = prev.trailingComments;
 		if (curSpliced && !prevSpliced && (!lead || lead.length === 0) && prevTrail && prevTrail.length > 0) {
@@ -77849,6 +78456,11 @@ function emitElementInner$3(origNode, ctx) {
 		hasFallthroughSpread = true;
 		break;
 	}
+	let portalAttr = null;
+	if (node.portalTo) {
+		ctx.runtimeImports.add("roziePortal");
+		portalAttr = `use:roziePortal={${rewriteTemplateExpression$3(node.portalTo.expression, ctx.ir, ctxRenames(ctx))}}`;
+	}
 	const attrText = emitAttributes$2(node.attributes, {
 		ir: ctx.ir,
 		elementTagKind: node.tagKind,
@@ -77877,6 +78489,7 @@ function emitElementInner$3(origNode, ctx) {
 	if (eventText) partsHead.push(eventText);
 	for (const sp of spreadTexts) partsHead.push(sp);
 	for (const ka of keynavAttrs) partsHead.push(ka);
+	if (portalAttr) partsHead.push(portalAttr);
 	if (ctx.scopeAttr.length > 0) partsHead.push(ctx.scopeAttr);
 	const head = partsHead.length > 0 ? " " + partsHead.join(" ") : "";
 	if (rHtml !== null) {
@@ -79608,6 +80221,88 @@ function hoistDoubleReadAccessors(program) {
 	}
 	visit(program.program);
 }
+/** True for `$props.X` where X is in `polymorphicModelProps`. */
+function isPolymorphicModelRead$1(node, polymorphicModelProps) {
+	return _babel_types.isMemberExpression(node) && !node.computed && _babel_types.isIdentifier(node.object) && node.object.name === "$props" && _babel_types.isIdentifier(node.property) && polymorphicModelProps.has(node.property.name);
+}
+/**
+* When `test` is `typeof $props.X === '<lit>'` (or `!==`) or `'<lit>' in
+* $props.X`, for X in `polymorphicModelProps`, returns X. Otherwise null.
+*/
+function matchesPolymorphicModelGuard$1(test, polymorphicModelProps) {
+	if (_babel_types.isLogicalExpression(test)) return matchesPolymorphicModelGuard$1(test.left, polymorphicModelProps) ?? matchesPolymorphicModelGuard$1(test.right, polymorphicModelProps);
+	if (!_babel_types.isBinaryExpression(test)) return null;
+	const { operator, left, right } = test;
+	if (operator === "===" || operator === "!==") {
+		if (_babel_types.isUnaryExpression(left) && left.operator === "typeof" && isPolymorphicModelRead$1(left.argument, polymorphicModelProps) && _babel_types.isStringLiteral(right)) return left.argument.property.name;
+		if (_babel_types.isUnaryExpression(right) && right.operator === "typeof" && isPolymorphicModelRead$1(right.argument, polymorphicModelProps) && _babel_types.isStringLiteral(left)) return right.argument.property.name;
+		return null;
+	}
+	if (operator === "in" && isPolymorphicModelRead$1(right, polymorphicModelProps)) return right.property.name;
+	return null;
+}
+/**
+* Quick task 260711-v2l (project_angular_typeof_narrow_gap) — port of Solid's
+* `hoistPolymorphicModelGuards` (emitter-hardening backlog item #11,
+* `project_solid_polymorphic_model_typeof_narrow_gap`, 73-02 Task 2) to the
+* Angular target. `$props.X` (a union or `unknown`-typed `model: true` prop)
+* lowers to an Angular signal accessor CALL (`this.X()`); TS does not narrow a
+* `typeof`/`in` guard across two SEPARATE calls to that accessor the way it
+* narrows a plain variable/property read. When a `ConditionalExpression`
+* guards on `typeof $props.X === '<lit>'` / `'<lit>' in $props.X` (X a
+* polymorphic/unknown model prop) AND re-reads `$props.X` again inside the
+* conditional, hoist ONE local binding before the guard and route every
+* `$props.X` read inside the conditional through it — mirroring the hand-
+* authored `const v = $props.value; return typeof v === 'string' ? v : ''`
+* workaround this replaces (DatePicker.rozie, commit bf3766b5).
+*
+* Gated to two known-safe shapes so this never mis-hoists into the wrong scope:
+*   1. the conditional IS an arrow function's own concise body — converted to
+*      a block body wrapping `const v = ...; return <conditional>;`
+*   2. the conditional sits inside a statement that lives in a statement LIST
+*      (block body, switch-case consequent, program body) — including
+*      statements nested inside control-flow blocks (`if`/`for`/`while`/
+*      `switch`/`try`). The local is inserted right before that statement, in
+*      the same block as the guarded reads (Spike-012 BUG-4).
+* A conditional not in either shape (e.g. a bare single-statement `if (x)
+* return …;` with no block) is left alone (falsify-to-no-op, never a wrong fix).
+*
+* Runs on the raw (pre-$props-rewrite) Program, before the main
+* `rewriteRozieIdentifiers` traversal — the injected `$props.X` reference is
+* left for that later pass to lower to the normal `this.X()` accessor call
+* (identical downstream lowering to the DatePicker hand-authored workaround
+* this replaces).
+*/
+function hoistPolymorphicModelGuards$1(cloned, polymorphicModelProps) {
+	if (polymorphicModelProps.size === 0) return;
+	traverse$8(cloned, { ConditionalExpression(path) {
+		const propName = matchesPolymorphicModelGuard$1(path.node.test, polymorphicModelProps);
+		if (!propName) return;
+		let occurrences = 0;
+		path.traverse({ MemberExpression(inner) {
+			if (isPolymorphicModelRead$1(inner.node, polymorphicModelProps) && inner.node.property.name === propName) occurrences++;
+		} });
+		if (occurrences < 2) return;
+		const parentPath = path.parentPath;
+		const isConciseArrowBody = parentPath.isArrowFunctionExpression() && parentPath.node.body === path.node;
+		const stmtPath = path.getStatementParent();
+		const canInsertBeforeStmt = !!stmtPath && stmtPath.inList;
+		if (!isConciseArrowBody && !canInsertBeforeStmt) return;
+		const localName = path.scope.hasBinding("v") ? path.scope.generateUidIdentifier("v").name : "v";
+		path.traverse({ MemberExpression(inner) {
+			if (isPolymorphicModelRead$1(inner.node, polymorphicModelProps) && inner.node.property.name === propName) {
+				inner.replaceWith(_babel_types.identifier(localName));
+				inner.skip();
+			}
+		} });
+		const varDecl = _babel_types.variableDeclaration("const", [_babel_types.variableDeclarator(_babel_types.identifier(localName), _babel_types.memberExpression(_babel_types.identifier("$props"), _babel_types.identifier(propName)))]);
+		if (isConciseArrowBody) {
+			parentPath.node.body = _babel_types.blockStatement([varDecl, _babel_types.returnStatement(path.node)]);
+			return;
+		}
+		stmtPath.insertBefore(varDecl);
+	} });
+}
 /**
 * Rewrite Rozie magic-accessor identifiers in-place on a cloned Program.
 *
@@ -81825,6 +82520,19 @@ function genCode$3(node) {
 	return generate$9(node, GEN_OPTS$8).code;
 }
 /**
+* Quick task 260714-orv — render hoisted user imports in ONE
+* @babel/generator pass so a comment shared between two adjacent imports
+* (Babel attaches it as BOTH the earlier import's `trailingComments` AND the
+* later import's `leadingComments`) prints exactly once. Generating imports
+* one at a time (`nodes.map(genCode).join`) gives each import its OWN
+* comment-dedup set, doubling any shared comment. `t.program(nodes)` prints
+* only its body statements (no wrapping braces/`File` boilerplate), so
+* non-comment cases stay byte-identical.
+*/
+function genImportsBlock$1(nodes) {
+	return generate$9(_babel_types.program(nodes), GEN_OPTS$8).code;
+}
+/**
 * Emit `() => body` for an Expression or BlockStatement body.
 *
 * Building the arrow as a Babel node (rather than string-templating
@@ -81907,7 +82615,7 @@ function renderType$2(ann) {
 		case "Boolean": return "boolean";
 		case "Array": return "any[]";
 		case "Object": return "Record<string, any>";
-		case "Function": return "(...args: unknown[]) => unknown";
+		case "Function": return "(...args: any[]) => any";
 		default: return ann.name;
 	}
 	if (ann.kind === "union") return ann.members.map((m) => {
@@ -81917,7 +82625,7 @@ function renderType$2(ann) {
 	if (ann.kind === "literal") {
 		if (ann.value === "array") return "any[]";
 		if (ann.value === "object") return "Record<string, any>";
-		if (ann.value === "function") return "(...args: unknown[]) => unknown";
+		if (ann.value === "function") return "(...args: any[]) => any";
 		return ann.value;
 	}
 	return "unknown";
@@ -82232,8 +82940,9 @@ function emitScript$2(ir, opts = {}) {
 	deconflictReservedImportBindings(cloned, new Set([...ir.props.map((p) => p.name), ...reservedClassMembers("angular", { singleModel: importSingleModel })]));
 	const { userImports: userImportNodes, hoistedTypeDecls, bodyStmts, valueImportNames } = partitionUserImports$2(cloned);
 	cloned.program.body = bodyStmts;
-	const userImports = userImportNodes.length > 0 ? userImportNodes.map((imp) => genCode$3(imp)).join("\n") + "\n" : "";
+	const userImports = userImportNodes.length > 0 ? genImportsBlock$1(userImportNodes) + "\n" : "";
 	normalizeModelAccessor$2(cloned);
+	hoistPolymorphicModelGuards$1(cloned, new Set(ir.props.filter((p) => p.isModel && (p.typeAnnotation.kind === "union" || renderType$2(p.typeAnnotation) === "unknown")).map((p) => p.name)));
 	hoistDoubleReadAccessors(cloned);
 	const lifecyclePairing = pairClonedLifecycle(cloned, ir);
 	const emitsWithPayload = collectEmitsWithPayload(cloned);
@@ -82871,6 +83580,42 @@ function shouldWrapAttrBinding$1(name, expr, ctx, elementTagName) {
 	return true;
 }
 /**
+* Quick task 260711-tgk — Angular's `[style]=` (`ɵɵstyleMap`) parses the bound
+* value into a semicolon-delimited key:value map. Its parser corrupts on an
+* EMPTY declaration (`;;` — e.g. `pinStyle(colId) + ';' + pad` when
+* `pinStyle` already ends in `;`), silently DROPPING the declaration that
+* follows the empty segment. The other 5 targets apply a `:style` STRING
+* value via the browser's own (tolerant) CSS parser — Angular is the lone
+* outlier because `[style]=` binds through `ɵɵstyleMap`, not `setAttribute`.
+*
+* Fix (see the call site in emitSingleAttr's binding branch): when a
+* `:style` binding's expression is PROVABLY a string at compile time, emit
+* `[attr.style]="<expr>"` instead of `[style]="<expr>"`. `[attr.style]`
+* compiles to `ɵɵattribute` → `setAttribute('style', <string>)`, which the
+* browser parses tolerantly — matching the other 5 targets' behavior. This
+* is only reachable for the element's SOLE style contributor: emitAttributes'
+* `counts.get('style') > 1` merge path (`[ngStyle]`) always intercepts
+* multi-source style bindings (a co-existing static `style=` or a second
+* `:style`) via its own `continue`, before emitSingleAttr is ever called for
+* a style attribute in that case.
+*
+* Conservative by design: a false NEGATIVE (returning false for a value that
+* IS always a string) just keeps the current, already-correct-for-non-`;;`
+* `[style]=` behavior. A false POSITIVE (returning true for a value that can
+* be an object) would break object-valued styles — so every branch below is
+* additive-only and defaults to `false`.
+*/
+function isProvablyStringStyleExpression(expr) {
+	if (_babel_types.isStringLiteral(expr)) return true;
+	if (_babel_types.isTemplateLiteral(expr)) return true;
+	if (_babel_types.isBinaryExpression(expr) && expr.operator === "+") {
+		if (!_babel_types.isExpression(expr.left)) return false;
+		return isProvablyStringStyleExpression(expr.left) || isProvablyStringStyleExpression(expr.right);
+	}
+	if (_babel_types.isConditionalExpression(expr)) return isProvablyStringStyleExpression(expr.consequent) && isProvablyStringStyleExpression(expr.alternate);
+	return false;
+}
+/**
 * Plan 14-05 R6 — keys that must never reach the emitted object from an
 * author-controlled `r-bind` LITERAL. Mirrors the React/Solid/Vue/Svelte
 * `FORBIDDEN_SPREAD_KEYS` set + the Phase 02 `collectPropDecls` write-time
@@ -83280,6 +84025,151 @@ function emitListenerSpread$1(spread, ctx) {
 	return `#${refName}`;
 }
 /**
+* command-palette-portal-overlay phase — the SHARED (once-per-component)
+* `__roziePortalPlace` helper method. Mirrors `applyAttrsHelperDecl` /
+* `listenersRendererFieldDecl`'s dedup pattern: pushed onto
+* `ctx.scriptInjections` at most once regardless of how many `r-portal`
+* elements the component has.
+*
+* A `WeakMap<Element, anchor>` lazily captures each portalled element's
+* ORIGINAL parent + next-sibling on first placement (so a later falsy
+* `target` restores it to its exact natural template position — the AOT-
+* safe, signals-era analog of Vue's `<Teleport :disabled>` / React's
+* ternary in-place fallback). A truthy `target` moves the element via
+* native `appendChild` and records it in `__roziePortalMoved` so the
+* shared `ngOnDestroy` teardown (registered by the per-portal effect, see
+* `emitPortalDirective`) can remove any STILL-relocated node — Angular's
+* own view-destroy machinery is not guaranteed to find a node that has
+* been moved outside its logical view position.
+*/
+const ROZIE_PORTAL_PLACE_FIELD_NAME = "__roziePortalPlace";
+const ROZIE_PORTAL_ANCHORS_FIELD_NAME = "__roziePortalAnchors";
+const ROZIE_PORTAL_MOVED_FIELD_NAME = "__roziePortalMoved";
+function portalAnchorsFieldDecl() {
+	return `private ${ROZIE_PORTAL_ANCHORS_FIELD_NAME} = new WeakMap<Element, { parent: Node | null; next: Node | null }>();`;
+}
+function portalMovedFieldDecl() {
+	return `private ${ROZIE_PORTAL_MOVED_FIELD_NAME} = new Set<Element>();`;
+}
+function portalPlaceMethodDecl() {
+	return [
+		`private ${ROZIE_PORTAL_PLACE_FIELD_NAME}(el: Element, target: Element | null | undefined): void {`,
+		`  let anchor = this.${ROZIE_PORTAL_ANCHORS_FIELD_NAME}.get(el);`,
+		`  if (!anchor) {`,
+		`    anchor = { parent: el.parentNode, next: el.nextSibling };`,
+		`    this.${ROZIE_PORTAL_ANCHORS_FIELD_NAME}.set(el, anchor);`,
+		`  }`,
+		`  if (target) {`,
+		`    if (!this.${ROZIE_PORTAL_MOVED_FIELD_NAME}.has(el) && !el.isConnected) return;`,
+		`    if (el.parentNode !== target) {`,
+		`      target.appendChild(el);`,
+		`    }`,
+		`    this.${ROZIE_PORTAL_MOVED_FIELD_NAME}.add(el);`,
+		`    return;`,
+		`  }`,
+		`  if (!this.${ROZIE_PORTAL_MOVED_FIELD_NAME}.has(el)) return;`,
+		`  this.${ROZIE_PORTAL_MOVED_FIELD_NAME}.delete(el);`,
+		`  if (anchor.parent) {`,
+		`    if (anchor.next && anchor.next.parentNode === anchor.parent) {`,
+		`      anchor.parent.insertBefore(el, anchor.next);`,
+		`    } else {`,
+		`      anchor.parent.appendChild(el);`,
+		`    }`,
+		`  }`,
+		`}`
+	].join("\n");
+}
+/**
+* command-palette-portal-overlay phase — emit the per-element machinery for
+* ONE `r-portal="<expr>"` element:
+*   - a `#roziePortal_<N>` template-ref attribute (returned for splicing
+*     onto the open tag),
+*   - a `viewChild<ElementRef>('roziePortal_<N>')` private field,
+*   - the SHARED `__roziePortalPlace`/anchors/moved-set fields (once per
+*     component — mirrors `emitSpreadBinding`'s `applyAttrsHelperDecl`
+*     dedup),
+*   - a `private __roziePortal_<N>_effect = effect(() => { ... });` field
+*     initializer that guards `nativeElement` (Pitfall 7 — `viewChild()`
+*     signals return `undefined` until the view is initialized, so a
+*     pre-render effect tick is a safe no-op) and re-runs the placement
+*     whenever the container expression's SIGNAL dependencies change
+*     (the AOT-safe, signals-era analog of a reactive `$watch`).
+*
+* AOT-SAFE by construction: no `import.meta.url` (not referenced at all),
+* no inline template arrow (the container expression is a plain property/
+* method-call expression spliced into a `effect()` callback BODY — a
+* function statement, not a template-attribute arrow literal; analogjs AOT
+* rejects arrows INSIDE `{{ }}`/binding attribute VALUES, not inside a
+* class-field-initializer's own script-side callback).
+*
+* `effect()` in a field initializer is valid Angular injection context
+* (mirrors `emitSpreadBinding`/`emitListenerSpread`'s identical Pitfall-8
+* rationale) — no separate `ngAfterViewInit`/constructor wiring is needed,
+* unlike the r-keynav controller (which needs `viewChild()` to resolve
+* itself for the FIRST commit-timing-sensitive read; a portal's placement
+* has no such ordering hazard — `effect()`'s own no-op-until-mounted guard
+* covers the initial-render case identically to every render after it).
+*/
+function emitPortalDirective(element, ctx) {
+	const counter = ctx.injectionCounter ?? { next: 0 };
+	const idx = counter.next++;
+	const refName = `roziePortal_${idx}`;
+	const effectFieldName = `__roziePortal_${idx}_effect`;
+	const destroyRegisteredFieldName = `__roziePortal_${idx}_destroyRegistered`;
+	const containerCode = rewriteListenerExpression(element.portalTo.expression, ctx.ir, {
+		collisionRenames: ctx.collisionRenames,
+		classMembers: ctx.classMembers,
+		cvaModelProp: ctx.cvaModelProp,
+		cvaMergeDisabled: ctx.cvaMergeDisabled
+	});
+	if (ctx.scriptInjections !== void 0) {
+		ctx.scriptInjections.push({
+			name: refName,
+			decl: `private ${refName} = viewChild<ElementRef>('${refName}');`
+		});
+		if (!ctx.scriptInjections.some((si) => si.name === ROZIE_PORTAL_ANCHORS_FIELD_NAME)) {
+			ctx.scriptInjections.push({
+				name: ROZIE_PORTAL_ANCHORS_FIELD_NAME,
+				decl: portalAnchorsFieldDecl()
+			});
+			ctx.scriptInjections.push({
+				name: ROZIE_PORTAL_MOVED_FIELD_NAME,
+				decl: portalMovedFieldDecl()
+			});
+			ctx.scriptInjections.push({
+				name: ROZIE_PORTAL_PLACE_FIELD_NAME,
+				decl: portalPlaceMethodDecl()
+			});
+		}
+		ctx.scriptInjections.push({
+			name: destroyRegisteredFieldName,
+			decl: `private ${destroyRegisteredFieldName} = false;`
+		});
+		const effectDecl = [
+			`private ${effectFieldName} = effect(() => {`,
+			`  const el = this.${refName}()?.nativeElement;`,
+			`  if (!el) return;`,
+			`  this.${ROZIE_PORTAL_PLACE_FIELD_NAME}(el, ${containerCode});`,
+			`  if (!this.${destroyRegisteredFieldName}) {`,
+			`    this.${destroyRegisteredFieldName} = true;`,
+			`    this.__rozieDestroyRef.onDestroy(() => {`,
+			`      for (const moved of this.${ROZIE_PORTAL_MOVED_FIELD_NAME}) {`,
+			`        moved.parentNode?.removeChild(moved);`,
+			`      }`,
+			`    });`,
+			`  }`,
+			`});`
+		].join("\n");
+		ctx.scriptInjections.push({
+			name: effectFieldName,
+			decl: effectDecl
+		});
+	}
+	if (ctx.hasListenerSpread !== void 0) ctx.hasListenerSpread.value = true;
+	if (ctx.needsDestroyRefField !== void 0) ctx.needsDestroyRefField.value = true;
+	return `#${refName}`;
+}
+/**
 * Emit a single attribute. Returns null when the attribute should be dropped
 * (e.g., r-html, which gets emitted later as `[innerHTML]="..."` by the
 * element emitter).
@@ -83326,6 +84216,7 @@ function emitSingleAttr(attr, ctx, elementTagName) {
 			if (ctx.hasDisplayWrap) ctx.hasDisplayWrap.value = true;
 			return `[${bindingName.startsWith("attr.") ? bindingName : `attr.${attr.name}`}]="rozieAttr(${expr})"`;
 		}
+		if (attr.name === "style" && isProvablyStringStyleExpression(attr.expression)) return `[attr.style]="${expr}"`;
 		return `[${bindingName}]="${expr}"`;
 	}
 	if (attr.segments.length === 1 && attr.segments[0].kind === "binding") {
@@ -84503,6 +85394,21 @@ function emitElementInner$2(origNode, ctx) {
 	if (attrText) partsHead.push(attrText);
 	if (eventText) partsHead.push(eventText);
 	for (const text of dynamicListenerTexts) partsHead.push(text);
+	if (node.portalTo) {
+		const portalRefText = emitPortalDirective(node, {
+			ir: ctx.ir,
+			collisionRenames: ctx.collisionRenames,
+			loopBindings: ctx.loopBindings,
+			scriptInjections: ctx.scriptInjections,
+			injectionCounter: ctx.injectionCounter,
+			hasListenerSpread: ctx.hasListenerSpread,
+			needsDestroyRefField: ctx.needsDestroyRefField,
+			cvaModelProp: ctx.cvaModelProp,
+			cvaMergeDisabled: ctx.cvaMergeDisabled,
+			classMembers: ctx.classMembers
+		});
+		partsHead.push(portalRefText);
+	}
 	const keynav = ctx.keynav ?? null;
 	const keynavAttrs = [...keynavRootAttrs$2(keynav, node, ctx.ir), ...keynavItemAttrs$2(keynav, node, ctx.keynavItemIndexAlias ?? null, ctx.ir)];
 	for (const a of keynavAttrs) partsHead.push(a);
@@ -86150,7 +87056,7 @@ function renderType$1(ann) {
 		case "Boolean": return "boolean";
 		case "Array": return "any[]";
 		case "Object": return "Record<string, any>";
-		case "Function": return "(...args: unknown[]) => unknown";
+		case "Function": return "(...args: any[]) => any";
 		default: return ann.name;
 	}
 	if (ann.kind === "union") return ann.members.map((m) => {
@@ -86160,7 +87066,7 @@ function renderType$1(ann) {
 	if (ann.kind === "literal") {
 		if (ann.value === "array") return "any[]";
 		if (ann.value === "object") return "Record<string, any>";
-		if (ann.value === "function") return "(...args: unknown[]) => unknown";
+		if (ann.value === "function") return "(...args: any[]) => any";
 		return ann.value;
 	}
 	return "unknown";
@@ -86289,6 +87195,63 @@ function buildSetterCall$1(varName, operator, rhs) {
 	return _babel_types.callExpression(_babel_types.identifier(setterName), [_babel_types.binaryExpression(binOp, _babel_types.callExpression(_babel_types.identifier(varName), []), rhs)]);
 }
 /**
+* 260712-ig6 Task B — detects the "null-widened prop spliced into a 3rd-party
+* object-literal call argument" shape: a `$props.<name>` read (where `<name>`
+* has `default: null`) that ultimately feeds an `ObjectProperty` VALUE inside
+* an `ObjectExpression` that is (possibly via nested object-literal property
+* values, e.g. `useEngine(el, { options: { group: $props.group } })`) itself
+* a DIRECT argument of a `CallExpression` — the mount-time engine-init shape
+* (`useSortableJS($refs.listEl, { options: { handle: $props.handle, ... } })`).
+*
+* Walks UP from the read, tolerating exactly two pass-through shapes on the
+* way to an `ObjectProperty` value:
+*   - `ConditionalExpression` consequent/alternate (the `group` prop's
+*     `cloneable ? { ... } : $props.group` ternary)
+*   - nested `ObjectExpression` → `ObjectProperty` value chains (an object
+*     literal nested inside another object literal's property value)
+*
+* Any OTHER parent shape (binary/logical expression, array literal, bare
+* statement, non-direct call argument, …) fails the match — this is
+* intentionally narrow, mirroring Pattern D's `isDirectCallArg` precedent.
+* Distinct from Pattern D: Pattern D fires on `$refs` DOM-ref reads that are
+* THEMSELVES a direct call argument; this fires on `$props` reads nested
+* inside an object-literal call argument.
+*
+* `excludeCallees` DISQUALIFIES the match when the terminal call's callee is
+* one of the emitter's OWN synthesized reactive setters (`set<Data>` /
+* `set<ModelProp>`, minted by `buildSetterCall` for `$data.x = {...}` /
+* `$model.x = {...}` writes). Those setter calls are Rozie-internal — the
+* `{...}` argument feeds a Solid `createSignal` setter, not a 3rd-party lib's
+* typed options object, so a null-widened prop spliced into one must stay
+* `null` verbatim (the cross-target `PropDefaultCoercion` conformance probe
+* asserts `JSON.stringify({ a: null, ... })` renders the literal `"a":null`
+* substring on every target — `?? undefined` would DROP the key entirely,
+* a real cross-target behavior regression, not a type-only change).
+*/
+function isNullWidenedPropObjectLiteralCallArgTarget(path, excludeCallees) {
+	let cur = path;
+	for (;;) {
+		const parent = cur.parentPath;
+		if (!parent) return false;
+		if (parent.isConditionalExpression() && (parent.node.consequent === cur.node || parent.node.alternate === cur.node)) {
+			cur = parent;
+			continue;
+		}
+		if (parent.isObjectProperty() && parent.node.value === cur.node) {
+			const objExpr = parent.parentPath;
+			if (!objExpr || !objExpr.isObjectExpression()) return false;
+			cur = objExpr;
+			continue;
+		}
+		if (parent.isCallExpression() && parent.node.arguments.some((arg) => arg === cur.node)) {
+			const callee = parent.node.callee;
+			if (_babel_types.isIdentifier(callee) && excludeCallees.has(callee.name)) return false;
+			return true;
+		}
+		return false;
+	}
+}
+/**
 * Phase 18 (Req 2) — normalize the producer-side two-way-write sigil `$model`
 * to `$props` across a cloned File, in place. See the call-site comment in
 * `rewriteRozieIdentifiers` for the full contract; `$model.X` is model-only and
@@ -86395,7 +87358,7 @@ function hoistPolymorphicModelGuards(cloned, polymorphicModelProps) {
 *
 * @experimental — shape may change before v1.0
 */
-function rewriteRozieExpressionNode(expr, ir) {
+function rewriteRozieExpressionNode(expr, ir, options) {
 	let programBody;
 	const isBlock = _babel_types.isBlockStatement(expr);
 	if (isBlock) programBody = _babel_types.cloneNode(expr, true, false).body;
@@ -86409,7 +87372,7 @@ function rewriteRozieExpressionNode(expr, ir) {
 			sourceType: "module"
 		},
 		comments: []
-	}, ir).rewrittenProgram.program.body;
+	}, ir, options).rewrittenProgram.program.body;
 	if (isBlock) return _babel_types.blockStatement(body);
 	if (body.length === 1 && _babel_types.isExpressionStatement(body[0])) return body[0].expression;
 	const last = body[body.length - 1];
@@ -86420,10 +87383,12 @@ function rewriteRozieExpressionNode(expr, ir) {
 * Full Solid identifier rewrite pass. Replaces all $props/$data/$refs/$emit
 * references with their Solid-idiomatic equivalents.
 */
-function rewriteRozieIdentifiers(cloned, ir) {
+function rewriteRozieIdentifiers(cloned, ir, options) {
 	const diagnostics = [];
+	const nonNullRefCallArgs = options?.nonNullRefCallArgs === true;
 	const modelProps = new Set(ir.props.filter((p) => p.isModel).map((p) => p.name));
 	const nonModelProps = new Set(ir.props.filter((p) => !p.isModel).map((p) => p.name));
+	const nullWidenedNonModelProps = new Set(ir.props.filter((p) => !p.isModel && _babel_types.isNullLiteral(p.defaultValue)).map((p) => p.name));
 	const unknownModelProps = new Set(ir.props.filter((p) => p.isModel && renderType$1(p.typeAnnotation) === "unknown").map((p) => p.name));
 	const polymorphicModelProps = new Set(ir.props.filter((p) => p.isModel && (p.typeAnnotation.kind === "union" || renderType$1(p.typeAnnotation) === "unknown")).map((p) => p.name));
 	const dataNames = new Set(ir.state.map((s) => s.name));
@@ -86540,6 +87505,12 @@ function rewriteRozieIdentifiers(cloned, ir) {
 					return;
 				}
 				if (nonModelProps.has(property.name)) {
+					if (nonNullRefCallArgs && nullWidenedNonModelProps.has(property.name) && isNullWidenedPropObjectLiteralCallArgTarget(path, solidSetters)) {
+						const localRead = _babel_types.memberExpression(_babel_types.identifier("local"), _babel_types.identifier(property.name));
+						path.replaceWith(_babel_types.logicalExpression("??", localRead, _babel_types.identifier("undefined")));
+						path.skip();
+						return;
+					}
 					path.node.object = _babel_types.identifier("local");
 					return;
 				}
@@ -86553,7 +87524,8 @@ function rewriteRozieIdentifiers(cloned, ir) {
 			}
 			if (object.name === "$refs" && refNames.has(property.name)) {
 				const refIdent = _babel_types.identifier(property.name + "Ref");
-				if (property.name === "__rozieRoot") path.replaceWith(_babel_types.tsNonNullExpression(refIdent));
+				const isDirectCallArg = nonNullRefCallArgs && path.parentPath?.isCallExpression() && path.parentPath.node.arguments.includes(path.node);
+				if (property.name === "__rozieRoot" || isDirectCallArg) path.replaceWith(_babel_types.tsNonNullExpression(refIdent));
 				else path.replaceWith(refIdent);
 				path.skip();
 				return;
@@ -86934,6 +87906,19 @@ function genCode$1(node) {
 	return generate$7(node, GEN_OPTS$6).code;
 }
 /**
+* Quick task 260714-orv — render hoisted user imports in ONE
+* @babel/generator pass so a comment shared between two adjacent imports
+* (Babel attaches it as BOTH the earlier import's `trailingComments` AND the
+* later import's `leadingComments`) prints exactly once. Generating imports
+* one at a time (`nodes.map(genCode).join`) gives each import its OWN
+* comment-dedup set, doubling any shared comment. `t.program(nodes)` prints
+* only its body statements (no wrapping braces/`File` boilerplate), so
+* non-comment cases stay byte-identical.
+*/
+function genImportsBlock(nodes) {
+	return generate$7(_babel_types.program(nodes), GEN_OPTS$6).code;
+}
+/**
 * ROZ-cast-blindness fix — Solid emits each ComputedDecl's body via
 * `rewriteNode(c.body, ir)` directly from IR (never re-scanning the cloned
 * Program for the body itself), so there is no existing "find the cloned
@@ -86992,6 +87977,17 @@ function capitalize$6(name) {
 	return name.charAt(0).toUpperCase() + name.slice(1);
 }
 /**
+* 260712-kl1 — exact-AST-shape gate mirroring the `isMutableLiteralFactoryDefault`
+* / `isNullWidenedPropObjectLiteralCallArgTarget` predicate convention. Matches
+* ONLY a Babel `NullLiteral` prop default (`default: null`) — never `undefined`,
+* `void 0`, or any other falsy/nullish shape. Used to widen a model prop's
+* `createControllableSignal<T>` generic to `T | null` (see 260712-kb9's
+* NEW-controllable-null-default catalog entry).
+*/
+function isNullLiteralDefault(dv) {
+	return _babel_types.isNullLiteral(dv);
+}
+/**
 * WR-01 fix (73-REVIEW.md, 73-10 gap-closure): collect every Identifier
 * binding name introduced by a declarator's `id` pattern — Identifier
 * directly, or recursively through ObjectPattern / ArrayPattern /
@@ -87204,7 +88200,7 @@ function emitScript$1(ir, collectors, _registry) {
 	diagnostics.push(...rewriteResult.diagnostics);
 	const { userImports: userImportNodes, hoistedTypeDecls: hoistedTypeNodes, bodyStmts } = partitionUserImports$1(rewriteResult.rewrittenProgram);
 	rewriteResult.rewrittenProgram.program.body = bodyStmts;
-	const userImports = userImportNodes.length > 0 ? userImportNodes.map((imp) => genCode$1(imp)).join("\n") + "\n" : "";
+	const userImports = userImportNodes.length > 0 ? genImportsBlock(userImportNodes) + "\n" : "";
 	const hoistedTypeDecls = hoistedTypeNodes.map((decl) => genCode$1(decl));
 	const contextEmit = emitContext$1(ir, {
 		solid: collectors.solidImports,
@@ -87220,7 +88216,9 @@ function emitScript$1(ir, collectors, _registry) {
 			const dv = p.defaultValue;
 			const raw = genCode$1(dv);
 			const val = isMutableLiteralFactoryDefault(dv) ? `(${raw})()` : raw;
-			return `${p.name}: ${val}`;
+			const ann = p.typeAnnotation;
+			const entryVal = isMutableLiteralFactoryDefault(dv) && ann.kind === "identifier" && (ann.name === "Object" || ann.name === "Array") ? `${val} as ${renderType$1(ann)}` : val;
+			return `${p.name}: ${entryVal}`;
 		}).join(", ")} }, _props);\n`;
 	}
 	for (const p of ir.props) {
@@ -87234,7 +88232,8 @@ function emitScript$1(ir, collectors, _registry) {
 			else dflt = raw;
 		}
 		const tsType = renderType$1(p.typeAnnotation);
-		hookLines.push(`const [${p.name}, ${setterName}] = createControllableSignal<${tsType}>(_props as unknown as Record<string, unknown>, '${p.name}', ${dflt});`);
+		const genericType = isNullLiteralDefault(p.defaultValue) && tsType !== "unknown" ? `${tsType} | null` : tsType;
+		hookLines.push(`const [${p.name}, ${setterName}] = createControllableSignal<${genericType}>(_props as unknown as Record<string, unknown>, '${p.name}', ${dflt});`);
 	}
 	for (const s of ir.state) {
 		collectors.solidImports.add("createSignal");
@@ -87266,7 +88265,7 @@ function emitScript$1(ir, collectors, _registry) {
 	for (const lh of ir.lifecycle) if (lh.phase === "mount") if (lh.cleanup) {
 		collectors.solidImports.add("onMount");
 		collectors.solidImports.add("onCleanup");
-		const rewrittenSetup = rewriteRozieExpressionNode(lh.setup, ir);
+		const rewrittenSetup = rewriteRozieExpressionNode(lh.setup, ir, { nonNullRefCallArgs: true });
 		const rewrittenCleanup = rewriteRozieExpressionNode(lh.cleanup, ir);
 		if (_babel_types.isBlockStatement(lh.setup) && cleanupReferencesSetupLocal(lh.setup, lh.cleanup)) {
 			const setupStatements = rewrittenSetup.body;
@@ -87280,7 +88279,7 @@ function emitScript$1(ir, collectors, _registry) {
 		}
 	} else {
 		collectors.solidImports.add("onMount");
-		const arg = lifecycleArg(rewriteRozieExpressionNode(lh.setup, ir));
+		const arg = lifecycleArg(rewriteRozieExpressionNode(lh.setup, ir, { nonNullRefCallArgs: true }));
 		hookLines.push(`onMount(${arg});`);
 	}
 	else if (lh.phase === "unmount") {
@@ -89955,7 +90954,22 @@ function emitLoop$1(node, ctx) {
 		invokeAccessors: ctx.invokeAccessors,
 		loopValueBindings: new Set([...ctx.loopValueBindings ?? [], node.itemAlias])
 	});
-	return `<Key each={${iterableCode} as readonly any[]} by={(${node.itemAlias}) => ${keyCode}}>{${aliasStr} => ${bodyJsx}}</Key>`;
+	return `<Key each={${new Set([
+		"Identifier",
+		"MemberExpression",
+		"OptionalMemberExpression",
+		"CallExpression",
+		"OptionalCallExpression",
+		"NewExpression",
+		"ArrayExpression",
+		"ObjectExpression",
+		"TSNonNullExpression",
+		"TSAsExpression",
+		"ParenthesizedExpression",
+		"StringLiteral",
+		"NumericLiteral",
+		"TemplateLiteral"
+	]).has(node.iterableExpression.type) ? iterableCode : `(${iterableCode})`} as readonly any[]} by={(${node.itemAlias}) => ${keyCode}}>{${aliasStr} => ${bodyJsx}}</Key>`;
 }
 /**
 * Find an attribute by name.
@@ -90301,8 +91315,34 @@ function mergeEventAttributes(attrsJsx, eventsJsx, elementTag) {
 * (so the child is never hidden) while still changing value — and thus
 * still triggering `keyed` recreation — whenever the underlying key changes.
 */
+/**
+* command-palette-portal-overlay phase — `r-portal="<expr>"` element
+* teleport. Wraps the element markup in Solid's native `<Show when={c}
+* fallback={tree}><Portal mount={c}>{tree}</Portal></Show>` — falsy
+* container renders `tree` in place via the `fallback` prop (never mounts
+* `<Portal>` at all), matching React's `container ? createPortal(tree,
+* container) : tree` and Vue's `<Teleport :disabled>` in-place semantics.
+*
+* SSR guard: `typeof document === 'undefined'` short-circuits the container
+* expression to `null` BEFORE it is evaluated at all — some author
+* expressions call `document.querySelector` internally (see
+* `resolveAppendTo`/`resolveTo`), so the guard must gate evaluation, not
+* just the result.
+*/
+function emitPortalWrap(node, markup, ctx) {
+	const { expression } = node.portalTo;
+	if (ctx.elementPortalImport) ctx.elementPortalImport.needed = true;
+	const containerCode = `(typeof document === 'undefined' ? null : (${rewriteTemplateExpression$1(expression, ctx.ir, {
+		invokeAccessors: ctx.invokeAccessors,
+		loopValueBindings: ctx.loopValueBindings,
+		scopeAccessorParams: ctx.scopeAccessorParams
+	})}))`;
+	ctx.collectors.solid.add("Show");
+	return `<Show when={${containerCode}} fallback={${markup}}><Portal mount={${containerCode}}>${markup}</Portal></Show>`;
+}
 function emitElement$1(origNode, ctx) {
 	const markup = emitElementInner$1(origNode, ctx);
+	if (origNode.portalTo) return emitPortalWrap(origNode, markup, ctx);
 	if ((origNode.tagKind === "component" || origNode.tagKind === "self") && origNode.remountKeyExpression) {
 		const keyExprCode = rewriteTemplateExpression$1(origNode.remountKeyExpression, ctx.ir, {
 			invokeAccessors: ctx.invokeAccessors,
@@ -90540,11 +91580,13 @@ function emitTemplate$1(ir, collectors, registry, opts = {}) {
 		jsx: "null",
 		scriptInjections: [],
 		needsKeyedImport: false,
-		diagnostics: []
+		diagnostics: [],
+		hasElementPortal: false
 	};
 	const scriptInjections = [];
 	const injectionCounter = { next: 0 };
 	const keyedImport = { needed: false };
+	const elementPortalImport = { needed: false };
 	const keynav = resolveKeynavPlan$1(ir);
 	const ctx = {
 		ir,
@@ -90554,6 +91596,7 @@ function emitTemplate$1(ir, collectors, registry, opts = {}) {
 		scriptInjections,
 		injectionCounter,
 		keyedImport,
+		elementPortalImport,
 		keynav,
 		...opts.scopeAttr !== void 0 ? { scopeAttr: opts.scopeAttr } : {}
 	};
@@ -90563,7 +91606,8 @@ function emitTemplate$1(ir, collectors, registry, opts = {}) {
 		jsx,
 		scriptInjections,
 		needsKeyedImport: keyedImport.needed,
-		diagnostics
+		diagnostics,
+		hasElementPortal: elementPortalImport.needed
 	};
 }
 //#endregion
@@ -91532,7 +92576,7 @@ function emitSolid(ir, opts = {}) {
 		...listenersResult.scriptInjections
 	].filter((s) => s.trim().length > 0).join("\n\n");
 	const solidImportsStr = `import type { JSX } from 'solid-js';\n` + solidImports.render();
-	const portalImport = scriptResult.hasPortals ? "import { render } from 'solid-js/web';\n" : "";
+	const portalImport = (scriptResult.hasPortals ? "import { render } from 'solid-js/web';\n" : "") + (templateResult.hasElementPortal ? "import { Portal } from 'solid-js/web';\n" : "");
 	const keyedImport = templateResult.needsKeyedImport ? "import { Key } from '@solid-primitives/keyed';\n" : "";
 	const shell = buildShell$1({
 		componentName: ir.name,
@@ -93024,7 +94068,7 @@ function renderTsType(ann) {
 		case "Boolean": return "boolean";
 		case "Array": return "any[]";
 		case "Object": return "any";
-		case "Function": return "((...args: unknown[]) => unknown) | null";
+		case "Function": return "((...args: any[]) => any) | null";
 		default: return ann.name;
 	}
 	if (ann.kind === "union") return ann.members.map((m) => {
@@ -93053,14 +94097,81 @@ function renderTsType(ann) {
 * The `!`-shape matches what Rozie already emits for Angular `@Input` and Lit
 * `@query` ref fields.
 */
+/**
+* 260712-a09 (Pattern B) — an explicit `default: undefined` (or `default: void 0`)
+* is authorial shorthand for "no meaningful default", not a real default value.
+* `prop.defaultValue` is a live (non-null) AST node for either form, so the
+* `prop.defaultValue != null` guard below would otherwise route it into the
+* `= <default>` initializer branch and emit `foo: string = undefined` — a
+* TS2322 under strictNullChecks (a typed field can't be initialized with
+* `undefined` unless the type itself admits it). Detect both spellings here
+* and treat them identically to "no default" so they fall through to the
+* existing `?:`/`!:` branch.
+*/
+function isUndefinedDefault(expr) {
+	return _babel_types.isIdentifier(expr, { name: "undefined" }) || _babel_types.isUnaryExpression(expr) && expr.operator === "void";
+}
+/**
+* 260712-ig6 Task A — the full ARIAMixin field-name set (lib.dom.d.ts). A
+* prop authored with one of these names collides with LitElement's own
+* `implements ARIAMixin` field declaration (always `<T> | null`, NEVER
+* `undefined`-admitting) if it lands in the ordinary no-default `?:`/`!:`
+* branch below — Pattern B's `default: undefined` routes there and would
+* otherwise emit `ariaLabel?: string;` (`string | undefined`), which is not
+* assignable to the base class's `string | null` field (TS2416/TS1240).
+* Gated STRICTLY on name-set membership so every other prop name keeps its
+* pre-existing byte-identical `?:`/`!:` output.
+*/
+const ARIA_MIXIN_FIELDS = new Set([
+	"ariaAtomic",
+	"ariaAutoComplete",
+	"ariaBusy",
+	"ariaChecked",
+	"ariaColCount",
+	"ariaColIndex",
+	"ariaColSpan",
+	"ariaCurrent",
+	"ariaDescription",
+	"ariaDisabled",
+	"ariaExpanded",
+	"ariaHasPopup",
+	"ariaHidden",
+	"ariaInvalid",
+	"ariaKeyShortcuts",
+	"ariaLabel",
+	"ariaLevel",
+	"ariaLive",
+	"ariaModal",
+	"ariaMultiLine",
+	"ariaMultiSelectable",
+	"ariaOrientation",
+	"ariaPlaceholder",
+	"ariaPosInSet",
+	"ariaPressed",
+	"ariaReadOnly",
+	"ariaRequired",
+	"ariaRoleDescription",
+	"ariaRowCount",
+	"ariaRowIndex",
+	"ariaRowSpan",
+	"ariaSelected",
+	"ariaSetSize",
+	"ariaSort",
+	"ariaValueMax",
+	"ariaValueMin",
+	"ariaValueNow",
+	"ariaValueText",
+	"role"
+]);
 function renderFieldSuffix(prop) {
 	const tsType = renderTsType(prop.typeAnnotation);
-	if (prop.defaultValue != null) {
+	if (prop.defaultValue != null && !isUndefinedDefault(prop.defaultValue)) {
 		let fieldType = tsType;
 		const admitsNull = /\bnull\b/.test(fieldType) || /(^|\|)\s*(any|unknown)\s*(\||$)/.test(fieldType);
 		if (_babel_types.isNullLiteral(prop.defaultValue) && !admitsNull) fieldType = `${fieldType} | null`;
 		return `: ${fieldType} = ${renderDefault(prop.defaultValue, prop.typeAnnotation)}`;
 	}
+	if (ARIA_MIXIN_FIELDS.has(prop.name)) return `: ${/\bnull\b/.test(tsType) || /(^|\|)\s*(any|unknown)\s*(\||$)/.test(tsType) ? tsType : `${tsType} | null`} = null`;
 	return prop.required ? `!: ${tsType}` : `?: ${tsType}`;
 }
 function isPrimitiveType(ann) {
@@ -93433,12 +94544,15 @@ function emitScript(ir, opts) {
 	const composedTypeImportLines = [];
 	for (const typeName of composedTypeImports) {
 		const decl = (ir.components ?? []).find((c) => c.localName === typeName);
-		if (decl) composedTypeImportLines.push(`import type { ${typeName} } from '${decl.importPath}';`);
+		if (decl) {
+			const importPath = isPublishedSpecifier(decl.importPath) ? rewriteRozieImport(decl.importPath, "lit") : decl.importPath;
+			composedTypeImportLines.push(`import type { ${typeName} } from '${importPath}';`);
+		}
 	}
 	const rewritten = rewriteScript(ir.setupBody.scriptProgram, ir, { runtime: opts.runtime });
 	const { userImports: userImportNodes, hoistedTypeDecls: hoistedTypeNodes, bodyStmts: nonImportStmts } = partitionUserImports(rewritten.file);
 	rewritten.file.program.body = nonImportStmts;
-	const userImports = (composedTypeImportLines.length > 0 ? composedTypeImportLines.join("\n") + "\n" : "") + (userImportNodes.length > 0 ? userImportNodes.map((imp) => generate$1(imp, GEN_OPTS$1).code).join("\n") + "\n" : "");
+	const userImports = (composedTypeImportLines.length > 0 ? composedTypeImportLines.join("\n") + "\n" : "") + (userImportNodes.length > 0 ? generate$1(_babel_types.program(userImportNodes), GEN_OPTS$1).code + "\n" : "");
 	const hoistedTypeDecls = hoistedTypeNodes.map((decl) => generate$1(decl, GEN_OPTS$1).code);
 	const partition = partitionScript(rewritten.file);
 	const computedNames = new Set(ir.computed.map((c) => c.name));
@@ -95166,6 +96280,7 @@ function emitElementOpenTag(node, ir, irName, opts) {
 	const tagName = resolveTagName(node, irName);
 	const parts = [];
 	let refAttr = null;
+	let portalSentinel = "";
 	const rModelAttr = node.attributes.find((a) => attributeIsRModel(a));
 	const staticClassValues = [];
 	let bindingClass = null;
@@ -95268,16 +96383,27 @@ function emitElementOpenTag(node, ir, irName, opts) {
 		parts.push(`\${rozieListeners(${expr})}`);
 	}
 	if (refAttr) parts.push(refAttr);
+	if (node.portalTo && opts._state) {
+		const fieldName = `__roziePortal${opts._state.portalCount++}`;
+		parts.push(`data-rozie-portal-ref="${fieldName}"`);
+		portalSentinel = `<span data-rozie-portal-anchor="${fieldName}" hidden></span>`;
+		opts.decorators.add("query");
+		opts.runtime.add("RoziePortalController");
+		const containerCode = rewriteTemplateExpression(node.portalTo.expression, ir);
+		opts._state.portalFieldDecls.push(`  @query('[data-rozie-portal-ref="${fieldName}"]') private ${fieldName}!: HTMLElement;`);
+		opts._state.portalFieldDecls.push(`  @query('[data-rozie-portal-anchor="${fieldName}"]') private ${fieldName}Anchor!: HTMLElement;`);
+		opts._state.portalFieldDecls.push(`  private ${fieldName}Controller = new RoziePortalController(this, () => this.${fieldName}, () => this.${fieldName}Anchor, () => (${containerCode}));`);
+	}
 	const keynav = opts.keynav ?? null;
 	parts.push(...keynavRootAttrs(keynav, node, opts.runtime), ...keynavItemAttrs(keynav, node, opts.keynavItemIndexAlias ?? null));
 	if ((node.tagKind === "html" || node.tagKind === "component") && opts.scopeHash) parts.push(`data-rozie-s-${opts.scopeHash}`);
 	const attrsText = parts.length > 0 ? " " + parts.join(" ") : "";
 	if (isVoidElement(node.tagName) && node.children.length === 0) return {
-		open: `<${tagName}${attrsText} />`,
+		open: `${portalSentinel}<${tagName}${attrsText} />`,
 		selfClose: true
 	};
 	return {
-		open: `<${tagName}${attrsText}>`,
+		open: `${portalSentinel}<${tagName}${attrsText}>`,
 		selfClose: false
 	};
 }
@@ -95546,6 +96672,8 @@ function emitTemplate(ir, opts) {
 		slotFillerClassFields: [],
 		slotFillerUpdatedBody: [],
 		slotFillerDisconnectReset: [],
+		portalFieldDecls: [],
+		portalCount: 0,
 		diagnostics
 	};
 	const keynav = resolveKeynavPlan(ir);
@@ -95574,6 +96702,7 @@ function emitTemplate(ir, opts) {
 			slotFillerUpdatedBody: state.slotFillerUpdatedBody,
 			slotFillerDisconnectReset: state.slotFillerDisconnectReset,
 			keynavFieldDecls,
+			portalFieldDecls: state.portalFieldDecls,
 			diagnostics
 		};
 	}
@@ -95596,6 +96725,7 @@ function emitTemplate(ir, opts) {
 		slotFillerUpdatedBody: state.slotFillerUpdatedBody,
 		slotFillerDisconnectReset: state.slotFillerDisconnectReset,
 		keynavFieldDecls,
+		portalFieldDecls: state.portalFieldDecls,
 		diagnostics
 	};
 }
@@ -96056,7 +97186,11 @@ function emitStyle(styles, source, opts) {
 	const engineCss = stringifyRules((styles.engineRules ?? []).flatMap((r) => r.children ?? []), source);
 	const rawScopedCss = stringifyRules(scopedRules, source);
 	const scopedCss = opts.scopeHash ? scopeCss(rawScopedCss, opts.scopeHash) : rawScopedCss;
-	const globalCss = [rootRules.length > 0 ? stringifyRules(rootRules, source) : "", engineCss].filter((s) => s.length > 0).join("\n");
+	const globalCss = [
+		rootRules.length > 0 ? stringifyRules(rootRules, source) : "",
+		engineCss,
+		opts.hasElementPortal === true ? scopedCss : ""
+	].filter((s) => s.length > 0).join("\n");
 	const combinedScoped = [
 		HOST_DISPLAY_DEFAULT,
 		scopedCss,
@@ -96133,6 +97267,33 @@ function buildShell(parts) {
 }
 //#endregion
 //#region ../targets/lit/src/emitLit.ts
+/**
+* command-palette-portal-overlay phase — a cheap, INDEPENDENT presence-only
+* walk over `ir.template` for at least one `r-portal` element. Needed
+* because `emitStyle` runs BEFORE `emitTemplate` in this file's call
+* sequence (styles must be ready before the template walk references
+* `opts.scopeHash`), so the template-walk-derived `portalCount` isn't
+* available yet at the point `emitStyle` needs to know whether to ALSO
+* push `scopedCss` through `injectGlobalStyles` (see `emitStyle.ts`'s
+* `opts.hasElementPortal` doc comment / `RoziePortalController.ts`'s module
+* doc comment for WHY). A second, tiny boolean-only walk is simpler and
+* lower-risk than reordering the two emit passes or synchronizing two
+* independent per-element counters.
+*/
+function hasElementPortal(node) {
+	if (node === null) return false;
+	switch (node.type) {
+		case "TemplateElement":
+			if (node.portalTo !== void 0) return true;
+			return node.children.some(hasElementPortal);
+		case "TemplateFragment": return node.children.some(hasElementPortal);
+		case "TemplateConditional": return node.branches.some((b) => b.body.some(hasElementPortal));
+		case "TemplateMatch": return node.branches.some((b) => b.body.some(hasElementPortal)) || node.hostElement !== void 0 && hasElementPortal(node.hostElement);
+		case "TemplateLoop": return node.body.some(hasElementPortal);
+		case "TemplateSlotInvocation": return node.fallback.some(hasElementPortal);
+		default: return false;
+	}
+}
 function emitLit(ir, opts = {}) {
 	const litImports = new LitImportCollector();
 	const decoratorImports = new LitDecoratorImportCollector();
@@ -96153,7 +97314,8 @@ function emitLit(ir, opts = {}) {
 		componentName: ir.name,
 		lit: litImports,
 		runtime: runtimeImports,
-		scopeHash
+		scopeHash,
+		hasElementPortal: hasElementPortal(ir.template)
 	});
 	diagnostics.push(...styleResult.diagnostics);
 	const scriptResult = emitScript(ir, {
@@ -96241,6 +97403,7 @@ function emitLit(ir, opts = {}) {
 		debouncedFieldDecls: templateResult.debouncedFieldDecls.join("\n"),
 		hoistedLiteralFieldDecls: templateResult.hoistedLiteralFieldDecls.join("\n"),
 		keynavFieldDecls: templateResult.keynavFieldDecls.join("\n"),
+		portalFieldDecls: templateResult.portalFieldDecls.join("\n"),
 		slotFillerClassFields: templateResult.slotFillerClassFields.map((f) => "  " + f).join("\n"),
 		slotFields: slotResult.fields,
 		cleanupField: "  private _disconnectCleanups: Array<() => void> = [];\n  // Re-parenting guard: set true once the deferred teardown has actually\n  // run (a genuine un-mount), so a subsequent reconnect knows to re-arm.\n  private _rozieTornDown = false;",
@@ -96317,6 +97480,7 @@ function composeClassBody(parts) {
 	if (parts.debouncedFieldDecls.trim().length > 0) sections.push(parts.debouncedFieldDecls);
 	if (parts.hoistedLiteralFieldDecls.trim().length > 0) sections.push(parts.hoistedLiteralFieldDecls);
 	if (parts.keynavFieldDecls.trim().length > 0) sections.push(parts.keynavFieldDecls);
+	if (parts.portalFieldDecls.trim().length > 0) sections.push(parts.portalFieldDecls);
 	if (parts.slotFillerClassFields.trim().length > 0) sections.push(parts.slotFillerClassFields);
 	if (parts.slotFields.trim().length > 0) sections.push(parts.slotFields);
 	sections.push(parts.cleanupField);
@@ -96400,7 +97564,8 @@ function buildComponentImportsBlock(components, selfName) {
 	const lines = [];
 	for (const decl of components) {
 		if (decl.localName === selfName) continue;
-		lines.push(`import '${decl.importPath}';`);
+		const importPath = isPublishedSpecifier(decl.importPath) ? rewriteRozieImport(decl.importPath, "lit") : decl.importPath;
+		lines.push(`import '${importPath}';`);
 	}
 	if (lines.length === 0) return void 0;
 	return lines.join("\n") + "\n";
@@ -96515,9 +97680,9 @@ function compile(source, opts) {
 	});
 	const acc = [...parseDiags, ...irDiags];
 	if (!ir) return guardEmpty(fail(acc));
-	threadParamTypes(ir, filename ?? "<anonymous>", cache, resolver, acc);
+	threadParamTypes(ir, filename ?? "<anonymous>", cache, resolver, opts.target, acc);
 	validatePortalScopedStyle(ir, acc);
-	validateTwoWayBindings(ir, filename ?? "<anonymous>", cache, resolver, acc);
+	validateTwoWayBindings(ir, filename ?? "<anonymous>", cache, resolver, opts.target, acc);
 	stampMissingFilename(acc, filename);
 	if (acc.some((d) => d.severity === "error")) return fail(acc);
 	const emitOpts = {