@vertz/ui-server 0.2.47 → 0.2.52

package/dist/bun-dev-server.d.ts

@@ -1,3 +1,32 @@
+interface QuerySnapshot {
+	data: SerializedValue;
+	loading: boolean;
+	revalidating: boolean;
+	error: SerializedValue;
+	idle: boolean;
+	key?: string;
+}
+interface InstanceSnapshot {
+	index: number;
+	key?: string;
+	signals: Record<string, SerializedValue>;
+	queries: Record<string, QuerySnapshot>;
+}
+interface ComponentSnapshot {
+	name: string;
+	moduleId: string;
+	instanceCount: number;
+	instances: InstanceSnapshot[];
+}
+interface StateSnapshot {
+	components: ComponentSnapshot[];
+	totalInstances: number;
+	connectedClients: number;
+	timestamp: string;
+	message?: string;
+	truncated?: boolean;
+}
+type SerializedValue = string | number | boolean | null | object;
 import { AccessSet } from "@vertz/ui/auth";
 interface SessionData {
 	user: {
@@ -198,6 +227,12 @@ interface BunDevServer {
 	clearErrorForFileChange(): void;
 	/** Set the last changed file path (for testing). */
 	setLastChangedFile(file: string): void;
+	/**
+	* Request a state inspection from connected browser clients.
+	* Broadcasts an `inspect-state` command and waits for the first
+	* `state-snapshot` response. Returns the snapshot JSON or an error.
+	*/
+	inspectState(filter?: string): Promise<StateSnapshot>;
 }
 interface HMRAssets {
 	/** Discovered `/_bun/client/<hash>.js` URL, or null if not found */

package/dist/bun-dev-server.js

@@ -2060,11 +2060,50 @@ class SSRElement extends SSRNode {
   set name(value) {
     this.attrs.name = value;
   }
+  _selectValue;
   get value() {
+    if (this.tag === "select") {
+      return this._selectValue ?? "";
+    }
     return this.attrs.value ?? "";
   }
   set value(value) {
-    this.attrs.value = value;
+    if (this.tag === "select") {
+      this._selectValue = value;
+      this._applySelectValue();
+    } else {
+      this.attrs.value = value;
+    }
+  }
+  _applySelectValue() {
+    if (this._selectValue === undefined)
+      return;
+    this._applySelectValueToChildren(this.children);
+  }
+  _applySelectValueToChildren(children) {
+    for (const child of children) {
+      if (child instanceof SSRElement) {
+        if (child.tag === "option") {
+          const optValue = child.attrs.value ?? this._getChildTextContent(child);
+          if (optValue === this._selectValue) {
+            child.attrs.selected = "";
+          } else {
+            delete child.attrs.selected;
+          }
+        } else if (child.tag === "optgroup") {
+          this._applySelectValueToChildren(child.children);
+        }
+      }
+    }
+  }
+  _getChildTextContent(el) {
+    return el.children.map((c) => {
+      if (typeof c === "string")
+        return c;
+      if (c instanceof SSRElement)
+        return this._getChildTextContent(c);
+      return "";
+    }).join("");
   }
   get src() {
     return this.attrs.src ?? "";
@@ -2135,9 +2174,14 @@ class SSRElement extends SSRNode {
   addEventListener(_event, _handler) {}
   removeEventListener(_event, _handler) {}
   toVNode() {
+    let attrs = { ...this.attrs };
+    if (this.tag === "select") {
+      this._applySelectValue();
+      delete attrs.value;
+    }
     return {
       tag: this.tag,
-      attrs: { ...this.attrs },
+      attrs,
       children: this.children.map((child) => {
         if (typeof child === "string") {
           return this._innerHTML != null ? rawHtml(child) : child;
@@ -3632,6 +3676,7 @@ function createBunDevServer(options) {
   let ssrFallback = false;
   const wsClients = new Set;
   let currentError = null;
+  const pendingInspections = new Map;
   const sourceMapResolver = createSourceMapResolver(projectRoot);
   let clearGraceUntil = 0;
   let runtimeDebounceTimer = null;
@@ -4098,6 +4143,10 @@ function createBunDevServer(options) {
     const frInitPath = resolve(devDir, "fast-refresh-init.ts");
     writeFileSync3(frInitPath, `import '@vertz/ui-server/fast-refresh-runtime';
 if (import.meta.hot) import.meta.hot.accept();
+`);
+    const siInitPath = resolve(devDir, "state-inspector-init.ts");
+    writeFileSync3(siInitPath, `import '@vertz/ui-server/state-inspector';
+if (import.meta.hot) import.meta.hot.accept();
 `);
     const hmrShellHtml = `<!doctype html>
 <html lang="en"><head>
@@ -4105,6 +4154,7 @@ if (import.meta.hot) import.meta.hot.accept();
   <title>HMR Shell</title>
 </head><body>
   <script type="module" src="./fast-refresh-init.ts"></script>
+  <script type="module" src="./state-inspector-init.ts"></script>
   <script type="module" src="${clientSrc}"></script>
 </body></html>`;
     const hmrShellPath = resolve(devDir, "hmr-shell.html");
@@ -4431,6 +4481,13 @@ data: {}
               devServer.restart();
             } else if (data.type === "ping") {
               ws.sendText(JSON.stringify({ type: "pong" }));
+            } else if (data.type === "state-snapshot" && data.requestId) {
+              const pending = pendingInspections.get(data.requestId);
+              if (pending) {
+                clearTimeout(pending.timer);
+                pendingInspections.delete(data.requestId);
+                pending.resolve(data.snapshot);
+              }
             } else if (data.type === "resolve-stack" && data.stack) {
               const selfFetch = async (url) => {
                 const absUrl = url.startsWith("http") ? url : `http://${host}:${server?.port}${url}`;
@@ -4803,8 +4860,53 @@ data: {}
     setLastChangedFile(file) {
       lastChangedFile = file;
     },
+    async inspectState(filter) {
+      if (wsClients.size === 0) {
+        return {
+          components: [],
+          totalInstances: 0,
+          connectedClients: 0,
+          timestamp: new Date().toISOString(),
+          message: "No browser clients connected. Open the app in a browser first."
+        };
+      }
+      const requestId = crypto.randomUUID();
+      const TIMEOUT_MS = 5000;
+      return new Promise((resolve2) => {
+        const timer = setTimeout(() => {
+          pendingInspections.delete(requestId);
+          resolve2({
+            components: [],
+            totalInstances: 0,
+            connectedClients: wsClients.size,
+            timestamp: new Date().toISOString(),
+            message: "State inspection timed out after 5 seconds."
+          });
+        }, TIMEOUT_MS);
+        pendingInspections.set(requestId, { resolve: resolve2, timer });
+        const cmd = JSON.stringify({
+          type: "inspect-state",
+          requestId,
+          ...filter ? { filter } : {}
+        });
+        for (const client of wsClients) {
+          client.sendText(cmd);
+        }
+      });
+    },
     async stop() {
       stopped = true;
+      for (const [, { resolve: res, timer }] of pendingInspections) {
+        clearTimeout(timer);
+        res({
+          components: [],
+          totalInstances: 0,
+          connectedClients: 0,
+          timestamp: new Date().toISOString(),
+          message: "Server stopped."
+        });
+      }
+      pendingInspections.clear();
       if (refreshTimeout) {
         clearTimeout(refreshTimeout);
         refreshTimeout = null;

package/dist/bun-plugin/state-inspector.d.ts

@@ -0,0 +1,59 @@
+interface QuerySnapshot {
+	data: SerializedValue;
+	loading: boolean;
+	revalidating: boolean;
+	error: SerializedValue;
+	idle: boolean;
+	key?: string;
+}
+interface InstanceSnapshot {
+	index: number;
+	key?: string;
+	signals: Record<string, SerializedValue>;
+	queries: Record<string, QuerySnapshot>;
+}
+interface ComponentSnapshot {
+	name: string;
+	moduleId: string;
+	instanceCount: number;
+	instances: InstanceSnapshot[];
+}
+interface StateSnapshot {
+	components: ComponentSnapshot[];
+	totalInstances: number;
+	connectedClients: number;
+	timestamp: string;
+	message?: string;
+	truncated?: boolean;
+}
+type SerializedValue = string | number | boolean | null | object;
+/**
+* Serialize any JavaScript value to a JSON-safe representation.
+* Handles functions, DOM nodes, circular references, Date, Map, Set,
+* Error, Promise, Symbol, WeakRef, ArrayBuffer, and depth limiting.
+*/
+declare function safeSerialize(value: unknown, maxDepth?: number, seen?: WeakSet<object>): SerializedValue;
+/**
+* Walk the Fast Refresh registry and collect a state snapshot.
+* Optionally filter by component function name (case-sensitive).
+*/
+declare function collectStateSnapshot(filter?: string): StateSnapshot;
+/**
+* Handle incoming `inspect-state` WebSocket messages.
+* Collects a state snapshot and sends it back with the matching requestId.
+*/
+declare function handleInspectMessage(event: MessageEvent, ws: WebSocket): void;
+/**
+* Set up the state inspector's WebSocket listener.
+*
+* Uses `addEventListener` instead of replacing `onmessage` to coexist with
+* the error overlay handler. Polls for `__vertz_overlay._ws` reference changes
+* so that reconnections (which create a new WebSocket instance) are re-hooked.
+*
+* NOTE: When multiple browser tabs are connected, the server broadcasts
+* inspect-state to all. The first response wins — other tabs' responses are
+* dropped. This is acceptable for v0.1.x; a future improvement could merge
+* responses from multiple tabs.
+*/
+declare function setupStateInspector(): void;
+export { setupStateInspector, safeSerialize, handleInspectMessage, collectStateSnapshot, StateSnapshot, QuerySnapshot, InstanceSnapshot, ComponentSnapshot };

package/dist/bun-plugin/state-inspector.js

@@ -0,0 +1,270 @@
+// @bun
+import"../shared/chunk-pshsm7ck.js";
+
+// src/bun-plugin/state-inspector.ts
+var REGISTRY_KEY = Symbol.for("vertz:fast-refresh:registry");
+var MAX_RESPONSE_SIZE = 2 * 1024 * 1024;
+var DEFAULT_MAX_DEPTH = 4;
+var QUERY_SIGNAL_NAMES = ["data", "loading", "revalidating", "error", "idle"];
+function safeSerialize(value, maxDepth = DEFAULT_MAX_DEPTH, seen = new WeakSet) {
+  if (value === null)
+    return null;
+  if (value === undefined)
+    return null;
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "number") {
+    if (Number.isNaN(value))
+      return "[NaN]";
+    if (!Number.isFinite(value))
+      return value > 0 ? "[Infinity]" : "[-Infinity]";
+    return value;
+  }
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value === "symbol") {
+    const desc = value.description;
+    return desc ? `[Symbol: ${desc}]` : "[Symbol]";
+  }
+  if (typeof value === "function") {
+    const name = value.name;
+    return name && name !== "anonymous" ? `[Function: ${name}]` : "[Function]";
+  }
+  const obj = value;
+  if (seen.has(obj))
+    return "[Circular]";
+  if (obj instanceof Date)
+    return obj.toISOString();
+  if (obj instanceof Error) {
+    return { name: obj.name, message: obj.message };
+  }
+  if (obj instanceof Promise)
+    return "[Promise]";
+  if (obj instanceof Map)
+    return `[Map: ${obj.size} entries]`;
+  if (obj instanceof Set)
+    return `[Set: ${obj.size} items]`;
+  if (obj instanceof WeakMap)
+    return "[WeakMap]";
+  if (obj instanceof WeakSet)
+    return "[WeakSet]";
+  if (typeof WeakRef !== "undefined" && obj instanceof WeakRef)
+    return "[WeakRef]";
+  if (obj instanceof ArrayBuffer)
+    return `[ArrayBuffer: ${obj.byteLength} bytes]`;
+  if (ArrayBuffer.isView(obj) && "byteLength" in obj) {
+    return `[ArrayBuffer: ${obj.byteLength} bytes]`;
+  }
+  if (typeof HTMLElement !== "undefined" && obj instanceof HTMLElement) {
+    return `[HTMLElement: ${obj.tagName}]`;
+  }
+  if (typeof Node !== "undefined" && obj instanceof Node) {
+    return `[Node: ${obj.nodeName}]`;
+  }
+  if (maxDepth <= 0) {
+    if (Array.isArray(obj))
+      return `[Array: ${obj.length} items]`;
+    return `[Object: ${Object.keys(obj).length} keys]`;
+  }
+  seen.add(obj);
+  if (Array.isArray(obj)) {
+    const result2 = obj.map((item) => safeSerialize(item, maxDepth - 1, seen));
+    seen.delete(obj);
+    return result2;
+  }
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    result[key] = safeSerialize(obj[key], maxDepth - 1, seen);
+  }
+  seen.delete(obj);
+  return result;
+}
+function peekSafe(sig) {
+  try {
+    return sig.peek();
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return `[Error: ${msg}]`;
+  }
+}
+function collectStateSnapshot(filter) {
+  const registry = globalThis[REGISTRY_KEY];
+  if (!registry || registry.size === 0) {
+    return emptySnapshot(filter ? `${filter} is not in the component registry. Check the name spelling or ensure the file has been loaded.` : undefined);
+  }
+  const components = [];
+  let totalInstances = 0;
+  let foundInRegistry = false;
+  for (const [moduleId, moduleMap] of registry) {
+    for (const [name, record] of moduleMap) {
+      if (filter && name !== filter)
+        continue;
+      if (filter)
+        foundInRegistry = true;
+      const instances = [];
+      for (let i = 0;i < record.instances.length; i++) {
+        const inst = record.instances[i];
+        if (!inst.element?.isConnected)
+          continue;
+        const signals = {};
+        const queries = {};
+        const queryGroups = new Map;
+        const standaloneSignals = [];
+        for (const sig of inst.signals) {
+          const group = sig._queryGroup;
+          if (group) {
+            if (!queryGroups.has(group))
+              queryGroups.set(group, []);
+            queryGroups.get(group).push(sig);
+          } else {
+            standaloneSignals.push(sig);
+          }
+        }
+        let positionalIdx = 0;
+        for (const sig of standaloneSignals) {
+          const key = sig._hmrKey ?? `signal_${positionalIdx++}`;
+          signals[key] = safeSerialize(peekSafe(sig));
+        }
+        for (const [groupKey, groupSignals] of queryGroups) {
+          queries[groupKey] = buildQuerySnapshot(groupSignals, groupKey);
+        }
+        instances.push({ index: i, signals, queries });
+        totalInstances++;
+      }
+      if (instances.length > 0) {
+        components.push({ name, moduleId, instanceCount: instances.length, instances });
+      } else if (filter && foundInRegistry) {}
+    }
+  }
+  let message;
+  if (filter && components.length === 0) {
+    if (foundInRegistry) {
+      let moduleId = "";
+      for (const [mid, moduleMap] of registry) {
+        if (moduleMap.has(filter)) {
+          moduleId = mid;
+          break;
+        }
+      }
+      message = `${filter} is registered (in ${moduleId}) but has 0 mounted instances on the current page. Navigate to a page that renders it.`;
+    } else {
+      message = `${filter} is not in the component registry. Check the name spelling or ensure the file has been loaded.`;
+    }
+  }
+  const snapshot = {
+    components,
+    totalInstances,
+    connectedClients: 0,
+    timestamp: new Date().toISOString(),
+    ...message ? { message } : {}
+  };
+  const jsonStr = JSON.stringify(snapshot);
+  if (jsonStr.length > MAX_RESPONSE_SIZE) {
+    return truncateSnapshot(snapshot);
+  }
+  return snapshot;
+}
+function emptySnapshot(message) {
+  return {
+    components: [],
+    totalInstances: 0,
+    connectedClients: 0,
+    timestamp: new Date().toISOString(),
+    ...message ? { message } : {}
+  };
+}
+function buildQuerySnapshot(signals, groupKey) {
+  const named = new Map;
+  const unnamed = [];
+  for (const sig of signals) {
+    const val = peekSafe(sig);
+    if (sig._hmrKey && QUERY_SIGNAL_NAMES.includes(sig._hmrKey)) {
+      named.set(sig._hmrKey, val);
+    } else {
+      unnamed.push(val);
+    }
+  }
+  return {
+    data: safeSerialize(named.get("data") ?? unnamed[0] ?? null),
+    loading: Boolean(named.get("loading") ?? unnamed[1] ?? false),
+    revalidating: Boolean(named.get("revalidating") ?? unnamed[2] ?? false),
+    error: safeSerialize(named.get("error") ?? unnamed[3] ?? null),
+    idle: Boolean(named.get("idle") ?? unnamed[4] ?? false),
+    key: groupKey
+  };
+}
+function handleInspectMessage(event, ws) {
+  if (typeof event.data !== "string")
+    return;
+  try {
+    const msg = JSON.parse(event.data);
+    if (msg.type === "inspect-state") {
+      const snapshot = collectStateSnapshot(msg.filter ?? undefined);
+      ws.send(JSON.stringify({
+        type: "state-snapshot",
+        requestId: msg.requestId,
+        snapshot
+      }));
+    }
+  } catch {}
+}
+function setupStateInspector() {
+  if (typeof window === "undefined")
+    return;
+  let currentWs = null;
+  const MAX_INIT_RETRIES = 10;
+  let initRetries = 0;
+  function hookWs(ws) {
+    if (ws === currentWs)
+      return;
+    currentWs = ws;
+    ws.addEventListener("message", (event) => {
+      handleInspectMessage(event, ws);
+    });
+  }
+  function poll() {
+    const overlay = window.__vertz_overlay;
+    if (!overlay) {
+      if (initRetries++ < MAX_INIT_RETRIES) {
+        setTimeout(poll, 500);
+      }
+      return;
+    }
+    const checkWs = () => {
+      if (overlay._ws && overlay._ws !== currentWs) {
+        hookWs(overlay._ws);
+      }
+    };
+    checkWs();
+    setInterval(checkWs, 2000);
+  }
+  poll();
+}
+if (typeof document !== "undefined") {
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", setupStateInspector);
+  } else {
+    setupStateInspector();
+  }
+}
+function truncateSnapshot(snapshot) {
+  const truncated = {
+    ...snapshot,
+    truncated: true,
+    components: snapshot.components.map((comp) => ({
+      ...comp,
+      instances: comp.instances.slice(0, 3),
+      instanceCount: comp.instanceCount
+    }))
+  };
+  truncated.totalInstances = truncated.components.reduce((sum, c) => sum + c.instances.length, 0);
+  return truncated;
+}
+export {
+  setupStateInspector,
+  safeSerialize,
+  handleInspectMessage,
+  collectStateSnapshot
+};

package/dist/dom-shim/index.d.ts

@@ -113,8 +113,15 @@ declare class SSRElement extends SSRNode {
 	set type(value: string);
 	get name(): string;
 	set name(value: string);
+	/** Internal storage for select.value (not serialized as an attribute). */
+	private _selectValue;
 	get value(): string;
 	set value(value: string);
+	/** Walk <option> children and set/remove "selected" to match _selectValue. */
+	private _applySelectValue;
+	private _applySelectValueToChildren;
+	/** Get concatenated text content of an element's children. */
+	private _getChildTextContent;
 	get src(): string;
 	set src(value: string);
 	get alt(): string;

package/dist/dom-shim/index.js

@@ -7,7 +7,7 @@ import {
   installDomShim,
   removeDomShim,
   toVNode
-} from "../shared/chunk-szvdd1qq.js";
+} from "../shared/chunk-bp1ez7v4.js";
 import"../shared/chunk-bt1px3c4.js";
 export {
   toVNode,

package/dist/index.d.ts

@@ -536,6 +536,28 @@ interface SSRHandlerOptions {
 	* (JSON files, third-party APIs, custom DB clients).
 	*/
 	aotDataResolver?: AotDataResolver;
+	/**
+	* Derive attributes to set on the `<html>` tag from the incoming request.
+	*
+	* Useful for setting `data-theme`, `dir`, `lang`, or other attributes that
+	* must be on `<html>` to avoid FOUC. The callback runs before SSR rendering
+	* so the attributes are available in the first byte of the response.
+	*
+	* If the template already has an attribute with the same name, the callback's
+	* value overrides it. Values are HTML-escaped automatically. Keys must be
+	* valid HTML attribute names (`/^[a-zA-Z][a-zA-Z0-9-]*$/`).
+	*
+	* Return `undefined`, `null`, or `{}` to skip injection.
+	*
+	* @example
+	* ```ts
+	* htmlAttributes: (request) => ({
+	*   'data-theme': getThemeCookie(request) ?? 'dark',
+	*   dir: getDirection(request),
+	* })
+	* ```
+	*/
+	htmlAttributes?: (request: Request) => Record<string, string> | null | undefined;
 }
 declare function createSSRHandler(options: SSRHandlerOptions): (request: Request) => Promise<Response>;
 type NodeHandlerOptions = SSRHandlerOptions;
@@ -741,6 +763,8 @@ interface AotBarrelResult {
 	* Write each entry as `<tempDir>/<filename>.ts` alongside the barrel.
 	*/
 	files: Record<string, string>;
+	/** Function names skipped due to residual JSX in compiled output. */
+	skippedFns: string[];
 }
 /**
 * Generate a barrel module that re-exports __ssr_* functions from compiled files.

package/dist/index.js

@@ -1,10 +1,10 @@
 import {
   createSSRHandler,
   loadAotManifest
-} from "./shared/chunk-ck3n699k.js";
+} from "./shared/chunk-nstzxw4e.js";
 import {
   createNodeHandler
-} from "./shared/chunk-kzycr5v0.js";
+} from "./shared/chunk-x8r5mh0q.js";
 import {
   clearRouteCssCache,
   collectStreamChunks,
@@ -34,7 +34,7 @@ import {
   ssrStreamNavQueries,
   streamToString,
   toPrefetchSession
-} from "./shared/chunk-tm5aeq94.js";
+} from "./shared/chunk-c22cgv96.js";
 import {
   clearGlobalSSRTimeout,
   createSSRAdapter,
@@ -46,7 +46,7 @@ import {
   registerSSRQuery,
   setGlobalSSRTimeout,
   ssrStorage
-} from "./shared/chunk-szvdd1qq.js";
+} from "./shared/chunk-bp1ez7v4.js";
 import {
   __commonJS,
   __require,
@@ -171578,26 +171578,39 @@ function generateAotBarrel(compiledFiles, routeMap, appEntry) {
     "import { __esc, __esc_attr, __ssr_spread, __ssr_style_object } from '@vertz/ui-server';"
   ];
   const files = {};
+  const skippedFns = [];
   let fileIndex = 0;
   for (const [filePath, fns] of fileToFns) {
     const moduleName = basename(filePath, ".tsx").replace(/[^a-zA-Z0-9_-]/g, "_");
     const tempFileName = `__aot_${fileIndex}_${moduleName}`;
     const moduleRef = `./${tempFileName}.ts`;
-    lines.push(`export { ${fns.sort().join(", ")} } from '${moduleRef}';`);
     const compiled = compiledFiles[filePath];
     if (compiled) {
       const helperImport = `import { __esc, __esc_attr, __ssr_spread, __ssr_style_object } from '@vertz/ui-server';
 ` + `import type { SSRAotContext } from '@vertz/ui-server';
 `;
-      const extracted = extractSsrFunctions(compiled.code, fns);
-      files[`${tempFileName}.ts`] = helperImport + extracted;
+      const cleanFns = [];
+      for (const fn of fns) {
+        const fnCode = extractSsrFunctions(compiled.code, [fn]);
+        if (hasResidualJsx(fnCode)) {
+          skippedFns.push(fn);
+        } else {
+          cleanFns.push(fn);
+        }
+      }
+      if (cleanFns.length > 0) {
+        const extracted = extractSsrFunctions(compiled.code, cleanFns);
+        lines.push(`export { ${cleanFns.sort().join(", ")} } from '${moduleRef}';`);
+        files[`${tempFileName}.ts`] = helperImport + extracted;
+      }
     }
     fileIndex++;
   }
   return {
     barrelSource: lines.join(`
 `),
-    files
+    files,
+    skippedFns
   };
 }
 function extractSsrFunctions(code, fnNames) {
@@ -171624,6 +171637,9 @@ function extractSsrFunctions(code, fnNames) {
   return extracted.join(`
 `);
 }
+function hasResidualJsx(code) {
+  return /<[A-Za-z]\w*\s+[\w-]+=\{/.test(code);
+}
 function findAppComponent(components) {
   for (const [name, comp] of Object.entries(components)) {
     if (comp.tier === "runtime-fallback")