@absolutejs/absolute 0.20.0-beta.170 → 0.20.0-beta.171

package/dist/dev/client/domTracker.ts

@@ -1,13 +1,58 @@
 import type {} from '../../types/globals';
 /* Snapshot/restore for JS-modified DOM state across HMR updates.
  * Before patching, captures text and dynamic children of elements with IDs.
- * After patching, restores values that were changed by user scripts. */
+ * After patching, restores values that were changed by user scripts.
+ *
+ * "Changed by user scripts" means the live value differs from what the
+ * server last sent for that element (the baseline), not from what it sends
+ * now. Comparing against the new markup alone would treat every edited
+ * text as a script change and put the old text back. The baseline is the
+ * page as parsed when the HMR client starts (captureServerDOM), then each
+ * update's markup. */
 
 type DOMSnapshot = {
 	children: Map<string, string>;
 	text: Map<string, string>;
 };
 
+let serverBaseline: DOMSnapshot | null = null;
+
+const collectIdState = (root: ParentNode): DOMSnapshot => {
+	const text = new Map<string, string>();
+	const children = new Map<string, string>();
+
+	root.querySelectorAll('[id]').forEach((elem) => {
+		const { childNodes } = elem;
+		const isTextLeaf = Array.from(childNodes).every(
+			(child) => child.nodeType === Node.TEXT_NODE
+		);
+
+		if (isTextLeaf && childNodes.length > 0) {
+			text.set(elem.id, elem.textContent || '');
+		} else if (elem.children.length > 0) {
+			children.set(elem.id, elem.innerHTML);
+		}
+	});
+
+	return { children, text };
+};
+
+/* Record the server-rendered DOM as the baseline. Call once, when the HMR
+ * client starts: it runs at the end of <body>, before most page scripts
+ * have changed anything. */
+export const captureServerDOM = (root: ParentNode | null | undefined) => {
+	if (!root || serverBaseline) return;
+	serverBaseline = collectIdState(root);
+};
+
+/* True when the live value still matches what the server last sent, i.e.
+ * no script touched it: the new server value wins. */
+const isUntouched = (
+	baseline: Map<string, string> | undefined,
+	elId: string,
+	liveValue: string
+) => baseline?.has(elId) === true && baseline.get(elId) === liveValue;
+
 export const restoreDOMChanges = (
 	root: HTMLElement,
 	snapshot: DOMSnapshot,
@@ -15,12 +60,14 @@ export const restoreDOMChanges = (
 ) => {
 	const tempDiv = document.createElement('div');
 	tempDiv.innerHTML = newHTML;
+	const baseline = serverBaseline;
 
 	/* Restore JS-modified text on leaf elements */
 	snapshot.text.forEach((liveText, elId) => {
 		const newEl = tempDiv.querySelector(`#${CSS.escape(elId)}`);
 		const newText = newEl ? newEl.textContent || '' : '';
 		if (liveText === newText) return;
+		if (isUntouched(baseline?.text, elId, liveText)) return;
 
 		const liveEl = root.querySelector(`#${CSS.escape(elId)}`);
 		if (liveEl) {
@@ -33,29 +80,15 @@ export const restoreDOMChanges = (
 		const newEl = tempDiv.querySelector(`#${CSS.escape(elId)}`);
 		const newInner = newEl ? newEl.innerHTML : '';
 		if (liveHTML === newInner || liveHTML.length <= newInner.length) return;
+		if (isUntouched(baseline?.children, elId, liveHTML)) return;
 
 		const liveEl = root.querySelector(`#${CSS.escape(elId)}`);
 		if (liveEl) {
 			liveEl.innerHTML = liveHTML;
 		}
 	});
-};
-export const snapshotDOMChanges = (root: HTMLElement): DOMSnapshot => {
-	const text = new Map<string, string>();
-	const children = new Map<string, string>();
-
-	root.querySelectorAll('[id]').forEach((elem) => {
-		const { childNodes } = elem;
-		const isTextLeaf = Array.from(childNodes).every(
-			(child) => child.nodeType === Node.TEXT_NODE
-		);
-
-		if (isTextLeaf && childNodes.length > 0) {
-			text.set(elem.id, elem.textContent || '');
-		} else if (elem.children.length > 0) {
-			children.set(elem.id, elem.innerHTML);
-		}
-	});
 
-	return { children, text };
+	// The markup just applied is what the server sent last.
+	serverBaseline = collectIdState(tempDiv);
 };
+export const snapshotDOMChanges = (root: HTMLElement) => collectIdState(root);

package/dist/dev/client/frameworkDetect.ts

@@ -61,3 +61,14 @@ export const getComponentNameFromPath = (filePath: string) => {
 		.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
 		.join('');
 };
+/* Static (HTML/HTMX) pages are told which built page they are (see
+ * injectHMRIntoHTMLFile in build.ts). Every tab receives every page's
+ * html-update / htmx-update, so a tab applies only its own page's. A
+ * document without a page name (older builds) applies all of them. */
+export const isUpdateForThisPage = (sourceFile: unknown) => {
+	const page = window.__HMR_PAGE__;
+	if (!page || typeof sourceFile !== 'string') return true;
+	const normalized = sourceFile.replace(/\\/g, '/');
+
+	return normalized.slice(normalized.lastIndexOf('/') + 1) === page;
+};

package/dist/dev/client/handlers/html.ts

@@ -14,7 +14,10 @@ import {
 } from '../domState';
 import { processCSSLinks, waitForCSSAndUpdate } from '../cssUtils';
 import { patchHeadInPlace } from '../headPatch';
-import { detectCurrentFramework } from '../frameworkDetect';
+import {
+	detectCurrentFramework,
+	isUpdateForThisPage
+} from '../frameworkDetect';
 import type { ScriptInfo } from '../../../types/client';
 import { restoreDOMChanges, snapshotDOMChanges } from '../domTracker';
 import { hmrState } from '../hmrState';
@@ -86,6 +89,7 @@ export const handleHTMLUpdate = (message: {
 	data: {
 		html?: string | { body?: string; head?: string } | null;
 		serverDuration?: number;
+		sourceFile?: string;
 	};
 	timestamp?: number;
 }) => {
@@ -93,6 +97,7 @@ export const handleHTMLUpdate = (message: {
 	if (htmlFrameworkCheck !== 'html') {
 		return;
 	}
+	if (!isUpdateForThisPage(message.data.sourceFile)) return;
 
 	if (window.__REACT_ROOT__) {
 		window.__REACT_ROOT__ = undefined;

package/dist/dev/client/handlers/htmx.ts

@@ -14,7 +14,10 @@ import {
 } from '../domState';
 import { processCSSLinks, waitForCSSAndUpdate } from '../cssUtils';
 import { patchHeadInPlace } from '../headPatch';
-import { detectCurrentFramework } from '../frameworkDetect';
+import {
+	detectCurrentFramework,
+	isUpdateForThisPage
+} from '../frameworkDetect';
 import { type HTMXSavedState, type ScriptInfo } from '../../../types/client';
 import { hmrState } from '../hmrState';
 import { sendAbsoluteHmrTiming } from '../hmrTiming';
@@ -72,11 +75,13 @@ export const handleHTMXUpdate = (message: {
 	data: {
 		html?: string | { body?: string; head?: string } | null;
 		serverDuration?: number;
+		sourceFile?: string;
 	};
 	timestamp?: number;
 }) => {
 	const htmxFrameworkCheck = detectCurrentFramework();
 	if (htmxFrameworkCheck !== 'htmx') return;
+	if (!isUpdateForThisPage(message.data.sourceFile)) return;
 
 	if (window.__REACT_ROOT__) {
 		window.__REACT_ROOT__ = undefined;

package/dist/dev/client/hmrClient.ts

@@ -15,6 +15,7 @@ import {
 	type ServerSnapshot
 } from './reconnect';
 import { detectCurrentFramework } from './frameworkDetect';
+import { captureServerDOM } from './domTracker';
 import {
 	absoluteHmrClientTarget,
 	restoreAbsoluteHmrApply,
@@ -159,6 +160,15 @@ if (typeof window !== 'undefined') {
 	if (!window.__HMR_SERVER_VERSIONS__) {
 		window.__HMR_SERVER_VERSIONS__ = {};
 	}
+	// Static pages: remember the server-rendered text of elements with an
+	// id, so an HMR update can tell script changes from edited markup.
+	const framework = window.__HMR_FRAMEWORK__;
+	if (
+		(framework === 'html' || framework === 'htmx') &&
+		typeof document !== 'undefined'
+	) {
+		captureServerDOM(document.body);
+	}
 }
 
 // Catch uncaught runtime errors and show the error overlay

package/dist/dev/serverBootstrap.js

@@ -739,7 +739,7 @@ var init_workspacePackages = __esm(() => {
 
 // src/dev/hot/analyze.ts
 import { dirname, extname } from "path";
-var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scriptKindFor = (tsc, path) => {
+var ANALYZER_VERSION = 2, hashText = (text) => Bun.hash(text).toString(36), scriptKindFor = (tsc, path) => {
   switch (extname(path)) {
     case ".tsx":
       return tsc.ScriptKind.TSX;
@@ -997,7 +997,23 @@ var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scri
   while (current && (tsc.isParenthesizedExpression(current) || tsc.isAsExpression(current) || tsc.isSatisfiesExpression(current)))
     current = current.expression;
   return current !== undefined && (tsc.isArrowFunction(current) || tsc.isFunctionExpression(current));
-}, IDENTIFIER, rejection = (reason) => ({
+}, IDENTIFIER, STATEFUL_FACTORIES, STATIC_IDENTIFIERS, isStaticExpression = (tsc, node) => {
+  if (tsc.isParenthesizedExpression(node) || tsc.isAsExpression(node) || tsc.isSatisfiesExpression(node) || tsc.isSpreadElement(node) || tsc.isSpreadAssignment(node))
+    return isStaticExpression(tsc, node.expression);
+  if (tsc.isStringLiteral(node) || tsc.isNumericLiteral(node) || tsc.isBigIntLiteral(node) || tsc.isNoSubstitutionTemplateLiteral(node) || tsc.isRegularExpressionLiteral(node) || node.kind === tsc.SyntaxKind.TrueKeyword || node.kind === tsc.SyntaxKind.FalseKeyword || node.kind === tsc.SyntaxKind.NullKeyword || tsc.isOmittedExpression(node))
+    return true;
+  if (tsc.isIdentifier(node))
+    return STATIC_IDENTIFIERS.has(node.text);
+  if (tsc.isPrefixUnaryExpression(node))
+    return isStaticExpression(tsc, node.operand);
+  if (tsc.isArrayLiteralExpression(node))
+    return node.elements.every((element) => isStaticExpression(tsc, element));
+  if (tsc.isObjectLiteralExpression(node))
+    return node.properties.every((property) => tsc.isSpreadAssignment(property) ? isStaticExpression(tsc, property) : tsc.isPropertyAssignment(property) && (!tsc.isComputedPropertyName(property.name) || isStaticExpression(tsc, property.name.expression)) && isStaticExpression(tsc, property.initializer));
+  if (tsc.isTemplateExpression(node))
+    return node.templateSpans.every((span) => isStaticExpression(tsc, span.expression));
+  return false;
+}, rejection = (reason) => ({
   ok: false,
   reason
 }), addImport = (scope, local, binding) => {
@@ -1008,14 +1024,23 @@ var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scri
   if (!clause || clause.isTypeOnly)
     return;
   const specifier = statement.moduleSpecifier;
-  const module = tsc.isStringLiteralLike(specifier) || tsc.isIdentifier(specifier) ? resolveImport(specifier.text) : undefined;
+  const written = tsc.isStringLiteralLike(specifier) || tsc.isIdentifier(specifier) ? specifier.text : undefined;
+  const module = written === undefined ? undefined : resolveImport(written);
   if (clause.name)
-    addImport(scope, clause.name.text, { module, name: "default" });
+    addImport(scope, clause.name.text, {
+      module,
+      name: "default",
+      specifier: written
+    });
   const bindings = clause.namedBindings;
   if (!bindings)
     return;
   if (tsc.isNamespaceImport(bindings)) {
-    addImport(scope, bindings.name.text, { module, name: "*" });
+    addImport(scope, bindings.name.text, {
+      module,
+      name: "*",
+      specifier: written
+    });
     return;
   }
   for (const element of bindings.elements) {
@@ -1023,7 +1048,8 @@ var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scri
       continue;
     addImport(scope, element.name.text, {
       module,
-      name: (element.propertyName ?? element.name).text
+      name: (element.propertyName ?? element.name).text,
+      specifier: written
     });
   }
 }, recordExportList = (tsc, scope, statement) => {
@@ -1397,8 +1423,58 @@ var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scri
       edit(node.getStart(file), node.end - node.getStart(file), replacement);
     }
   };
+  const statefulCall = (reference) => {
+    if (reference.deferred || !reference.call)
+      return;
+    const imported = imports.get(reference.name);
+    const factories = imported?.specifier ? STATEFUL_FACTORIES.get(imported.specifier) : undefined;
+    if (!imported || !factories)
+      return;
+    const viaNamespace = imported.name === "*" && reference.member !== undefined;
+    const name = viaNamespace ? reference.member : imported.name;
+    const callee = viaNamespace ? reference.node.parent : reference.node;
+    const call = callee.parent;
+    if (!name || !factories.has(name) || !call || !tsc.isCallExpression(call) || call.expression !== callee)
+      return;
+    return { call, name };
+  };
+  const ownerId = (statement, node) => {
+    const { node: root } = statement;
+    if (!tsc.isVariableStatement(root))
+      return statement.id;
+    const declaration = root.declarationList.declarations.find((item) => item.pos <= node.pos && node.end <= item.end);
+    const name = declaration ? bindingNames(tsc, declaration.name)[0] : undefined;
+    if (!name)
+      return statement.id;
+    return statement.kind === "let" ? `${statement.id}:${name}` : `v:${name}`;
+  };
+  const rewriteStatefulCalls = (statement) => {
+    if (statement.kind === "import" || statement.kind === "skip")
+      return;
+    const occurrences = new Map;
+    for (const reference of statement.refs) {
+      const found = statefulCall(reference);
+      if (!found)
+        continue;
+      const { call, name } = found;
+      const owner = ownerId(statement, call);
+      const line = file.getLineAndCharacterOfPosition(call.getStart(file)).line + 1;
+      const label = quote(`${name}(\u2026) on line ${line}`);
+      const isStatic = call.arguments.every((argument) => isStaticExpression(tsc, argument));
+      if (!isStatic && hasTopLevelAwait(tsc, call))
+        continue;
+      const textHash = hashText(call.getText(file));
+      const occurrence = occurrences.get(`${owner}#${textHash}`) ?? 0;
+      occurrences.set(`${owner}#${textHash}`, occurrence + 1);
+      const key = quote(`${owner}#${textHash}#${occurrence}`);
+      edit(call.getStart(file), 0, isStatic ? `__absH.p(${quote(owner)},${key},${label},()=>(` : `__absH.w(${quote(owner)},${key},${label},()=>(`);
+      edit(call.end, 0, "))");
+    }
+  };
   for (const statement of statements)
     rewriteStatement(statement);
+  for (const statement of statements)
+    rewriteStatefulCalls(statement);
   for (const statement of statements)
     rewriteCellReferences(statement);
   edits.sort(compareEdits);
@@ -1453,6 +1529,10 @@ var ANALYZER_VERSION = 1, hashText = (text) => Bun.hash(text).toString(36), scri
 };
 var init_analyze = __esm(() => {
   IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+  STATEFUL_FACTORIES = new Map([
+    ["@absolutejs/scoped-state", new Set(["scopedState"])]
+  ]);
+  STATIC_IDENTIFIERS = new Set(["Infinity", "NaN", "undefined"]);
 });
 
 // src/dev/hot/runtime.ts
@@ -1464,6 +1544,7 @@ var records, recordFor = (path) => {
   const created = {
     cells: {},
     generation: 0,
+    instances: new Map,
     keys: new Map,
     lastChanged: new Set,
     lastTimings: new Map,
@@ -1472,6 +1553,7 @@ var records, recordFor = (path) => {
     revisions: new Map,
     slots: new Map,
     tag: 0,
+    warned: new Set,
     watchers: new Map
   };
   records.set(path, created);
@@ -1514,6 +1596,7 @@ var records, recordFor = (path) => {
   record.generation += 1;
   const pending = {
     generation: record.generation,
+    instances: new Map,
     meta,
     reran: new Set,
     seen: new Set,
@@ -1549,6 +1632,7 @@ var records, recordFor = (path) => {
     pending.slots.set(id, { generation, value });
     return value;
   };
+  const where = (label) => `${label} of ${relative(process.cwd(), path) || path}`;
   return {
     cells: record.cells,
     c: (name, id, init) => {
@@ -1576,6 +1660,14 @@ var records, recordFor = (path) => {
         return previous.value;
       return store(id, await ownedAsync(id, factory));
     },
+    p: (owner, key, label, create) => {
+      const previous = record.instances.get(key);
+      const value = previous ? previous.value : create();
+      if (!previous && record.keys.has(owner))
+        console.log(`[hmr] ${where(label)} is new or changed, so its state starts empty`);
+      pending.instances.set(key, { owner, value });
+      return value;
+    },
     r: (id, effect) => {
       if (kept(id))
         return;
@@ -1587,6 +1679,13 @@ var records, recordFor = (path) => {
         return;
       await ownedAsync(id, effect);
       store(id, undefined);
+    },
+    w: (owner, key, label, create) => {
+      if (record.keys.has(owner) && !record.warned.has(key)) {
+        record.warned.add(key);
+        console.warn(`[hmr] ${where(label)} ran again because its statement re-ran, so the state it holds was reset. Create it in its own top-level const (const visitorState = scopedState({ \u2026 })) and pass that to .use() to keep it across edits.`);
+      }
+      return create();
     }
   };
 }, exportToken = (module, name, call) => {
@@ -1612,6 +1711,12 @@ var records, recordFor = (path) => {
   await Promise.all([...replaced.values()].map((slot) => disposeValue(slot.value).catch((error) => console.error(`[hmr] disposing a replaced value failed:`, error))));
   if (record.generation > 1)
     logDisposed(record.path, counts);
+}, keptInstances = (record, pending) => {
+  const instances = new Map(pending.instances);
+  for (const [key, instance] of record.instances)
+    if (!instances.has(key) && pending.seen.has(instance.owner) && !pending.reran.has(instance.owner))
+      instances.set(key, instance);
+  return instances;
 }, commit = (record, pending) => {
   if (record.pending !== pending)
     return;
@@ -1625,6 +1730,7 @@ var records, recordFor = (path) => {
   record.keys = pending.keys;
   record.lastChanged = pending.changedExports;
   record.lastTimings = pending.timings;
+  record.instances = keptInstances(record, pending);
   for (const name of pending.changedExports)
     record.revisions.set(name, (record.revisions.get(name) ?? 0) + 1);
   if (replaced.size === 0)