@c9up/aurora 0.1.36 → 0.1.38

package/dist/AuroraProvider.js

@@ -20,10 +20,12 @@ import { isAbsolute, resolve as resolvePath } from "node:path";
 import { fileURLToPath } from "node:url";
 import { AuroraManager } from "./AuroraManager.js";
 import { auroraRoute } from "./route.js";
-import { setAurora } from "./services/main.js";
+import { clearAurora, getAurora, setAurora } from "./services/main.js";
 import { renderToString } from "./ssr.js";
 export default class AuroraProvider {
     app;
+    /** What this provider bound, so shutdown only clears its own. */
+    #owned;
     constructor(app) {
         this.app = app;
     }
@@ -46,6 +48,7 @@ export default class AuroraProvider {
         // Force-resolve so `setAurora` runs even if the app never
         // touches the singleton from a preload.
         const manager = await this.app.container.resolve(AuroraManager);
+        this.#owned = manager;
         setAurora(manager);
     }
     async start() {
@@ -77,7 +80,15 @@ export default class AuroraProvider {
         }
     }
     async ready() { }
-    async shutdown() { }
+    async shutdown() {
+        // Release the module-level singleton, while it is still ours. A stopped
+        // application left a dead Aurora manager reachable through `services/main`, and
+        // with two applications in one process the survivor's binding must not
+        // be the one cleared.
+        if (this.#owned !== undefined && getAurora() === this.#owned)
+            clearAurora();
+        this.#owned = undefined;
+    }
     /**
      * Resolve the user-supplied config:
      *   - relative `pages.root` (e.g. `./resources/pages`) is joined to

package/dist/augmentations.d.ts

@@ -15,9 +15,29 @@
  * simply inert.
  */
 import type { AuroraManager } from "./AuroraManager.js";
+import type { AuroraRequestRenderer } from "./middleware.js";
 declare module "@c9up/ream/types" {
     interface ContainerBindings {
         /** The Aurora manager, bound by `AuroraProvider`. */
         aurora: AuroraManager;
     }
 }
+declare module "@c9up/ream" {
+    interface HttpContext {
+        /**
+         * Render a page for THIS request — `ctx.aurora.render(name, props)`.
+         *
+         * Attached by the `auroraContext` middleware, which is what the docs tell
+         * an application to register. Without this declaration the property the
+         * middleware sets did not exist as far as the compiler was concerned, so
+         * the shorthand the documentation teaches did not typecheck, and a
+         * controller had to reach for the module-level `aurora.render(ctx, ...)`
+         * or assert its way past it.
+         *
+         * Optional, because the middleware is: an application that never
+         * registers it has no `ctx.aurora`, and saying otherwise would let a
+         * controller call something that is not there.
+         */
+        aurora?: AuroraRequestRenderer;
+    }
+}

package/dist/html.js

@@ -216,11 +216,90 @@ function collectSlots(root, classification) {
     visit(root.content, []);
     return slots;
 }
+/**
+ * Elements that only ever exist inside `<svg>`.
+ *
+ * Names shared with HTML — `a`, `title`, `style`, `script`, `text` in some
+ * dialects — are deliberately absent: seeing one says nothing about which
+ * namespace was meant, and guessing wrong would move an ordinary anchor into
+ * SVG.
+ */
+const SVG_ONLY = new Set([
+    "animate",
+    "animatemotion",
+    "animatetransform",
+    "circle",
+    "clippath",
+    "defs",
+    "desc",
+    "ellipse",
+    "feblend",
+    "fecolormatrix",
+    "fegaussianblur",
+    "femerge",
+    "feoffset",
+    "filter",
+    "foreignobject",
+    "g",
+    "image",
+    "line",
+    "lineargradient",
+    "marker",
+    "mask",
+    "path",
+    "pattern",
+    "polygon",
+    "polyline",
+    "radialgradient",
+    "rect",
+    "stop",
+    "svg",
+    "symbol",
+    "tspan",
+    "use",
+]);
+/**
+ * Whether this markup is SVG content that lost its `<svg>` ancestor.
+ *
+ * A template compiled on its own — `html\`<path/><path/>\``, the body of an
+ * icon helper — is parsed with no parent, and the HTML parser has no
+ * self-closing tag for an unknown element: the second `<path>` becomes a CHILD
+ * of the first, in the XHTML namespace. Nothing throws and nothing is logged;
+ * the icon is simply invisible, because `<path>` in the wrong namespace paints
+ * nothing. Parsing the same markup inside an `<svg>` makes the parser apply
+ * foreign-content rules and produce the two siblings that were written.
+ *
+ * `<svg>` itself is excluded: the parser already handles it when it is the root
+ * of the markup, and wrapping one in another would nest them.
+ */
+function isOrphanedSvgContent(root) {
+    const elements = Array.from(root.content.childNodes).filter((node) => node.nodeType === 1);
+    if (elements.length === 0)
+        return false;
+    return elements.every((el) => {
+        const name = el.localName.toLowerCase();
+        return name !== "svg" && SVG_ONLY.has(name);
+    });
+}
 function compile(strings) {
     const classification = classifySlots(strings);
     const markup = buildMarkup(strings, classification);
-    const tpl = document.createElement("template");
+    let tpl = document.createElement("template");
     tpl.innerHTML = markup;
+    if (isOrphanedSvgContent(tpl)) {
+        // Re-parsed with the ancestor the markup was written for, then lifted
+        // back out: the nodes keep the SVG namespace they were given, and the
+        // slot paths below are collected against the shape that will actually
+        // be cloned.
+        const wrapper = document.createElement("template");
+        wrapper.innerHTML = `<svg>${markup}</svg>`;
+        const svg = wrapper.content.firstElementChild;
+        if (svg !== null) {
+            tpl = document.createElement("template");
+            while (svg.firstChild)
+                tpl.content.appendChild(svg.firstChild);
+        }
+    }
     const slots = collectSlots(tpl, classification);
     return { element: tpl, slots };
 }

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-import "./augmentations.js";
 export type { CookieCodec, CookieOptions, PersistedSignalOptions, ShareData, StorageArea, WebStorageOptions, WindowSize, } from "./browser.js";
 export { back, booleanCookie, clipboard, cookie, cookieSignal, cookieState, forward, getCookieStore, hash, jsonCookie, mediaQuery, navigate, online, persistedSignal, prefersDark, queryParam, redirect, reload, replace, session, setCookieStore, share, storage, visibility, WebStorage, windowSize, } from "./browser.js";
 export { type ClassValue, clsx, cn, twMerge } from "./cn.js";

package/dist/index.js

@@ -4,7 +4,15 @@
 // node:fs / node:path / node:url live in `@c9up/aurora/server`. Keeping them off
 // this barrel is what lets a browser bundle import the client primitives without
 // the bundler dragging Node built-ins through the import graph.
-import "./augmentations.js";
+//
+// `./augmentations.js` is NOT loaded here either, and for a related reason: it
+// augments ream's HttpContext and ContainerBindings, so it names `@c9up/ream`
+// and drags ream's whole source into any program that imports this barrel. A
+// component library that only wants `component`/`html` was compiling ream's
+// decorated console commands under its own tsconfig, which does not enable
+// decorators — a build failure, in a package that never mentions ream. The
+// augmentations load from `@c9up/aurora/server` and `@c9up/aurora/provider`,
+// which is where every type they describe is reachable from anyway.
 export { back, booleanCookie, clipboard, cookie, cookieSignal, cookieState, forward, getCookieStore, hash, jsonCookie, mediaQuery, navigate, online, persistedSignal, prefersDark, queryParam, redirect, reload, replace, session, setCookieStore, share, storage, visibility, WebStorage, windowSize, } from "./browser.js";
 export { clsx, cn, twMerge } from "./cn.js";
 export { command } from "./command.js";

package/dist/server.d.ts

@@ -1,3 +1,4 @@
+import "./augmentations.js";
 export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
 export { type AuroraRequestRenderer, auroraContext, } from "./middleware.js";
 export { type PageFactory, Pages, type PagesConfig } from "./Pages.js";

package/dist/server.js

@@ -4,6 +4,12 @@
 // importing client primitives (component/html/hydrate/render) never pulls the
 // Node built-ins through the import graph. Server code imports from
 // `@c9up/aurora/server`; the client `.` entry stays node-free.
+//
+// The ream augmentations (`ctx.aurora`, the `aurora` container binding) load
+// here rather than from the client barrel: everything they describe is
+// server-side, and naming `@c9up/ream` from the browser entry pulled ream's
+// source into every consumer's program — including ones that never use it.
+import "./augmentations.js";
 export { AuroraManager } from "./AuroraManager.js";
 export { auroraContext, } from "./middleware.js";
 export { Pages } from "./Pages.js";

package/dist/services/main.d.ts

@@ -14,5 +14,14 @@ import type { AuroraManager } from "../AuroraManager.js";
 export declare function setAurora(value: AuroraManager): void;
 /** @internal Read the singleton (or `undefined` pre-boot). */
 export declare function getAurora(): AuroraManager | undefined;
+/**
+ * @internal Release the singleton, so a shut-down application does not leave a
+ * dead Aurora manager reachable through `services/main`.
+ *
+ * The caller checks ownership first (`getAurora() === mine`): two applications
+ * share this module in one process, and the one shutting down must not clear
+ * what the other has since bound.
+ */
+export declare function clearAurora(): void;
 declare const aurora: AuroraManager;
 export default aurora;

package/dist/services/main.js

@@ -18,6 +18,17 @@ export function setAurora(value) {
 export function getAurora() {
     return instance;
 }
+/**
+ * @internal Release the singleton, so a shut-down application does not leave a
+ * dead Aurora manager reachable through `services/main`.
+ *
+ * The caller checks ownership first (`getAurora() === mine`): two applications
+ * share this module in one process, and the one shutting down must not clear
+ * what the other has since bound.
+ */
+export function clearAurora() {
+    instance = undefined;
+}
 const aurora = new Proxy({}, {
     get(_target, prop) {
         // A module loader inspects what it imports before anyone uses it: it reads

package/dist/ssr.js

@@ -64,15 +64,37 @@ function stringifyTemplateResult(result) {
         // value written into the HTML, and any exception swallowed.
         const directiveMatch = segment.match(/\s([@?.][\w-]+)=("|'|)$/);
         const skipValue = directiveMatch !== null;
+        // Set when the skipped directive is a boolean attribute, which — unlike
+        // the other two — still has markup to emit. See below.
+        let booleanAttrName;
         if (directiveMatch) {
-            const [whole = "", , quote] = directiveMatch;
+            const [whole = "", directive = "", quote] = directiveMatch;
             segment = segment.slice(0, segment.length - whole.length);
+            // `?disabled=${x}` is HTML STATE, not a client-only binding.
+            // `@click` is a listener and `.value` a DOM property: neither
+            // exists until the runtime binds it, so dropping them is right.
+            // A boolean attribute is different — the browser acts on it while
+            // parsing. Skipping it too made the server contradict the very
+            // first client render: a `?hidden` panel arrived visible and
+            // blinked away once hydration caught up.
+            if (directive.startsWith("?"))
+                booleanAttrName = directive.slice(1);
             // Only a quoted directive leaves a closing quote to swallow.
             pendingClosingQuote =
                 quote === '"' ? '"' : quote === "'" ? "'" : undefined;
         }
         out += segment;
         scanner.consume(segment);
+        if (booleanAttrName !== undefined && i < values.length) {
+            // Present-and-empty when truthy, absent otherwise — byte-for-byte
+            // what applyBooleanAttrSlot writes on the client, so hydration
+            // re-applying the effect is a no-op instead of a correction.
+            if (resolveBooleanValue(values[i])) {
+                const rendered = ` ${booleanAttrName}=""`;
+                out += rendered;
+                scanner.consume(rendered);
+            }
+        }
         if (i < values.length && !skipValue) {
             const value = values[i];
             const inAttr = scanner.insideTag;
@@ -151,6 +173,26 @@ class TagScanner {
         return this.#inTag;
     }
 }
+/**
+ * Read a boolean attribute's value the way the client reads it: a signal or a
+ * reactive expression is called ONCE, then coerced. One level is not an
+ * approximation — `applyBooleanAttrSlot` does exactly the same, so a signal
+ * that returns a signal is truthy on both sides.
+ */
+function resolveBooleanValue(value) {
+    if (isSignal(value) || typeof value === "function") {
+        try {
+            return Boolean(value());
+        }
+        catch {
+            // Same fail-soft as stringifyValue: an expression that throws
+            // server-side leaves the attribute off and lets the client effect
+            // decide once it has a real DOM to read.
+            return false;
+        }
+    }
+    return Boolean(value);
+}
 function stringifyValue(value, inAttribute) {
     if (value === null || value === undefined || value === false)
         return "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c9up/aurora",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "Aurora — reactive UI runtime for the Ream framework. Tagged-template DOM, signal-based state, isomorphic SSR + hydration, zero build step.",
   "license": "MIT",
   "type": "module",
@@ -58,6 +58,7 @@
     "@types/node": "^22.19.15",
     "@vitest/browser": "4.1.11",
     "@vitest/browser-playwright": "4.1.11",
+    "@vitest/coverage-v8": "4.1.9",
     "jsdom": "^30.0.1",
     "playwright": "^1.61.1",
     "typescript": "^6.0.2",
@@ -81,7 +82,7 @@
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
-    "lint": "biome check src/",
+    "lint": "biome check src/ tests/",
     "test:coverage": "vitest run --coverage",
     "test:browser": "vitest run -c vitest.browser.config.ts"
   }

package/src/AuroraProvider.ts

@@ -26,7 +26,7 @@ import type {
 	AssetsRequest,
 	AssetsResponse,
 } from "./server/serveAssets.js";
-import { setAurora } from "./services/main.js";
+import { clearAurora, getAurora, setAurora } from "./services/main.js";
 import { renderToString } from "./ssr.js";
 
 interface AuroraContainer {
@@ -50,6 +50,9 @@ interface ReamRouter {
 }
 
 export default class AuroraProvider {
+	/** What this provider bound, so shutdown only clears its own. */
+	#owned: AuroraManager | undefined;
+
 	constructor(protected app: AuroraAppContext) {}
 
 	register(): void {
@@ -75,6 +78,7 @@ export default class AuroraProvider {
 		// touches the singleton from a preload.
 		const manager =
 			await this.app.container.resolve<AuroraManager>(AuroraManager);
+		this.#owned = manager;
 		setAurora(manager);
 	}
 
@@ -114,7 +118,14 @@ export default class AuroraProvider {
 	}
 
 	async ready(): Promise<void> {}
-	async shutdown(): Promise<void> {}
+	async shutdown(): Promise<void> {
+		// Release the module-level singleton, while it is still ours. A stopped
+		// application left a dead Aurora manager reachable through `services/main`, and
+		// with two applications in one process the survivor's binding must not
+		// be the one cleared.
+		if (this.#owned !== undefined && getAurora() === this.#owned) clearAurora();
+		this.#owned = undefined;
+	}
 
 	/**
 	 * Resolve the user-supplied config:

package/src/augmentations.ts

@@ -15,10 +15,12 @@
  * simply inert.
  */
 
-// Referenced so the augmentation below resolves the module it augments.
+// Referenced so the augmentations below resolve the modules they augment.
+import type {} from "@c9up/ream";
 import type {} from "@c9up/ream/types";
 
 import type { AuroraManager } from "./AuroraManager.js";
+import type { AuroraRequestRenderer } from "./middleware.js";
 
 declare module "@c9up/ream/types" {
 	interface ContainerBindings {
@@ -26,3 +28,23 @@ declare module "@c9up/ream/types" {
 		aurora: AuroraManager;
 	}
 }
+
+declare module "@c9up/ream" {
+	interface HttpContext {
+		/**
+		 * Render a page for THIS request — `ctx.aurora.render(name, props)`.
+		 *
+		 * Attached by the `auroraContext` middleware, which is what the docs tell
+		 * an application to register. Without this declaration the property the
+		 * middleware sets did not exist as far as the compiler was concerned, so
+		 * the shorthand the documentation teaches did not typecheck, and a
+		 * controller had to reach for the module-level `aurora.render(ctx, ...)`
+		 * or assert its way past it.
+		 *
+		 * Optional, because the middleware is: an application that never
+		 * registers it has no `ctx.aurora`, and saying otherwise would let a
+		 * controller call something that is not there.
+		 */
+		aurora?: AuroraRequestRenderer;
+	}
+}

package/src/html.ts

@@ -259,11 +259,94 @@ function collectSlots(
 	return slots;
 }
 
+/**
+ * Elements that only ever exist inside `<svg>`.
+ *
+ * Names shared with HTML — `a`, `title`, `style`, `script`, `text` in some
+ * dialects — are deliberately absent: seeing one says nothing about which
+ * namespace was meant, and guessing wrong would move an ordinary anchor into
+ * SVG.
+ */
+const SVG_ONLY = new Set([
+	"animate",
+	"animatemotion",
+	"animatetransform",
+	"circle",
+	"clippath",
+	"defs",
+	"desc",
+	"ellipse",
+	"feblend",
+	"fecolormatrix",
+	"fegaussianblur",
+	"femerge",
+	"feoffset",
+	"filter",
+	"foreignobject",
+	"g",
+	"image",
+	"line",
+	"lineargradient",
+	"marker",
+	"mask",
+	"path",
+	"pattern",
+	"polygon",
+	"polyline",
+	"radialgradient",
+	"rect",
+	"stop",
+	"svg",
+	"symbol",
+	"tspan",
+	"use",
+]);
+
+/**
+ * Whether this markup is SVG content that lost its `<svg>` ancestor.
+ *
+ * A template compiled on its own — `html\`<path/><path/>\``, the body of an
+ * icon helper — is parsed with no parent, and the HTML parser has no
+ * self-closing tag for an unknown element: the second `<path>` becomes a CHILD
+ * of the first, in the XHTML namespace. Nothing throws and nothing is logged;
+ * the icon is simply invisible, because `<path>` in the wrong namespace paints
+ * nothing. Parsing the same markup inside an `<svg>` makes the parser apply
+ * foreign-content rules and produce the two siblings that were written.
+ *
+ * `<svg>` itself is excluded: the parser already handles it when it is the root
+ * of the markup, and wrapping one in another would nest them.
+ */
+function isOrphanedSvgContent(root: HTMLTemplateElement): boolean {
+	const elements = Array.from(root.content.childNodes).filter(
+		(node): node is Element => node.nodeType === 1,
+	);
+	if (elements.length === 0) return false;
+	return elements.every((el) => {
+		const name = el.localName.toLowerCase();
+		return name !== "svg" && SVG_ONLY.has(name);
+	});
+}
+
 function compile(strings: TemplateStringsArray): Template {
 	const classification = classifySlots(strings);
 	const markup = buildMarkup(strings, classification);
-	const tpl = document.createElement("template");
+	let tpl = document.createElement("template");
 	tpl.innerHTML = markup;
+
+	if (isOrphanedSvgContent(tpl)) {
+		// Re-parsed with the ancestor the markup was written for, then lifted
+		// back out: the nodes keep the SVG namespace they were given, and the
+		// slot paths below are collected against the shape that will actually
+		// be cloned.
+		const wrapper = document.createElement("template");
+		wrapper.innerHTML = `<svg>${markup}</svg>`;
+		const svg = wrapper.content.firstElementChild;
+		if (svg !== null) {
+			tpl = document.createElement("template");
+			while (svg.firstChild) tpl.content.appendChild(svg.firstChild);
+		}
+	}
+
 	const slots = collectSlots(tpl, classification);
 	return { element: tpl, slots };
 }

package/src/index.ts

@@ -4,7 +4,15 @@
 // node:fs / node:path / node:url live in `@c9up/aurora/server`. Keeping them off
 // this barrel is what lets a browser bundle import the client primitives without
 // the bundler dragging Node built-ins through the import graph.
-import "./augmentations.js";
+//
+// `./augmentations.js` is NOT loaded here either, and for a related reason: it
+// augments ream's HttpContext and ContainerBindings, so it names `@c9up/ream`
+// and drags ream's whole source into any program that imports this barrel. A
+// component library that only wants `component`/`html` was compiling ream's
+// decorated console commands under its own tsconfig, which does not enable
+// decorators — a build failure, in a package that never mentions ream. The
+// augmentations load from `@c9up/aurora/server` and `@c9up/aurora/provider`,
+// which is where every type they describe is reachable from anyway.
 
 export type {
 	CookieCodec,

package/src/server.ts

@@ -4,6 +4,12 @@
 // importing client primitives (component/html/hydrate/render) never pulls the
 // Node built-ins through the import graph. Server code imports from
 // `@c9up/aurora/server`; the client `.` entry stays node-free.
+//
+// The ream augmentations (`ctx.aurora`, the `aurora` container binding) load
+// here rather than from the client barrel: everything they describe is
+// server-side, and naming `@c9up/ream` from the browser entry pulled ream's
+// source into every consumer's program — including ones that never use it.
+import "./augmentations.js";
 
 export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
 export {

package/src/services/main.ts

@@ -24,6 +24,18 @@ export function getAurora(): AuroraManager | undefined {
 	return instance;
 }
 
+/**
+ * @internal Release the singleton, so a shut-down application does not leave a
+ * dead Aurora manager reachable through `services/main`.
+ *
+ * The caller checks ownership first (`getAurora() === mine`): two applications
+ * share this module in one process, and the one shutting down must not clear
+ * what the other has since bound.
+ */
+export function clearAurora(): void {
+	instance = undefined;
+}
+
 const aurora: AuroraManager = new Proxy({} as AuroraManager, {
 	get(_target, prop) {
 		// A module loader inspects what it imports before anyone uses it: it reads

package/src/ssr.ts

@@ -68,15 +68,36 @@ function stringifyTemplateResult(result: TemplateResult): string {
 		// value written into the HTML, and any exception swallowed.
 		const directiveMatch = segment.match(/\s([@?.][\w-]+)=("|'|)$/);
 		const skipValue = directiveMatch !== null;
+		// Set when the skipped directive is a boolean attribute, which — unlike
+		// the other two — still has markup to emit. See below.
+		let booleanAttrName: string | undefined;
 		if (directiveMatch) {
-			const [whole = "", , quote] = directiveMatch;
+			const [whole = "", directive = "", quote] = directiveMatch;
 			segment = segment.slice(0, segment.length - whole.length);
+			// `?disabled=${x}` is HTML STATE, not a client-only binding.
+			// `@click` is a listener and `.value` a DOM property: neither
+			// exists until the runtime binds it, so dropping them is right.
+			// A boolean attribute is different — the browser acts on it while
+			// parsing. Skipping it too made the server contradict the very
+			// first client render: a `?hidden` panel arrived visible and
+			// blinked away once hydration caught up.
+			if (directive.startsWith("?")) booleanAttrName = directive.slice(1);
 			// Only a quoted directive leaves a closing quote to swallow.
 			pendingClosingQuote =
 				quote === '"' ? '"' : quote === "'" ? "'" : undefined;
 		}
 		out += segment;
 		scanner.consume(segment);
+		if (booleanAttrName !== undefined && i < values.length) {
+			// Present-and-empty when truthy, absent otherwise — byte-for-byte
+			// what applyBooleanAttrSlot writes on the client, so hydration
+			// re-applying the effect is a no-op instead of a correction.
+			if (resolveBooleanValue(values[i])) {
+				const rendered = ` ${booleanAttrName}=""`;
+				out += rendered;
+				scanner.consume(rendered);
+			}
+		}
 		if (i < values.length && !skipValue) {
 			const value = values[i];
 			const inAttr = scanner.insideTag;
@@ -155,6 +176,26 @@ class TagScanner {
 	}
 }
 
+/**
+ * Read a boolean attribute's value the way the client reads it: a signal or a
+ * reactive expression is called ONCE, then coerced. One level is not an
+ * approximation — `applyBooleanAttrSlot` does exactly the same, so a signal
+ * that returns a signal is truthy on both sides.
+ */
+function resolveBooleanValue(value: unknown): boolean {
+	if (isSignal(value) || typeof value === "function") {
+		try {
+			return Boolean((value as () => unknown)());
+		} catch {
+			// Same fail-soft as stringifyValue: an expression that throws
+			// server-side leaves the attribute off and lets the client effect
+			// decide once it has a real DOM to read.
+			return false;
+		}
+	}
+	return Boolean(value);
+}
+
 function stringifyValue(value: unknown, inAttribute: boolean): string {
 	if (value === null || value === undefined || value === false) return "";
 	if (value === true) return inAttribute ? "" : "true";