@absolutejs/absolute 0.20.0-beta.72 → 0.20.0-beta.73

package/dist/angular/components/core/streamingSlotRegistrar.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-88UQkL/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-GauEbM/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");

package/dist/angular/components/core/streamingSlotRegistry.js

@@ -1,7 +1,7 @@
 // @bun
 var __require = import.meta.require;
 
-// .angular-partial-tmp-88UQkL/src/core/streamingSlotRegistrar.ts
+// .angular-partial-tmp-GauEbM/src/core/streamingSlotRegistrar.ts
 var STREAMING_SLOT_REGISTRAR_KEY = Symbol.for("absolutejs.streamingSlotRegistrar");
 var STREAMING_SLOT_WARNING_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotWarningController");
 var STREAMING_SLOT_COLLECTION_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotCollectionController");
@@ -48,7 +48,7 @@ var warnMissingStreamingSlotCollector = (primitiveName) => {
   getWarningController()?.maybeWarn(primitiveName);
 };
 
-// .angular-partial-tmp-88UQkL/src/core/streamingSlotRegistry.ts
+// .angular-partial-tmp-GauEbM/src/core/streamingSlotRegistry.ts
 var STREAMING_SLOT_STORAGE_KEY = Symbol.for("absolutejs.streamingSlotAsyncLocalStorage");
 var isObjectRecord2 = (value) => Boolean(value) && typeof value === "object";
 var isAsyncLocalStorage = (value) => isObjectRecord2(value) && ("getStore" in value) && typeof value.getStore === "function" && ("run" in value) && typeof value.run === "function";

package/dist/cli/{dev-rbvkxpj7.js → dev-p7s1ej32.js}

@@ -786,6 +786,160 @@ var createDevPrescan = (config, projectRoot = process.cwd()) => {
   };
 };
 
+// src/dev/importCost/recorder.ts
+var IMPORT_COST_ENV = "ABSOLUTE_DEV_IMPORT_COST";
+var importCostEnabled = () => process.env[IMPORT_COST_ENV] === "1";
+
+// src/dev/bootLifecycle.ts
+var getBootPhase = () => globalThis.__absoluteBootPhase;
+
+// src/dev/earlyListener.ts
+var HTTP_SERVICE_UNAVAILABLE = 503;
+var RETRY_AFTER_SECONDS = 2;
+var BIND_RETRY_INTERVAL_MS = 250;
+var BIND_RETRY_LIMIT = 40;
+var POLL_INTERVAL_MS = RETRY_AFTER_SECONDS * MILLISECONDS_IN_A_SECOND;
+var NOSCRIPT_REFRESH_SECONDS = 10;
+var BOOT_STATUS_HEADER = "X-Absolute-Boot";
+var PARENT_HANDOFF_MARKER = "absolute:listening";
+var PARENT_LISTENER_ENV = "ABSOLUTE_PARENT_LISTENER";
+var bindingPlaceholder = false;
+var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+var bootStatusSnapshot = (startedAt) => {
+  const elapsedMs = Math.max(0, Date.now() - startedAt);
+  return {
+    elapsedMs,
+    elapsedSeconds: Math.floor(elapsedMs / MILLISECONDS_IN_A_SECOND),
+    phase: getBootPhase() ?? "starting",
+    status: "building"
+  };
+};
+var buildingPage = (snapshot) => `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta http-equiv="refresh" content="${NOSCRIPT_REFRESH_SECONDS}">
+<title>Building\u2026</title>
+<style>
+:root{color-scheme:light dark}
+body{margin:0;min-height:100vh;display:grid;place-items:center;font:15px/1.5 system-ui,-apple-system,"Segoe UI",sans-serif;background:#0f1115;color:#e6e8ee}
+main{text-align:center;padding:2rem}
+.spin{width:36px;height:36px;margin:0 auto 1rem;border:3px solid rgba(255,255,255,.15);border-top-color:#8ab4ff;border-radius:50%;animation:s 1s linear infinite}
+@keyframes s{to{transform:rotate(360deg)}}
+h1{font-size:1.15rem;font-weight:600;margin:0 0 .25rem}
+p{margin:0;opacity:.6;font-size:.85rem}
+code{font-family:ui-monospace,SFMono-Regular,Menlo,monospace}
+</style>
+</head>
+<body>
+<main>
+<div class="spin" aria-hidden="true"></div>
+<h1>Building\u2026 <span id="t">${snapshot.elapsedSeconds}</span>s</h1>
+<p>AbsoluteJS dev server \xB7 <code id="p">${escapeHtml(snapshot.phase)}</code></p>
+</main>
+<script>
+(function(){
+var started=Date.now()-${snapshot.elapsedMs};
+var t=document.getElementById('t');
+setInterval(function(){t.textContent=String(Math.floor((Date.now()-started)/1000));},1000);
+function poll(){
+fetch(location.href,{cache:'no-store',headers:{accept:'application/json'}}).then(function(r){
+if(r.headers.get('${BOOT_STATUS_HEADER.toLowerCase()}')!=='building'){location.reload();return;}
+return r.json().then(function(j){if(j&&j.phase){document.getElementById('p').textContent=j.phase;}});
+}).catch(function(){}).then(function(){setTimeout(poll,${POLL_INTERVAL_MS});});
+}
+setTimeout(poll,${POLL_INTERVAL_MS});
+})();
+</script>
+</body>
+</html>
+`;
+var buildingResponse = (request, startedAt) => {
+  const snapshot = bootStatusSnapshot(startedAt);
+  const headers = {
+    "Cache-Control": "no-store",
+    "Retry-After": String(RETRY_AFTER_SECONDS),
+    "X-Absolute-Boot": "building"
+  };
+  const isUpgrade = request.headers.get("upgrade")?.toLowerCase() === "websocket";
+  const accept = request.headers.get("accept") ?? "";
+  if (!isUpgrade && accept.includes("text/html")) {
+    headers["Content-Type"] = "text/html; charset=utf-8";
+    return new Response(buildingPage(snapshot), {
+      headers,
+      status: HTTP_SERVICE_UNAVAILABLE
+    });
+  }
+  if (!isUpgrade && accept.includes("application/json")) {
+    headers["Content-Type"] = "application/json; charset=utf-8";
+    return new Response(JSON.stringify(snapshot), {
+      headers,
+      status: HTTP_SERVICE_UNAVAILABLE
+    });
+  }
+  headers["Content-Type"] = "text/plain; charset=utf-8";
+  return new Response(`AbsoluteJS dev server is building (${snapshot.elapsedSeconds}s, ${snapshot.phase}). Retry shortly.
+`, { headers, status: HTTP_SERVICE_UNAVAILABLE });
+};
+var parentListenerSupported = () => process.platform !== "win32";
+var startEarlyListener = (options) => {
+  const startedAt = Date.now();
+  let server = null;
+  let released = false;
+  let attempts = 0;
+  let retryTimer;
+  const tryBind = () => {
+    if (released)
+      return;
+    attempts += 1;
+    bindingPlaceholder = true;
+    try {
+      server = Bun.serve({
+        hostname: options.host,
+        port: options.port,
+        fetch: (request) => buildingResponse(request, startedAt),
+        ...options.reusePort ? { reusePort: true } : {},
+        ...options.tls ? { tls: options.tls } : {}
+      });
+    } catch {
+      if (attempts >= BIND_RETRY_LIMIT)
+        return;
+      retryTimer = setTimeout(tryBind, BIND_RETRY_INTERVAL_MS);
+      retryTimer.unref();
+    } finally {
+      bindingPlaceholder = false;
+    }
+  };
+  const release = () => {
+    if (released)
+      return;
+    released = true;
+    if (retryTimer)
+      clearTimeout(retryTimer);
+    const active = server;
+    server = null;
+    if (!active)
+      return;
+    try {
+      active.stop(true);
+    } catch {}
+  };
+  tryBind();
+  const listener = {
+    release,
+    startedAt,
+    get released() {
+      return released;
+    },
+    get server() {
+      return server;
+    }
+  };
+  globalThis.__absoluteEarlyListener = listener;
+  return listener;
+};
+
 // src/cli/interactive.ts
 import { openSync } from "fs";
 import { ReadStream } from "tty";
@@ -1198,6 +1352,8 @@ var RESTART_PARK_POLL_MS = 20;
 var NODE_API_IMPORT_ERROR = "To load Node-API modules, use require() or process.dlopen instead of import.";
 var sourceServerBootstrap = resolvePath(import.meta.dir, "../../dev/serverBootstrap.ts");
 var serverBootstrap = existsSync4(sourceServerBootstrap) ? sourceServerBootstrap : resolvePath(import.meta.dir, "../dev/serverBootstrap.js");
+var sourceImportCostPreload = resolvePath(import.meta.dir, "../../dev/importCostPreload.ts");
+var importCostPreload = existsSync4(sourceImportCostPreload) ? sourceImportCostPreload : resolvePath(import.meta.dir, "../dev/importCostPreload.js");
 var formatServerBootDiagnostic = (output, serverEntry) => {
   if (!output.includes(NODE_API_IMPORT_ERROR))
     return null;
@@ -1565,6 +1721,54 @@ var dev = async (serverEntry, configPath, options = {}) => {
   }
   markBoot("dev port resolved");
   updateLockMetadata(buildDirectory, { port });
+  const parentListenerAllowed = env.ABSOLUTE_EARLY_LISTEN !== "0" && parentListenerSupported();
+  let parentListener = null;
+  let parentListenerPort = null;
+  let parentListenerTls;
+  const releaseParentListener = () => {
+    const listener = parentListener;
+    parentListener = null;
+    parentListenerPort = null;
+    if (!listener)
+      return;
+    listener.release();
+    if (globalThis.__absoluteEarlyListener === listener) {
+      globalThis.__absoluteEarlyListener = undefined;
+    }
+  };
+  const loadParentListenerTls = async () => {
+    if (!httpsEnabled)
+      return null;
+    try {
+      const { loadDevCert } = await import("./devCert-avr89zf3.js");
+      return loadDevCert();
+    } catch {
+      return null;
+    }
+  };
+  const ensureParentListener = async () => {
+    if (!parentListenerAllowed)
+      return;
+    if (parentListener && parentListenerPort === port)
+      return;
+    releaseParentListener();
+    parentListenerTls ??= await loadParentListenerTls();
+    const listener = startEarlyListener({
+      host: resolvedDev.host,
+      port,
+      reusePort: true,
+      tls: parentListenerTls
+    });
+    if (!listener.server) {
+      listener.release();
+      globalThis.__absoluteEarlyListener = undefined;
+      return;
+    }
+    parentListener = listener;
+    parentListenerPort = port;
+    markBoot("parent listener bound");
+  };
+  await ensureParentListener();
   const instancePid = process.pid;
   const instanceLogFile = instanceLogPath(instancePid);
   const relaunchCommand = [
@@ -2080,6 +2284,7 @@ var dev = async (serverEntry, configPath, options = {}) => {
     if (!chunk.includes("Local:"))
       return;
     serverReady = true;
+    releaseParentListener();
     startTunnelIfConfigured();
     startAndroidDev();
     startIosDev();
@@ -2200,8 +2405,12 @@ var dev = async (serverEntry, configPath, options = {}) => {
     } catch {}
   };
   let prescan = prescanConfig ? createDevPrescan(prescanConfig) : null;
+  let spawnGeneration = 0;
   const spawnServer = async () => {
+    spawnGeneration += 1;
+    const generation = spawnGeneration;
     await refreshDevConfigForSpawn();
+    await ensureParentListener();
     markBoot("dev child spawn requested");
     const prescanForSpawn = prescan;
     prescan = null;
@@ -2209,6 +2418,7 @@ var dev = async (serverEntry, configPath, options = {}) => {
       "--hot",
       "--no-clear-screen",
       ...heapSnapshotEnabled ? ["--preload", heapPreloadPath] : [],
+      ...importCostEnabled() ? ["--preload", importCostPreload] : [],
       serverBootstrap
     ], {
       cwd: process.cwd(),
@@ -2220,6 +2430,7 @@ var dev = async (serverEntry, configPath, options = {}) => {
         ABSOLUTE_INSTANCE_MANAGED: "1",
         ABSOLUTE_PORT: String(port),
         ABSOLUTE_SERVER_ENTRY: resolvePath(serverEntry),
+        ...parentListener ? { [PARENT_LISTENER_ENV]: "1" } : {},
         ...bootTimelineChildEnv(),
         ...prescanForSpawn ? { ABSOLUTE_DEV_PRESCAN: prescanForSpawn.path } : {},
         ...options.eager ? { ABSOLUTE_DEV_EAGER: "1" } : {},
@@ -2230,9 +2441,20 @@ var dev = async (serverEntry, configPath, options = {}) => {
         ...configPath ? { ABSOLUTE_CONFIG: configPath } : {},
         ...httpsEnabled ? { ABSOLUTE_HTTPS: "true" } : {}
       },
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe", "pipe"]
     });
     prescanForSpawn?.start();
+    const [, , , handoffPipe] = proc.stdio;
+    if (handoffPipe && "on" in handoffPipe) {
+      handoffPipe.on("data", (chunk) => {
+        if (generation !== spawnGeneration)
+          return;
+        if (!chunk.toString().includes(PARENT_HANDOFF_MARKER))
+          return;
+        releaseParentListener();
+      });
+      handoffPipe.on("error", () => {});
+    }
     let printedBootDiagnostic = false;
     const forward = (source, dest, sourceName) => {
       if (!source)
@@ -2443,6 +2665,7 @@ var dev = async (serverEntry, configPath, options = {}) => {
     });
     if (interactive)
       interactive.dispose();
+    releaseParentListener();
     tunnelClient?.close();
     androidDevAbort.abort();
     androidNativeWatcher?.close();

package/dist/cli/index.js

@@ -58,7 +58,7 @@ if (command === "dev") {
   }
   const positionalArgs = stripNamedArgs("--config", "--android-device", "--ios-device").filter((arg) => arg !== "--no-mobile" && arg !== "--eager");
   const serverEntry = positionalArgs[0] ?? DEFAULT_SERVER_ENTRY;
-  const { dev } = await import("./dev-rbvkxpj7.js");
+  const { dev } = await import("./dev-p7s1ej32.js");
   await dev(serverEntry, configPath, {
     androidDevice,
     eager: args.includes("--eager"),

package/dist/dev/importCostPreload.js

@@ -0,0 +1,206 @@
+// @bun
+// src/dev/importCostPreload.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var {plugin } = globalThis.Bun;
+
+// src/dev/importCost/instrument.ts
+var BYTE_ORDER_MARK = 65279;
+var NOT_FOUND = -1;
+var PROLOGUE_TOKEN = /\s+|\/\/[^\n]*|\/\*[\s\S]*?\*\/|(['"])use [^'"\n]*\1[ \t]*;?/y;
+var prologueEnd = (source) => {
+  let index = source.charCodeAt(0) === BYTE_ORDER_MARK ? 1 : 0;
+  if (source.startsWith("#!", index)) {
+    const newline = source.indexOf(`
+`, index);
+    index = newline === NOT_FOUND ? source.length : newline + 1;
+  }
+  for (;; ) {
+    PROLOGUE_TOKEN.lastIndex = index;
+    if (PROLOGUE_TOKEN.exec(source) === null)
+      return index;
+    index = PROLOGUE_TOKEN.lastIndex;
+  }
+};
+var TYPESCRIPT_EXTENSION = /\.[cm]?ts$/;
+var JS_LOADER = "js";
+var JSX_LOADER = "jsx";
+var TS_LOADER = "ts";
+var TSX_LOADER = "tsx";
+var importCostLoader = (path) => {
+  if (path.endsWith(".tsx"))
+    return TSX_LOADER;
+  if (path.endsWith(".jsx"))
+    return JSX_LOADER;
+  if (TYPESCRIPT_EXTENSION.test(path))
+    return TS_LOADER;
+  return JS_LOADER;
+};
+var instrumentModuleSource = (source, moduleIndex) => {
+  const insertAt = prologueEnd(source);
+  const enter = `globalThis.__absoluteImportCostEnter?.(${moduleIndex});`;
+  const exit = `
+;globalThis.__absoluteImportCostExit?.(${moduleIndex});`;
+  return `${source.slice(0, insertAt)}${enter}${source.slice(insertAt)}${exit}`;
+};
+
+// src/dev/importCost/recorder.ts
+var IMPORT_COST_EVENT = {
+  enter: 2,
+  exit: 3,
+  loadEnd: 1,
+  loadStart: 0
+};
+var IMPORT_COST_EVENT_KINDS = 4;
+var ensureImportCostRecorder = () => {
+  const existing = globalThis.__absoluteImportCost;
+  if (existing !== undefined)
+    return existing;
+  const created = {
+    entryModule: null,
+    entryOriginalModule: null,
+    events: [],
+    moduleIds: [],
+    moduleIndexes: new Map,
+    recording: true,
+    rootModule: null
+  };
+  globalThis.__absoluteImportCost = created;
+  return created;
+};
+
+// src/dev/importCost/scope.ts
+import { readdirSync, readFileSync, realpathSync, statSync } from "fs";
+import { join } from "path";
+var NESTED_SCAN_DEPTH = 6;
+var REGEX_SPECIAL = /[.*+?^${}()|[\]\\]/g;
+var SEPARATOR = "[\\\\/]";
+var OUTSIDE_MODULES = `(?!.*${SEPARATOR}node_modules${SEPARATOR}).*`;
+var SOURCE_EXTENSION = "\\.m?[jt]sx?$";
+var ANY_MJS = "\\.mjs$";
+var manifestType = (directory) => {
+  try {
+    const manifest = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+    return Reflect.get(Object(manifest), "type") === "module" ? "module" : "commonjs";
+  } catch {
+    return null;
+  }
+};
+var subdirectories = (directory) => {
+  try {
+    return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+};
+var findCommonJsIslands = (directory, found, depth) => {
+  if (depth > NESTED_SCAN_DEPTH)
+    return;
+  for (const name of subdirectories(directory)) {
+    visitIsland(join(directory, name), name, found, depth);
+  }
+};
+var visitIsland = (directory, name, found, depth) => {
+  if (name === "node_modules" || manifestType(directory) === "commonjs") {
+    found.push(directory);
+    return;
+  }
+  findCommonJsIslands(directory, found, depth + 1);
+};
+var recordPackage = (directory, regions) => {
+  if (manifestType(directory) !== "module")
+    return;
+  regions.esmPrefixes.push(directory);
+  findCommonJsIslands(directory, regions.cjsPrefixes, 0);
+};
+var scanEntry = (modulesRoot, name, regions) => {
+  if (name.startsWith("."))
+    return;
+  if (!name.startsWith("@")) {
+    recordPackage(join(modulesRoot, name), regions);
+    return;
+  }
+  for (const scoped of subdirectories(join(modulesRoot, name))) {
+    recordPackage(join(modulesRoot, name, scoped), regions);
+  }
+};
+var scanPackages = (modulesRoot, regions) => {
+  for (const name of subdirectories(modulesRoot)) {
+    scanEntry(modulesRoot, name, regions);
+  }
+};
+var esmRegions = (root) => {
+  const regions = { cjsPrefixes: [], esmPrefixes: [] };
+  const modulesRoot = join(root, "node_modules");
+  try {
+    statSync(modulesRoot);
+  } catch {
+    return regions;
+  }
+  scanPackages(realpathSync(modulesRoot), regions);
+  return regions;
+};
+var alternation = (prefixes) => prefixes.map((prefix) => prefix.replace(REGEX_SPECIAL, "\\$&")).join("|");
+var instrumentableFilter = (regions) => {
+  const inEsmRegion = regions.esmPrefixes.length === 0 ? "" : `|(?:${alternation(regions.esmPrefixes)}).*`;
+  const notCommonJs = regions.cjsPrefixes.length === 0 ? "" : `(?!(?:${alternation(regions.cjsPrefixes)}))`;
+  return new RegExp(`^${notCommonJs}(?:${OUTSIDE_MODULES}${inEsmRegion})${SOURCE_EXTENSION}|${ANY_MJS}`);
+};
+
+// src/dev/importCostPreload.ts
+var recorder = ensureImportCostRecorder();
+var { events, moduleIds, moduleIndexes } = recorder;
+var record = (moduleIndex, kind) => {
+  events.push(moduleIndex * IMPORT_COST_EVENT_KINDS + kind, performance.now());
+};
+globalThis.__absoluteImportCostEnter = (moduleIndex) => {
+  if (!recorder.recording)
+    return;
+  record(moduleIndex, IMPORT_COST_EVENT.enter);
+};
+globalThis.__absoluteImportCostExit = (moduleIndex) => {
+  if (!recorder.recording)
+    return;
+  record(moduleIndex, IMPORT_COST_EVENT.exit);
+};
+var reportModulePath = () => {
+  const compiled = join2(import.meta.dir, "importCostReport.js");
+  return existsSync(compiled) ? compiled : join2(import.meta.dir, "importCost", "report.ts");
+};
+globalThis.__absoluteImportCostReport = async () => {
+  recorder.recording = false;
+  try {
+    const loaded = await import(reportModulePath());
+    loaded.reportImportCost?.();
+  } catch (error) {
+    console.error(`[absolute] import-cost report failed to load: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};
+var moduleIndexOf = (path) => {
+  const existing = moduleIndexes.get(path);
+  if (existing !== undefined)
+    return existing;
+  const created = moduleIds.length;
+  moduleIds.push(path);
+  moduleIndexes.set(path, created);
+  return created;
+};
+plugin({
+  name: "absolute-import-cost",
+  setup(build) {
+    build.onLoad({ filter: instrumentableFilter(esmRegions(process.cwd())) }, (args) => {
+      const loader = importCostLoader(args.path);
+      if (!recorder.recording) {
+        return {
+          contents: readFileSync2(args.path, "utf8"),
+          loader
+        };
+      }
+      const moduleIndex = moduleIndexOf(args.path);
+      record(moduleIndex, IMPORT_COST_EVENT.loadStart);
+      const contents = instrumentModuleSource(readFileSync2(args.path, "utf8"), moduleIndex);
+      record(moduleIndex, IMPORT_COST_EVENT.loadEnd);
+      return { contents, loader };
+    });
+  }
+});