@retaw106/mmc-pi 0.0.0-stage → 1.2.2

package/dist/index-wv28nczk.js

@@ -0,0 +1,464 @@
+// ../plugin/src/shared/sqlite.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+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;
+  }
+}
+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 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}`);
+      }
+    }
+  }
+}
+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, prepareCachedStatement, withSqliteBackgroundWriter, withSqliteTransformPass, withoutSqliteTransformPass, isTransientSqliteError, withPrivilegedWriter };