@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/index-e1q8002h.js

@@ -0,0 +1,16 @@
+import {
+  log
+} from "./index-qbkzdkk0.js";
+
+// src/shared/write-transaction-timing.ts
+var SLOW_WRITE_TRANSACTION_THRESHOLD_MS = 1000;
+function logSlowWriteTransaction(site, startedAt, thresholdMs = SLOW_WRITE_TRANSACTION_THRESHOLD_MS, completedAtMs = performance.now()) {
+  try {
+    const durationMs = completedAtMs - startedAt;
+    if (durationMs < thresholdMs)
+      return;
+    log(`[magic-context] slow write transaction: site=${site} held=${durationMs.toFixed(1)}ms`);
+  } catch {}
+}
+
+export { logSlowWriteTransaction };

package/dist/index-fg34g6a5.js

@@ -0,0 +1,584 @@
+// src/shared/sqlite.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { statSync } from "node:fs";
+var reportSlowPrivilegedWrite;
+function registerSlowWriteReporter(reporter) {
+  reportSlowPrivilegedWrite = reporter;
+}
+var sqliteDiagnosticSink;
+function registerSqliteDiagnosticSink(sink) {
+  sqliteDiagnosticSink = sink;
+}
+function reportSqliteDiagnostic(message) {
+  try {
+    sqliteDiagnosticSink?.(`[magic-context] ${message}`);
+  } catch {}
+}
+function detectSqliteRuntime() {
+  const hasBunVersion = typeof process !== "undefined" && typeof process.versions?.bun === "string";
+  const hasBunGlobal = typeof globalThis !== "undefined" && typeof globalThis.Bun !== "undefined";
+  return hasBunVersion || hasBunGlobal ? "Bun" : "Node.js";
+}
+var bunSpec = "bun:" + "sqlite";
+var nodeSpec = "node:" + "sqlite";
+async function importSqliteModule(specifier) {
+  return await import(specifier);
+}
+function isModuleNotFoundError(error, specifier) {
+  const candidate = error;
+  const code = typeof candidate?.code === "string" ? candidate.code : "";
+  const name = typeof candidate?.name === "string" ? candidate.name : "";
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  const details = `${code} ${name} ${message}`.toLowerCase();
+  const mentionsSpecifier = details.includes(specifier.toLowerCase());
+  if (!mentionsSpecifier)
+    return false;
+  return code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNKNOWN_BUILTIN_MODULE" || code === "MODULE_NOT_FOUND" || name === "ResolveMessage" || details.includes("module not found") || details.includes("cannot find module") || details.includes("cannot find package") || details.includes("no such built-in module");
+}
+
+class SqliteRuntimeUnavailableError extends Error {
+  runtime;
+  specifier;
+  constructor(runtime, specifier, cause) {
+    const requirement = specifier === nodeSpec ? "Requires Node.js >= 24, or Bun with bun:sqlite — this Bun build lacks node:sqlite." : "Requires Bun with bun:sqlite, or Node.js >= 24 — this Bun build lacks bun:sqlite.";
+    super(`Magic Context detected ${runtime}, but could not load ${specifier}. ${requirement}`, { cause });
+    this.name = "SqliteRuntimeUnavailableError";
+    this.runtime = runtime;
+    this.specifier = specifier;
+  }
+}
+async function loadSqliteModule(runtime = detectSqliteRuntime(), importer = importSqliteModule) {
+  const specifier = runtime === "Bun" ? bunSpec : nodeSpec;
+  try {
+    return await importer(specifier);
+  } catch (error) {
+    if (isModuleNotFoundError(error, specifier)) {
+      throw new SqliteRuntimeUnavailableError(runtime, specifier, error);
+    }
+    throw error;
+  }
+}
+var detectedRuntime = detectSqliteRuntime();
+var isBun = detectedRuntime === "Bun";
+var sqliteModule = await loadSqliteModule(detectedRuntime);
+var DatabaseImpl = isBun ? sqliteModule.Database : buildNodeSqliteDatabaseClass(sqliteModule.DatabaseSync);
+var trackedSqliteConnections = new Map;
+var nextSqliteConnectionSequence = 1;
+function installTransactionRouting(db, readonly) {
+  const nativeExec = db.exec.bind(db);
+  Object.defineProperty(db, "exec", {
+    configurable: true,
+    writable: true,
+    value: (sql) => {
+      if (/^\s*BEGIN\s+(?:IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*;?\s*$/i.test(sql)) {
+        openWriterTransactions.delete(db);
+        if (transformPassScope.getStore()?.active || backgroundWriterScope.getStore())
+          acquireShort(db, () => nativeExec(sql), sql.trim());
+        else
+          nativeExec(sql);
+        return db;
+      }
+      if (WRITER_TRANSACTION_END.test(sql) && openWriterTransactions.has(db))
+        return endWriterTransaction(db, () => nativeExec(sql), sql);
+      if (!/^\s*(?:SELECT|EXPLAIN|PRAGMA|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(sql))
+        return withAutocommitTimeout(db, () => nativeExec(sql));
+      return nativeExec(sql);
+    }
+  });
+  const nativePrepare = db.prepare.bind(db);
+  Object.defineProperty(db, "prepare", {
+    configurable: true,
+    writable: true,
+    value: (sql) => {
+      const statement = nativePrepare(sql);
+      if (!readonly && !/^\s*(?:SELECT|EXPLAIN|PRAGMA)\b/i.test(sql)) {
+        for (const method of ["run", "get", "all"]) {
+          const execute = statement[method].bind(statement);
+          Object.defineProperty(statement, method, {
+            configurable: true,
+            value: (...args) => withAutocommitTimeout(db, () => execute(...args))
+          });
+        }
+      }
+      return statement;
+    }
+  });
+  Object.defineProperty(db, "transaction", {
+    configurable: true,
+    writable: true,
+    value: (fn) => {
+      const make = (mode) => function(...args) {
+        const nested = isInTransaction(db);
+        const savepoint = "mc_tx_sp";
+        db.exec(nested ? `SAVEPOINT ${savepoint}` : `BEGIN ${mode}`);
+        try {
+          const result = fn.apply(this, args);
+          db.exec(nested ? `RELEASE ${savepoint}` : "COMMIT");
+          return result;
+        } catch (error) {
+          if (isInTransaction(db)) {
+            if (nested) {
+              db.exec(`ROLLBACK TO ${savepoint}`);
+              db.exec(`RELEASE ${savepoint}`);
+            } else
+              db.exec("ROLLBACK");
+          }
+          throw error;
+        }
+      };
+      const defaultTransaction = make(readonly ? "DEFERRED" : "IMMEDIATE");
+      const variants = {
+        default: defaultTransaction,
+        deferred: make("DEFERRED"),
+        immediate: make("IMMEDIATE"),
+        exclusive: make("EXCLUSIVE"),
+        database: db
+      };
+      for (const transaction of [
+        variants.default,
+        variants.deferred,
+        variants.immediate,
+        variants.exclusive
+      ]) {
+        Object.assign(transaction, variants);
+      }
+      return defaultTransaction;
+    }
+  });
+}
+function trackSqliteConnection(db, filename, options) {
+  const originalClose = db.close.bind(db);
+  const sequence = nextSqliteConnectionSequence++;
+  const metadata = {
+    sequence,
+    filename: typeof filename === "string" ? filename : Buffer.isBuffer(filename) ? "<buffer>" : ":memory:",
+    readonly: Boolean(options) && typeof options === "object" && (options.readonly === true || options.readOnly === true)
+  };
+  installTransactionRouting(db, metadata.readonly);
+  Object.defineProperty(db, "close", {
+    configurable: true,
+    value: (...args) => {
+      try {
+        return originalClose(...args);
+      } finally {
+        trackedSqliteConnections.delete(sequence);
+      }
+    }
+  });
+  trackedSqliteConnections.set(sequence, {
+    ...metadata,
+    reference: new WeakRef(db)
+  });
+  const prepare = db.prepare.bind(db);
+  Object.defineProperty(db, "prepare", {
+    configurable: true,
+    writable: true,
+    value: (sql) => ownPreparedStatement(db, prepare(sql))
+  });
+  return db;
+}
+var TrackedDatabase = new Proxy(DatabaseImpl, {
+  construct(target, args) {
+    const db = Reflect.construct(target, args, target);
+    return trackSqliteConnection(db, args[0], args[1]);
+  }
+});
+function buildNodeSqliteDatabaseClass(DatabaseSync) {
+
+  class NodeSqliteDatabase extends DatabaseSync {
+    constructor(filename, options) {
+      const translated = { ...options };
+      if (options && "readonly" in options) {
+        translated.readOnly = options.readonly;
+        delete translated.readonly;
+      }
+      super(typeof filename === "string" ? filename : ":memory:", translated);
+    }
+    prepare(sql) {
+      const stmt = super.prepare(sql);
+      for (const method of ["run", "get", "all"]) {
+        const original = stmt[method].bind(stmt);
+        stmt[method] = (...args) => args.length === 1 && Array.isArray(args[0]) ? original(...args[0]) : original(...args);
+      }
+      return stmt;
+    }
+  }
+  return NodeSqliteDatabase;
+}
+var Database = TrackedDatabase;
+function pragmaValue(db, name) {
+  const row = db.prepare(`PRAGMA ${name}`).get();
+  if (!row)
+    return;
+  return row[name] ?? Object.values(row)[0];
+}
+function pragmaNumber(db, name) {
+  try {
+    const value = pragmaValue(db, name);
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function pragmaString(db, name) {
+  try {
+    const value = pragmaValue(db, name);
+    return typeof value === "string" ? value : null;
+  } catch {
+    return null;
+  }
+}
+function sqliteSidecarBytes(filename, suffix) {
+  if (filename === ":memory:" || filename === "<buffer>")
+    return 0;
+  try {
+    return statSync(`${filename}${suffix}`).size;
+  } catch (error) {
+    return error.code === "ENOENT" ? 0 : null;
+  }
+}
+function fts5TableCount(db) {
+  try {
+    const row = db.prepare("SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND sql LIKE '%USING fts5%'").get();
+    return typeof row?.count === "number" ? row.count : null;
+  } catch {
+    return null;
+  }
+}
+function getSqliteMemoryStats() {
+  const connections = [];
+  for (const [sequence, tracked] of trackedSqliteConnections) {
+    const db = tracked.reference.deref();
+    if (!db) {
+      trackedSqliteConnections.delete(sequence);
+      continue;
+    }
+    const pageSize = pragmaNumber(db, "page_size");
+    const cacheSize = pragmaNumber(db, "cache_size");
+    const cacheSizeUnit = cacheSize === null ? null : cacheSize < 0 ? "kib" : "pages";
+    const cacheUpperBoundBytes = cacheSize === null ? null : cacheSize < 0 ? Math.abs(cacheSize) * 1024 : pageSize === null ? null : cacheSize * pageSize;
+    connections.push({
+      sequence: tracked.sequence,
+      filename: tracked.filename,
+      readonly: tracked.readonly,
+      pageSize,
+      pageCount: pragmaNumber(db, "page_count"),
+      freelistCount: pragmaNumber(db, "freelist_count"),
+      cacheSize,
+      cacheSizeUnit,
+      cacheUpperBoundBytes,
+      mmapSizeBytes: pragmaNumber(db, "mmap_size"),
+      walFileBytes: sqliteSidecarBytes(tracked.filename, "-wal"),
+      shmFileBytes: sqliteSidecarBytes(tracked.filename, "-shm"),
+      fts5TableCount: fts5TableCount(db),
+      journalMode: pragmaString(db, "journal_mode")
+    });
+  }
+  const sumKnown = (select) => connections.reduce((sum, connection) => sum + (select(connection) ?? 0), 0);
+  return {
+    connectionCount: connections.length,
+    cacheUpperBoundBytes: sumKnown((connection) => connection.cacheUpperBoundBytes),
+    mmapUpperBoundBytes: sumKnown((connection) => connection.mmapSizeBytes),
+    walFileBytes: sumKnown((connection) => connection.walFileBytes),
+    shmFileBytes: sumKnown((connection) => connection.shmFileBytes),
+    sqliteStatusApi: "unavailable",
+    connections
+  };
+}
+var statementOwners = new WeakMap;
+var FIRST_PRUNE_AT = 256;
+function ownPreparedStatement(db, statement) {
+  const finalizable = statement;
+  if (typeof finalizable.finalize !== "function")
+    return statement;
+  let owner = statementOwners.get(db);
+  if (!owner) {
+    const references = new Set;
+    owner = { references, registered: new WeakSet, pruneAt: FIRST_PRUNE_AT };
+    statementOwners.set(db, owner);
+    const close = db.close.bind(db);
+    Object.defineProperty(db, "close", {
+      configurable: true,
+      writable: true,
+      value: (...args) => {
+        let failure;
+        for (const reference of references) {
+          try {
+            reference.deref()?.finalize();
+          } catch (error) {
+            failure ??= error;
+          }
+        }
+        references.clear();
+        const result = close(...args);
+        if (failure)
+          throw failure;
+        return result;
+      }
+    });
+  }
+  if (!owner.registered.has(finalizable)) {
+    if (owner.references.size >= owner.pruneAt) {
+      for (const reference of owner.references) {
+        if (reference.deref() === undefined)
+          owner.references.delete(reference);
+      }
+      owner.pruneAt = Math.max(FIRST_PRUNE_AT, owner.references.size * 2);
+    }
+    owner.references.add(new WeakRef(finalizable));
+    owner.registered.add(finalizable);
+  }
+  return statement;
+}
+function prepareCachedStatement(db, sql) {
+  return ownPreparedStatement(db, db.prepare(sql));
+}
+var privilegeDepth = new WeakMap;
+var transformPassScope = new AsyncLocalStorage;
+var admissionScope = new AsyncLocalStorage;
+var backgroundWriterScope = new AsyncLocalStorage;
+function withSqliteBackgroundWriter(operation) {
+  return backgroundWriterScope.run(true, operation);
+}
+function withSqliteTransformPass(operation) {
+  const existing = transformPassScope.getStore();
+  if (existing?.active)
+    return operation();
+  const lease = { active: true, remainingWaitMs: FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS };
+  return transformPassScope.run(lease, () => {
+    try {
+      const result = operation();
+      if (result && typeof result.then === "function") {
+        return Promise.resolve(result).finally(() => {
+          lease.active = false;
+        });
+      }
+      lease.active = false;
+      return result;
+    } catch (error) {
+      lease.active = false;
+      throw error;
+    }
+  });
+}
+function withoutSqliteTransformPass(operation) {
+  return transformPassScope.run(undefined, operation);
+}
+function isTransientSqliteError(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const value = error;
+  return typeof value.code === "string" && /^(SQLITE_BUSY|SQLITE_LOCKED)(_|$)/.test(value.code) || typeof value.errcode === "number" && [5, 6].includes(value.errcode & 255);
+}
+
+class SqliteAcquisitionBusyError extends Error {
+  code = "SQLITE_BUSY";
+  stage;
+  constructor(cause, stage = "BEGIN IMMEDIATE") {
+    super("SQLite writer acquisition remained busy", { cause });
+    this.name = "SqliteAcquisitionBusyError";
+    this.stage = stage;
+  }
+}
+var SHORT_BUSY_TIMEOUT_MS = 25;
+var FOREGROUND_IN_PASS_BUSY_TIMEOUT_MS = 250;
+var FOREGROUND_ACQUISITION_BUDGET_MS = 16500;
+var SLOW_WRITER_LOG_MS = 250;
+var WRITER_TRANSACTION_END = /^\s*(?:COMMIT|END|ROLLBACK)(?:\s+TRANSACTION)?\s*;?\s*$/i;
+var writerAcquisitionScope = new AsyncLocalStorage;
+var openWriterTransactions = new WeakMap;
+function foregroundWaitLease() {
+  const lease = transformPassScope.getStore();
+  return lease?.active && !admissionScope.getStore() && !backgroundWriterScope.getStore() ? lease : undefined;
+}
+function withAutocommitTimeout(db, operation) {
+  const lease = foregroundWaitLease();
+  if (isInTransaction(db) || !lease && !backgroundWriterScope.getStore())
+    return operation();
+  const previous = pragmaNumber(db, "busy_timeout");
+  db.exec(`PRAGMA busy_timeout=${lease ? Math.floor(lease.remainingWaitMs) : SHORT_BUSY_TIMEOUT_MS}`);
+  const started = performance.now();
+  try {
+    return operation();
+  } catch (error) {
+    if (lease && isTransientSqliteError(error))
+      throw new SqliteAcquisitionBusyError(error, "autocommit");
+    throw error;
+  } finally {
+    if (lease)
+      lease.remainingWaitMs = Math.max(0, lease.remainingWaitMs - (performance.now() - started));
+    if (previous !== null)
+      db.exec(`PRAGMA busy_timeout=${previous}`);
+  }
+}
+function acquireShort(db, acquire, site) {
+  const started = performance.now();
+  const previous = pragmaNumber(db, "busy_timeout");
+  const outer = writerAcquisitionScope.getStore();
+  const owner = outer && !outer.claimed ? outer : undefined;
+  if (owner)
+    owner.claimed = true;
+  const writerSite = owner?.site ?? site;
+  const lane = owner?.lane ?? (transformPassScope.getStore()?.active ? "foreground" : "background");
+  let acquiredAt;
+  try {
+    const lease = foregroundWaitLease();
+    const timeout = lease ? Math.floor(lease.remainingWaitMs) : SHORT_BUSY_TIMEOUT_MS;
+    db.exec(`PRAGMA busy_timeout=${timeout}`);
+    acquire();
+    acquiredAt = performance.now();
+  } catch (error) {
+    if (transformPassScope.getStore()?.active && isTransientSqliteError(error))
+      throw new SqliteAcquisitionBusyError(error, site);
+    throw error;
+  } finally {
+    const attemptMs = (acquiredAt ?? performance.now()) - started;
+    const lease = foregroundWaitLease();
+    if (lease)
+      lease.remainingWaitMs = Math.max(0, lease.remainingWaitMs - attemptMs);
+    if (previous !== null)
+      db.exec(`PRAGMA busy_timeout=${previous}`);
+    if (acquiredAt !== undefined) {
+      openWriterTransactions.set(db, {
+        site: writerSite,
+        lane,
+        acquireMs: acquiredAt - (owner?.startedAt ?? started),
+        attempts: owner?.attempts ?? 1,
+        acquiredAt
+      });
+    } else if (attemptMs >= SLOW_WRITER_LOG_MS) {
+      reportSqliteDiagnostic(`sqlite writer site=${writerSite} lane=${lane} acquire_ms=${Math.round(attemptMs)} attempts=${owner?.attempts ?? 1} outcome=busy`);
+    }
+  }
+}
+function endWriterTransaction(db, end, sql) {
+  let ended = false;
+  try {
+    const result = end();
+    ended = true;
+    return result;
+  } finally {
+    const open = openWriterTransactions.get(db);
+    if (open && !isInTransaction(db)) {
+      openWriterTransactions.delete(db);
+      const holdMs = performance.now() - open.acquiredAt;
+      if (open.acquireMs >= SLOW_WRITER_LOG_MS || holdMs >= SLOW_WRITER_LOG_MS) {
+        const outcome = /^\s*ROLLBACK/i.test(sql) ? "rolled_back" : ended ? "committed" : "failed";
+        reportSqliteDiagnostic(`sqlite writer site=${open.site} lane=${open.lane} acquire_ms=${Math.round(open.acquireMs)} hold_ms=${Math.round(holdMs)} attempts=${open.attempts} outcome=${outcome}`);
+      }
+    }
+  }
+}
+async function beginSqliteWriterAsync(db, site) {
+  const started = performance.now();
+  let attempts = 0;
+  for (;; ) {
+    attempts++;
+    try {
+      const acquisition = {
+        site,
+        lane: "background",
+        startedAt: started,
+        attempts,
+        claimed: false
+      };
+      writerAcquisitionScope.run(acquisition, () => withSqliteBackgroundWriter(() => db.exec("BEGIN IMMEDIATE")));
+      return performance.now();
+    } catch (error) {
+      if (!isTransientSqliteError(error))
+        throw error;
+      const elapsed = performance.now() - started;
+      if (elapsed >= FOREGROUND_ACQUISITION_BUDGET_MS) {
+        reportSqliteDiagnostic(`sqlite writer site=${site} lane=background acquire_ms=${Math.round(elapsed)} attempts=${attempts} outcome=busy`);
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, Math.min(attempts === 1 ? 500 : 1000, FOREGROUND_ACQUISITION_BUDGET_MS - elapsed)));
+    }
+  }
+}
+async function withAsyncPrivilegedWriter(db, operation) {
+  const started = performance.now();
+  let attempts = 0;
+  for (;; ) {
+    attempts++;
+    try {
+      const acquisition = {
+        site: "privileged_writer",
+        lane: "foreground",
+        startedAt: started,
+        attempts,
+        claimed: false
+      };
+      return admissionScope.run(true, () => withSqliteTransformPass(() => writerAcquisitionScope.run(acquisition, () => withPrivilegedWriter(db, operation))));
+    } catch (error) {
+      if (!(error instanceof SqliteAcquisitionBusyError))
+        throw error;
+      const elapsed = performance.now() - started;
+      if (elapsed >= FOREGROUND_ACQUISITION_BUDGET_MS) {
+        reportSqliteDiagnostic(`sqlite writer site=privileged_writer lane=foreground acquire_ms=${Math.round(elapsed)} attempts=${attempts} outcome=busy`);
+        throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, Math.min(attempts === 1 ? 500 : 1000, FOREGROUND_ACQUISITION_BUDGET_MS - elapsed)));
+    }
+  }
+}
+function isInTransaction(db) {
+  const candidate = db;
+  return candidate.inTransaction === true || candidate.isTransaction === true;
+}
+function withPrivilegedWriter(db, operation) {
+  const previousDepth = privilegeDepth.get(db) ?? 0;
+  const nested = isInTransaction(db);
+  const savepoint = "mc_privilege_scope";
+  let transactionStartedAt;
+  if (nested) {
+    db.exec(`SAVEPOINT ${savepoint}`);
+  } else {
+    try {
+      db.exec("BEGIN IMMEDIATE");
+    } catch (error) {
+      if (transformPassScope.getStore()?.active && isTransientSqliteError(error))
+        throw new SqliteAcquisitionBusyError(error);
+      throw error;
+    }
+    transactionStartedAt = performance.now();
+  }
+  privilegeDepth.set(db, previousDepth + 1);
+  try {
+    db.prepare("INSERT INTO context_privilege_state(id, enabled) VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET enabled = 1").run();
+    const result = operation();
+    if (previousDepth === 0) {
+      db.prepare("UPDATE context_privilege_state SET enabled = 0 WHERE id = 1").run();
+    }
+    if (nested) {
+      db.exec(`RELEASE ${savepoint}`);
+    } else {
+      db.exec("COMMIT");
+      if (transactionStartedAt !== undefined) {
+        reportSlowPrivilegedWrite?.("privileged_writer", transactionStartedAt);
+      }
+    }
+    if (previousDepth > 0)
+      privilegeDepth.set(db, previousDepth);
+    else
+      privilegeDepth.delete(db);
+    return result;
+  } catch (error) {
+    try {
+      if (nested) {
+        db.exec(`ROLLBACK TO ${savepoint}`);
+        db.exec(`RELEASE ${savepoint}`);
+      } else {
+        db.exec("ROLLBACK");
+      }
+    } finally {
+      if (previousDepth > 0)
+        privilegeDepth.set(db, previousDepth);
+      else
+        privilegeDepth.delete(db);
+    }
+    throw error;
+  }
+}
+
+export { registerSlowWriteReporter, registerSqliteDiagnosticSink, detectSqliteRuntime, Database, getSqliteMemoryStats, prepareCachedStatement, withSqliteBackgroundWriter, withSqliteTransformPass, withoutSqliteTransformPass, isTransientSqliteError, SqliteAcquisitionBusyError, beginSqliteWriterAsync, withAsyncPrivilegedWriter, withPrivilegedWriter };

package/dist/index-jdxxq8cz.js

@@ -0,0 +1,99 @@
+// src/shared/rpc-notifications.ts
+var queue = [];
+var nextNotificationId = 1;
+var sinks = new Set;
+function registerNotificationSink2(sink) {
+  sinks.add(sink);
+  return () => {
+    sinks.delete(sink);
+  };
+}
+function notificationMatchesSink(notification, sink) {
+  if (notification.sessionId === undefined)
+    return true;
+  if (sink.sessionId !== undefined)
+    return notification.sessionId === sink.sessionId;
+  return sink.protocol !== 2;
+}
+function pushNotification2(type, payload, sessionId) {
+  const notification = { id: nextNotificationId++, type, payload, sessionId };
+  queue.push(notification);
+  for (const sink of sinks) {
+    if (!notificationMatchesSink(notification, sink))
+      continue;
+    try {
+      sink.send(notification);
+    } catch {}
+  }
+  if (queue.length > 100) {
+    const reservedIds = new Set;
+    const reservedScopes = new Set;
+    for (let i = queue.length - 1;i >= 0 && reservedScopes.size < 25; i -= 1) {
+      const candidate = queue[i];
+      const scope = candidate.sessionId ?? "\x00global";
+      if (reservedScopes.has(scope))
+        continue;
+      reservedScopes.add(scope);
+      reservedIds.add(candidate.id);
+    }
+    const evictionIndex = queue.findIndex((candidate) => !reservedIds.has(candidate.id));
+    queue.splice(evictionIndex >= 0 ? evictionIndex : 0, 1);
+  }
+}
+function acknowledgeNotifications2(ids) {
+  const acknowledged = new Set(ids.filter((id) => Number.isSafeInteger(id) && id > 0));
+  if (acknowledged.size === 0)
+    return;
+  queue = queue.filter((notification) => !acknowledged.has(notification.id));
+}
+function cursor(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function drainNotifications2(lastReceivedId = 0, sessionId, options = {}) {
+  const sessionCursor = cursor(lastReceivedId);
+  if (options.globalOnly) {
+    queue = queue.filter((notification) => notification.sessionId !== undefined || notification.id > sessionCursor);
+    return queue.filter((notification) => notification.sessionId === undefined && notification.id > sessionCursor);
+  }
+  if (options.sessionOnly) {
+    if (sessionId === undefined)
+      return [];
+    queue = queue.filter((notification) => notification.sessionId !== sessionId || notification.id > sessionCursor);
+    return queue.filter((notification) => notification.sessionId === sessionId && notification.id > sessionCursor);
+  }
+  if (sessionId !== undefined && options.globalLastReceivedId !== undefined) {
+    const globalCursor = cursor(options.globalLastReceivedId);
+    queue = queue.filter((notification) => {
+      if (notification.sessionId === undefined)
+        return notification.id > globalCursor;
+      if (notification.sessionId === sessionId)
+        return notification.id > sessionCursor;
+      return true;
+    });
+    return queue.filter((notification) => {
+      if (notification.sessionId === undefined)
+        return notification.id > globalCursor;
+      return notification.sessionId === sessionId && notification.id > sessionCursor;
+    });
+  }
+  const matchesClient = (notification) => sessionId === undefined || notification.sessionId === undefined || notification.sessionId === sessionId;
+  if (sessionCursor > 0) {
+    queue = queue.filter((notification) => !(notification.id <= sessionCursor && matchesClient(notification)));
+  }
+  return queue.filter((notification) => notification.id > sessionCursor && matchesClient(notification));
+}
+function isTuiConnected2(sessionId) {
+  if (sinks.size === 0)
+    return false;
+  if (sessionId === undefined)
+    return true;
+  for (const sink of sinks) {
+    if (sink.sessionId === sessionId)
+      return true;
+    if (sink.sessionId === undefined && sink.protocol !== 2)
+      return true;
+  }
+  return false;
+}
+
+export { registerNotificationSink2, pushNotification2, acknowledgeNotifications2, drainNotifications2, isTuiConnected2 };