@githolon/runtime 0.114.0 → 0.115.0

package/dist/nomos-runner-web.js

@@ -1,7 +1,290 @@
 "use strict";
 (() => {
+  var __typeError = (msg) => {
+    throw TypeError(msg);
+  };
+  var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+  var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+  var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+  // ../../platform-shells/browser/memory_watch.ts
+  function memoryFields(sample) {
+    if (!sample) return {};
+    return {
+      "kernel.memory_bytes": sample.kernelBytes,
+      "kernel.memory_high_water_bytes": sample.kernelHighWaterBytes,
+      ...sample.jsHeapBytes === void 0 ? {} : { "js.heap_bytes": sample.jsHeapBytes },
+      ...sample.custodyBytes === void 0 ? {} : { "custody.memory_bytes": sample.custodyBytes },
+      ...sample.workspace ? { "memory.workspace": sample.workspace } : {},
+      ...sample.operation ? { "memory.operation": sample.operation } : {}
+    };
+  }
+  var MEMORY_FORENSICS_KEY = "nomos.peer-memory-session/v1";
+  var MiB = (bytes) => Math.round(bytes / 1048576);
+  var _storage, _sessionId, _now, _minIntervalMillis, _lastWrittenAt, _lastWrittenHighWater, _ended;
+  var MemoryForensics = class {
+    constructor(storage, sessionId, options = {}) {
+      __privateAdd(this, _storage);
+      __privateAdd(this, _sessionId);
+      __privateAdd(this, _now);
+      __privateAdd(this, _minIntervalMillis);
+      __privateAdd(this, _lastWrittenAt, Number.NEGATIVE_INFINITY);
+      __privateAdd(this, _lastWrittenHighWater, -1);
+      __privateAdd(this, _ended, false);
+      __privateSet(this, _storage, storage);
+      __privateSet(this, _sessionId, sessionId);
+      __privateSet(this, _now, options.now ?? Date.now);
+      __privateSet(this, _minIntervalMillis, options.minIntervalMillis ?? 2e3);
+    }
+    /** A previous session's record, as one observation, removed so it is reported once. */
+    takePreviousUnclean() {
+      let record;
+      try {
+        const raw = __privateGet(this, _storage)?.getItem(MEMORY_FORENSICS_KEY);
+        if (!raw) return void 0;
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1 || typeof parsed.sessionId !== "string" || !parsed.sample || typeof parsed.sample.kernelHighWaterBytes !== "number") {
+          __privateGet(this, _storage)?.removeItem(MEMORY_FORENSICS_KEY);
+          return void 0;
+        }
+        if (parsed.sessionId === __privateGet(this, _sessionId)) return void 0;
+        record = parsed;
+        __privateGet(this, _storage)?.removeItem(MEMORY_FORENSICS_KEY);
+      } catch {
+        return void 0;
+      }
+      const sample = record.sample;
+      const where = `${sample.operation ? ` during ${sample.operation}` : ""}${sample.workspace ? ` on ${sample.workspace}` : ""}`;
+      return {
+        op: "peer_previous_session_unclean",
+        failed: true,
+        totalUs: 0,
+        error: `previous session ended uncleanly at ${MiB(sample.kernelHighWaterBytes)} MB kernel high-water${sample.jsHeapBytes === void 0 ? "" : `, ${MiB(sample.jsHeapBytes)} MB JS heap`}${where}`,
+        previousSessionId: record.sessionId,
+        lastSampleAt: new Date(sample.at).toISOString(),
+        ...memoryFields(sample)
+      };
+    }
+    /** Keep the latest sample: at most once per interval, but at once when the high-water mark grew. */
+    record(sample) {
+      if (__privateGet(this, _ended) || !__privateGet(this, _storage)) return;
+      const now = __privateGet(this, _now).call(this);
+      if (sample.kernelHighWaterBytes <= __privateGet(this, _lastWrittenHighWater) && now - __privateGet(this, _lastWrittenAt) < __privateGet(this, _minIntervalMillis)) return;
+      try {
+        __privateGet(this, _storage).setItem(MEMORY_FORENSICS_KEY, JSON.stringify({ version: 1, sessionId: __privateGet(this, _sessionId), sample }));
+        __privateSet(this, _lastWrittenAt, now);
+        __privateSet(this, _lastWrittenHighWater, sample.kernelHighWaterBytes);
+      } catch {
+      }
+    }
+    /** A clean shutdown (or a page entering the back/forward cache): nothing to report next time. */
+    endCleanly() {
+      __privateSet(this, _ended, true);
+      try {
+        __privateGet(this, _storage)?.removeItem(MEMORY_FORENSICS_KEY);
+      } catch {
+      }
+    }
+    /** The page came back (back/forward cache): record again. */
+    resume() {
+      __privateSet(this, _ended, false);
+      __privateSet(this, _lastWrittenAt, Number.NEGATIVE_INFINITY);
+      __privateSet(this, _lastWrittenHighWater, -1);
+    }
+  };
+  _storage = new WeakMap();
+  _sessionId = new WeakMap();
+  _now = new WeakMap();
+  _minIntervalMillis = new WeakMap();
+  _lastWrittenAt = new WeakMap();
+  _lastWrittenHighWater = new WeakMap();
+  _ended = new WeakMap();
+
+  // ../../node_modules/@bjorn3/browser_wasi_shim/dist/wasi_defs.js
+  var RIGHTS_FD_DATASYNC = 1 << 0;
+  var RIGHTS_FD_READ = 1 << 1;
+  var RIGHTS_FD_SEEK = 1 << 2;
+  var RIGHTS_FD_FDSTAT_SET_FLAGS = 1 << 3;
+  var RIGHTS_FD_SYNC = 1 << 4;
+  var RIGHTS_FD_TELL = 1 << 5;
+  var RIGHTS_FD_WRITE = 1 << 6;
+  var RIGHTS_FD_ADVISE = 1 << 7;
+  var RIGHTS_FD_ALLOCATE = 1 << 8;
+  var RIGHTS_PATH_CREATE_DIRECTORY = 1 << 9;
+  var RIGHTS_PATH_CREATE_FILE = 1 << 10;
+  var RIGHTS_PATH_LINK_SOURCE = 1 << 11;
+  var RIGHTS_PATH_LINK_TARGET = 1 << 12;
+  var RIGHTS_PATH_OPEN = 1 << 13;
+  var RIGHTS_FD_READDIR = 1 << 14;
+  var RIGHTS_PATH_READLINK = 1 << 15;
+  var RIGHTS_PATH_RENAME_SOURCE = 1 << 16;
+  var RIGHTS_PATH_RENAME_TARGET = 1 << 17;
+  var RIGHTS_PATH_FILESTAT_GET = 1 << 18;
+  var RIGHTS_PATH_FILESTAT_SET_SIZE = 1 << 19;
+  var RIGHTS_PATH_FILESTAT_SET_TIMES = 1 << 20;
+  var RIGHTS_FD_FILESTAT_GET = 1 << 21;
+  var RIGHTS_FD_FILESTAT_SET_SIZE = 1 << 22;
+  var RIGHTS_FD_FILESTAT_SET_TIMES = 1 << 23;
+  var RIGHTS_PATH_SYMLINK = 1 << 24;
+  var RIGHTS_PATH_REMOVE_DIRECTORY = 1 << 25;
+  var RIGHTS_PATH_UNLINK_FILE = 1 << 26;
+  var RIGHTS_POLL_FD_READWRITE = 1 << 27;
+  var RIGHTS_SOCK_SHUTDOWN = 1 << 28;
+  var FDFLAGS_APPEND = 1 << 0;
+  var FDFLAGS_DSYNC = 1 << 1;
+  var FDFLAGS_NONBLOCK = 1 << 2;
+  var FDFLAGS_RSYNC = 1 << 3;
+  var FDFLAGS_SYNC = 1 << 4;
+  var FSTFLAGS_ATIM = 1 << 0;
+  var FSTFLAGS_ATIM_NOW = 1 << 1;
+  var FSTFLAGS_MTIM = 1 << 2;
+  var FSTFLAGS_MTIM_NOW = 1 << 3;
+  var OFLAGS_CREAT = 1 << 0;
+  var OFLAGS_DIRECTORY = 1 << 1;
+  var OFLAGS_EXCL = 1 << 2;
+  var OFLAGS_TRUNC = 1 << 3;
+  var EVENTRWFLAGS_FD_READWRITE_HANGUP = 1 << 0;
+  var SUBCLOCKFLAGS_SUBSCRIPTION_CLOCK_ABSTIME = 1 << 0;
+  var RIFLAGS_RECV_PEEK = 1 << 0;
+  var RIFLAGS_RECV_WAITALL = 1 << 1;
+  var ROFLAGS_RECV_DATA_TRUNCATED = 1 << 0;
+  var SDFLAGS_RD = 1 << 0;
+  var SDFLAGS_WR = 1 << 1;
+
+  // ../../node_modules/@bjorn3/browser_wasi_shim/dist/debug.js
+  var Debug = class Debug2 {
+    enable(enabled) {
+      this.log = createLogger(enabled === void 0 ? true : enabled, this.prefix);
+    }
+    get enabled() {
+      return this.isEnabled;
+    }
+    constructor(isEnabled) {
+      this.isEnabled = isEnabled;
+      this.prefix = "wasi:";
+      this.enable(isEnabled);
+    }
+  };
+  function createLogger(enabled, prefix) {
+    if (enabled) {
+      const a = console.log.bind(console, "%c%s", "color: #265BA0", prefix);
+      return a;
+    } else {
+      return () => {
+      };
+    }
+  }
+  var debug = new Debug(false);
+
+  // ../../node_modules/@bjorn3/browser_wasi_shim/dist/fd.js
+  var Inode = class _Inode {
+    static issue_ino() {
+      return _Inode.next_ino++;
+    }
+    static root_ino() {
+      return 0n;
+    }
+    constructor() {
+      this.ino = _Inode.issue_ino();
+    }
+  };
+  Inode.next_ino = 1n;
+
+  // ../../adapter/amortized_memory_file.ts
+  var ADOPT_WRITE_BYTES = 64 * 1024;
+
+  // ../../platform-shells/browser/custody_volume_filesystem.ts
+  var SEGMENT_TARGET_BYTES = 128 * 1024 * 1024;
+  var TAIL_BYTES = 256 * 1024;
+  var SMALL_TAIL_BYTES = 16 * 1024;
+  var COPY_CHUNK_BYTES = 1024 * 1024;
+  var BLOCK_CACHE_BYTES = 8 * 1024 * 1024;
+  var BLOCK_BYTES = 32 * 1024;
+  var CACHE_BLOCKS = BLOCK_CACHE_BYTES / BLOCK_BYTES;
+  var DIRTY_BLOCK_BYTES = 4 * 1024 * 1024;
+  var DIRECT_IO_BYTES = 256 * 1024;
+
+  // ../../platform-shells/browser/custody_volume_store.ts
+  var BASE_EVERY_BYTES = 8 * 1024 * 1024;
+  var COMPACT_MIN_SEGMENT_BYTES = 16 * 1024 * 1024;
+  var COMPACT_BUDGET_BYTES = 64 * 1024 * 1024;
+  var COMPACT_STEP_BYTES = 4 * 1024 * 1024;
+  var COMPACT_URGENT_DEAD_BYTES = 256 * 1024 * 1024;
+  var CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c = n;
+      for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+      table[n] = c >>> 0;
+    }
+    return table;
+  })();
+
+  // ../../platform-shells/browser/custody_store.ts
+  var BROWSER_CUSTODY_CHUNK_BYTES = 4 * 1024 * 1024;
+  var FALLBACK_MEMORY_CAP_BYTES = 192 * 1024 * 1024;
+  var IMPORT_BATCH_BYTES = 16 * 1024 * 1024;
+
+  // ../../platform-shells/browser/custody_tenure.ts
+  var inFront = (presence2) => presence2.visible && presence2.focused && !presence2.leaving;
+
+  // ../../platform-shells/browser/custody_presence.ts
+  function watchTabPresence(page, report, restart) {
+    let leaving = false;
+    let yielded = false;
+    let restarting = false;
+    const current = () => {
+      let focused = false;
+      try {
+        focused = page.document.hasFocus();
+      } catch {
+      }
+      return { visible: page.document.visibilityState === "visible", focused, ...leaving ? { leaving } : {} };
+    };
+    let last = "";
+    const changed = () => {
+      const presence2 = current();
+      if (yielded && inFront(presence2) && !restarting) {
+        restarting = true;
+        restart();
+        return;
+      }
+      const key = JSON.stringify(presence2);
+      if (key === last) return;
+      last = key;
+      report(presence2);
+    };
+    page.document.addEventListener("visibilitychange", changed);
+    page.addEventListener("focus", changed);
+    page.addEventListener("blur", changed);
+    page.addEventListener("pagehide", () => {
+      leaving = true;
+      changed();
+    });
+    page.addEventListener("pageshow", () => {
+      leaving = false;
+      changed();
+    });
+    page.document.addEventListener("freeze", () => {
+      leaving = true;
+      changed();
+    });
+    page.document.addEventListener("resume", () => {
+      leaving = false;
+      changed();
+    });
+    return {
+      current,
+      yielded() {
+        yielded = true;
+        changed();
+      }
+    };
+  }
+
   // ../../platform-shells/browser/worker_page_entry.ts
-  var workerDigest = true ? "961e0de48782cb8f30d35c183811f3c9b93cbe87d04e3f3c7d94445e38d89fa9" : "";
+  var workerDigest = true ? "9bce728d9971046fa9b2414d44e98b97f3433140ebe302e638c8579a98bcbe90" : "";
   var SLOW_OPERATION_MICROS = 1e6;
   var slowOperationsReported = 0;
   var bootStages = [];
@@ -13,10 +296,50 @@
       const perf = JSON.parse(json);
       if (perf.failed !== true && (typeof perf.totalUs !== "number" || perf.totalUs < SLOW_OPERATION_MICROS)) return;
       slowOperationsReported++;
-      report(json);
+      report(JSON.stringify({ ...memoryFields(latestMemory), ...perf }));
+    } catch {
+    }
+  };
+  var latestMemory;
+  var pageStorage = () => {
+    try {
+      return window.localStorage;
     } catch {
+      return void 0;
     }
   };
+  var forensics = new MemoryForensics(pageStorage(), (() => {
+    try {
+      return globalThis.crypto.randomUUID();
+    } catch {
+      return `${Date.now()}-${Math.random()}`;
+    }
+  })());
+  var previousSessionChecked = false;
+  var reportPreviousSession = () => {
+    if (previousSessionChecked) return;
+    previousSessionChecked = true;
+    const previous = forensics.takePreviousUnclean();
+    if (previous) reportSlowOperation(JSON.stringify(previous));
+  };
+  var MEMORY_BREADCRUMB_BYTES = 8 * 1048576;
+  var breadcrumbHighWater = 0;
+  var observeMemory = (sample) => {
+    latestMemory = sample;
+    forensics.record(sample);
+    if (sample.kernelHighWaterBytes < breadcrumbHighWater + MEMORY_BREADCRUMB_BYTES) return;
+    breadcrumbHighWater = sample.kernelHighWaterBytes;
+    const json = JSON.stringify({ op: "peer_memory", ...memoryFields(sample) });
+    console.info("[nomos-memory]", json);
+    try {
+      window.__nomosBreadcrumb?.(json);
+    } catch {
+    }
+  };
+  window.addEventListener?.("pagehide", () => forensics.endCleanly());
+  window.addEventListener?.("pageshow", (event) => {
+    if (event.persisted) forensics.resume();
+  });
   var worker;
   var booting;
   var bootResolve;
@@ -28,6 +351,17 @@
   var closeReject;
   var pending = /* @__PURE__ */ new Map();
   var send = (message) => worker.postMessage(message);
+  var presence;
+  var watchPresence = () => presence ?? (presence = watchTabPresence(
+    window,
+    (current) => {
+      if (worker) send({ kind: "presence", presence: current });
+    },
+    () => {
+      console.info("[nomos-peer-boot] this workspace is open in another tab; reloading to take it back");
+      window.location.reload();
+    }
+  ));
   var fail = (error) => {
     bootReject?.(error);
     bootResolve = void 0;
@@ -64,6 +398,9 @@
           if (totalMs >= 500) reportSlowOperation(JSON.stringify({ op: "custody_checkpoint", totalUs: Math.round(totalMs * 1e3), ...message.timing }));
         }
         break;
+      case "memory":
+        observeMemory(message.sample);
+        break;
       case "kernel-perf":
         console.debug("[nomos-worker]", message.line);
         reportSlowOperation(message.line);
@@ -81,6 +418,7 @@
         worker = void 0;
         break;
       case "disposed":
+        forensics.endCleanly();
         if (message.error) closeReject?.(new Error(message.error));
         else closeResolve?.();
         closeResolve = void 0;
@@ -91,6 +429,11 @@
         booting = void 0;
         lastSnapshot = void 0;
         break;
+      case "custody-yielded":
+        console.info("[nomos-peer-boot] handed this workspace to another tab:", message.reason, message.error ?? "");
+        if (message.error) reportSlowOperation(JSON.stringify({ op: "custody_handover", failed: true, reason: message.reason, error: message.error }));
+        watchPresence().yielded();
+        break;
       case "invoked": {
         const waiting = pending.get(message.id);
         if (!waiting) break;
@@ -127,6 +470,7 @@
     if (closing) return closing.then(() => window.__nomosBootRuntime(base));
     if (worker && !bootResolve) return booting ?? Promise.resolve();
     if (booting) return booting;
+    reportPreviousSession();
     const configured = window.__nomosWorkerUrl;
     if (!configured) return Promise.reject(new Error("Nomos Web Worker URL is not configured"));
     const url = workerDigest ? `${configured}${configured.includes("?") ? "&" : "?"}v=${workerDigest}` : configured;
@@ -150,13 +494,7 @@
         bootResolve = resolve;
         bootReject = reject;
       });
-      let reloaded = false;
-      try {
-        const navigation = performance.getEntriesByType("navigation")[0];
-        reloaded = navigation?.type === "reload" || navigation?.type === "back_forward";
-      } catch {
-      }
-      send({ kind: "boot", base, reloaded });
+      send({ kind: "boot", base, presence: watchPresence().current() });
     } catch (error) {
       fail(error instanceof Error ? error : new Error(String(error)));
       return Promise.reject(error);