negotium 0.2.19 → 0.2.20

package/dist/runtime/src/storage/self-schedules.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { db } from "#storage/forum-db";
 import { TURN_LEASE_STALE_MS } from "#storage/runtime-leases";
 import { TOPIC_MAINTENANCE_STALE_MS } from "#storage/runtime-topic-state";
+import { registerStorageSchemaInitializer } from "#storage/storage-host";
 
 export type SelfScheduleStatus = "pending" | "running";
 
@@ -33,30 +34,37 @@ interface SelfScheduleRow {
   running_query_id: string | null;
 }
 
-db.exec(`
-  CREATE TABLE IF NOT EXISTS runtime_self_schedules (
-    id TEXT PRIMARY KEY,
-    topic_id TEXT NOT NULL,
-    user_id TEXT NOT NULL,
-    message TEXT NOT NULL,
-    deliver_at INTEGER NOT NULL,
-    created_at INTEGER NOT NULL,
-    updated_at INTEGER NOT NULL,
-    status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running')),
-    claimed_by TEXT,
-    claimed_at INTEGER,
-    running_query_id TEXT
-  )
-`);
-db.exec(`
-  CREATE UNIQUE INDEX IF NOT EXISTS idx_runtime_self_schedules_one_pending
-  ON runtime_self_schedules(topic_id)
-  WHERE status = 'pending'
-`);
-db.exec(`
-  CREATE INDEX IF NOT EXISTS idx_runtime_self_schedules_due
-  ON runtime_self_schedules(status, deliver_at)
-`);
+// Registered rather than executed at import time. A bare top-level `db.exec`
+// resolves the storage connection the moment this module is imported, which for
+// an embedding host is before `configureStorageHost()` has run — Negotium then
+// opens its own database in the default state directory, caches it, and every
+// later caller silently keeps using it instead of the host's.
+registerStorageSchemaInitializer((database) => {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS runtime_self_schedules (
+      id TEXT PRIMARY KEY,
+      topic_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      message TEXT NOT NULL,
+      deliver_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running')),
+      claimed_by TEXT,
+      claimed_at INTEGER,
+      running_query_id TEXT
+    )
+  `);
+  database.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_runtime_self_schedules_one_pending
+    ON runtime_self_schedules(topic_id)
+    WHERE status = 'pending'
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_runtime_self_schedules_due
+    ON runtime_self_schedules(status, deliver_at)
+  `);
+});
 
 function rowToSchedule(row: SelfScheduleRow): SelfSchedule {
   return {

package/dist/runtime/src/storage/storage-host.ts

@@ -14,28 +14,73 @@ export type {
   StorageTransaction,
 } from "#storage/storage-contract";
 
-let configuredHost: Readonly<StorageHostConfig> = {};
 type InternalStorageDatabase = InstanceType<typeof Database>;
 type OwnedStorageDatabase = InternalStorageDatabase & { close(): void };
-let fallbackDatabase: OwnedStorageDatabase | null = null;
-let fallbackDatabasePath: string | null = null;
 
 interface StorageHostFrame {
   active: boolean;
   patch: Readonly<StorageHostConfig>;
 }
 
-const storageHostFrames: StorageHostFrame[] = [];
-
 type StorageSchemaInitializer = (database: InternalStorageDatabase) => void;
 interface RegisteredSchemaInitializer {
   initialize: StorageSchemaInitializer;
   priority: number;
 }
 
-const schemaInitializers: RegisteredSchemaInitializer[] = [];
-const initializedSchemas = new WeakMap<InternalStorageDatabase, Set<StorageSchemaInitializer>>();
-const initializingDatabases = new WeakSet<InternalStorageDatabase>();
+interface StorageHostState {
+  configuredHost: Readonly<StorageHostConfig>;
+  fallbackDatabase: OwnedStorageDatabase | null;
+  fallbackDatabasePath: string | null;
+  frames: StorageHostFrame[];
+  schemaInitializers: RegisteredSchemaInitializer[];
+  initializedSchemas: WeakMap<InternalStorageDatabase, Set<StorageSchemaInitializer>>;
+  initializingDatabases: WeakSet<InternalStorageDatabase>;
+}
+
+/**
+ * Which database an embedded Negotium uses is a property of the *process*, so
+ * the state deciding it is keyed off a registered symbol rather than held in
+ * module scope.
+ *
+ * Module scope would be equivalent only if every caller resolved to the same
+ * module instance, and in the published package they do not:
+ * `build-negotium-package.ts` emits most public entrypoints as independent
+ * graphs, so each gets a private copy of this file. A host that configured
+ * `negotium/storage` therefore left `negotium/agent-helpers` unconfigured, and
+ * that copy opened a second database under the default state directory — with
+ * no error, since both files are valid and writable.
+ *
+ * Merging those entrypoints into one graph looks tidier and does cut ~3MB from
+ * `dist`, but Bun 1.2.15 (the pinned version) emits a shared chunk's export
+ * list twice and the result is invalid ESM — "Cannot export a duplicate name".
+ * That is bundler output with no counterpart in this source, so there is
+ * nothing to de-duplicate here; it is fixed in Bun 1.3.14. Until the floor
+ * moves, correctness cannot depend on how the package is chunked.
+ */
+const STORAGE_HOST_STATE = Symbol.for("negotium.storage-host.state.v1");
+
+function storageState(): StorageHostState {
+  const holder = globalThis as typeof globalThis & { [STORAGE_HOST_STATE]?: StorageHostState };
+  const existing = holder[STORAGE_HOST_STATE];
+  if (existing) return existing;
+  const created: StorageHostState = {
+    configuredHost: {},
+    fallbackDatabase: null,
+    fallbackDatabasePath: null,
+    frames: [],
+    schemaInitializers: [],
+    initializedSchemas: new WeakMap(),
+    initializingDatabases: new WeakSet(),
+  };
+  Object.defineProperty(holder, STORAGE_HOST_STATE, {
+    value: created,
+    enumerable: false,
+    writable: false,
+    configurable: false,
+  });
+  return created;
+}
 
 function envPath(name: string, fallback: string): string {
   const value = process.env[name]?.trim();
@@ -114,41 +159,55 @@ export function initializeDatabase(database: InternalStorageDatabase): void {
 
 function defaultDatabase(): InternalStorageDatabase {
   const path = defaultSessionsDatabasePath();
-  if (fallbackDatabase && fallbackDatabasePath === path) return fallbackDatabase;
-  if (fallbackDatabase) fallbackDatabase.close();
+  const state = storageState();
+  if (state.fallbackDatabase && state.fallbackDatabasePath === path) return state.fallbackDatabase;
+  if (state.fallbackDatabase) state.fallbackDatabase.close();
   mkdirSync(dirname(path), { recursive: true });
-  fallbackDatabase = new Database(path, { create: true }) as unknown as OwnedStorageDatabase;
-  fallbackDatabasePath = path;
-  initializeDatabase(fallbackDatabase);
-  return fallbackDatabase;
+  state.fallbackDatabase = new Database(path, { create: true }) as unknown as OwnedStorageDatabase;
+  state.fallbackDatabasePath = path;
+  initializeDatabase(state.fallbackDatabase);
+  return state.fallbackDatabase;
 }
 
 export function resolveStorageDatabase(): InternalStorageDatabase {
-  return (configuredHost.database ?? defaultDatabase()) as InternalStorageDatabase;
+  return (storageState().configuredHost.database ?? defaultDatabase()) as InternalStorageDatabase;
+}
+
+/**
+ * The host-injected connection, or null when Negotium owns its own store.
+ *
+ * Unlike {@link resolveStorageDatabase} this never opens anything. Callers that
+ * manage their own short-lived connections need to know whether a host store
+ * exists *before* deciding to open one by path: opening it anyway is how an
+ * embedded Negotium ends up writing half its state into the host's database and
+ * the other half into `~/.negotium`, with nothing reporting an error.
+ */
+export function configuredStorageDatabase(): InternalStorageDatabase | null {
+  return (storageState().configuredHost.database as InternalStorageDatabase | undefined) ?? null;
 }
 
 export function resolveStorageDataDir(): string {
-  return configuredHost.dataDir ?? defaultDataDir();
+  return storageState().configuredHost.dataDir ?? defaultDataDir();
 }
 
 export function resolveStorageLogDir(): string {
-  return configuredHost.logDir ?? defaultLogDir();
+  return storageState().configuredHost.logDir ?? defaultLogDir();
 }
 
 export function resolveStorageSessionAsksDir(): string {
-  return configuredHost.sessionAsksDir ?? defaultSessionAsksDir();
+  return storageState().configuredHost.sessionAsksDir ?? defaultSessionAsksDir();
 }
 
 export function resolveStorageWorkspaceDir(): string {
-  return configuredHost.workspaceDir ?? defaultWorkspaceDir();
+  return storageState().configuredHost.workspaceDir ?? defaultWorkspaceDir();
 }
 
 export function resolveStorageSharedWikiDir(): string {
-  return configuredHost.sharedWikiDir ?? join(resolveStorageWorkspaceDir(), "wiki");
+  return storageState().configuredHost.sharedWikiDir ?? join(resolveStorageWorkspaceDir(), "wiki");
 }
 
 export function resolveStorageUsersLogDir(): string {
-  return configuredHost.usersLogDir ?? join(resolveStorageDataDir(), "users");
+  return storageState().configuredHost.usersLogDir ?? join(resolveStorageDataDir(), "users");
 }
 
 const STORAGE_PATH_KEYS = [
@@ -176,11 +235,9 @@ function normalizeStorageHostPatch(options: StorageHostConfig): Readonly<Storage
 }
 
 function refreshConfiguredHost(): void {
-  configuredHost = Object.freeze(
-    Object.assign(
-      {},
-      ...storageHostFrames.filter((frame) => frame.active).map((frame) => frame.patch),
-    ),
+  const state = storageState();
+  state.configuredHost = Object.freeze(
+    Object.assign({}, ...state.frames.filter((frame) => frame.active).map((frame) => frame.patch)),
   );
 }
 
@@ -193,52 +250,57 @@ function refreshConfiguredHost(): void {
  */
 export function configureStorageHost(options: StorageHostConfig): () => void {
   const frame: StorageHostFrame = { active: true, patch: normalizeStorageHostPatch(options) };
-  storageHostFrames.push(frame);
+  storageState().frames.push(frame);
   refreshConfiguredHost();
   return () => {
     if (!frame.active) return;
     frame.active = false;
-    const index = storageHostFrames.indexOf(frame);
-    if (index >= 0) storageHostFrames.splice(index, 1);
+    const frames = storageState().frames;
+    const index = frames.indexOf(frame);
+    if (index >= 0) frames.splice(index, 1);
     refreshConfiguredHost();
   };
 }
 
 /** Remove every configured host layer and restore standalone fallbacks. */
 export function resetStorageHost(): void {
-  for (const frame of storageHostFrames) frame.active = false;
-  storageHostFrames.length = 0;
+  const frames = storageState().frames;
+  for (const frame of frames) frame.active = false;
+  frames.length = 0;
   refreshConfiguredHost();
 }
 
 /** Close only Negotium's fallback connection. Injected connections are borrowed. */
 export function closeStorageDatabase(): void {
-  if (!fallbackDatabase) return;
-  fallbackDatabase.close();
-  fallbackDatabase = null;
-  fallbackDatabasePath = null;
+  const state = storageState();
+  if (!state.fallbackDatabase) return;
+  state.fallbackDatabase.close();
+  state.fallbackDatabase = null;
+  state.fallbackDatabasePath = null;
 }
 
 export function registerStorageSchemaInitializer(
   initialize: StorageSchemaInitializer,
   priority = 100,
 ): void {
-  schemaInitializers.push({ initialize, priority });
-  schemaInitializers.sort((a, b) => a.priority - b.priority);
+  const initializers = storageState().schemaInitializers;
+  initializers.push({ initialize, priority });
+  initializers.sort((a, b) => a.priority - b.priority);
 }
 
 export function ensureStorageSchemas(
   database: InternalStorageDatabase = resolveStorageDatabase(),
 ): void {
-  if (initializingDatabases.has(database)) return;
-  let initialized = initializedSchemas.get(database);
+  const state = storageState();
+  if (state.initializingDatabases.has(database)) return;
+  let initialized = state.initializedSchemas.get(database);
   if (!initialized) {
     initialized = new Set();
-    initializedSchemas.set(database, initialized);
+    state.initializedSchemas.set(database, initialized);
   }
-  initializingDatabases.add(database);
+  state.initializingDatabases.add(database);
   try {
-    for (const entry of schemaInitializers) {
+    for (const entry of state.schemaInitializers) {
       if (initialized.has(entry.initialize)) continue;
       // Mark first so a migration that calls through the public db proxy does
       // not recursively invoke itself. Remove on failure so the next call can retry.
@@ -251,7 +313,7 @@ export function ensureStorageSchemas(
       }
     }
   } finally {
-    initializingDatabases.delete(database);
+    state.initializingDatabases.delete(database);
   }
 }
 

package/dist/runtime/src/storage/vault.ts

@@ -1,7 +1,8 @@
 import { chmodSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { DATA_DIR, VAULT_MASTER_KEY } from "#platform/config";
+import { VAULT_MASTER_KEY } from "#platform/config";
 import { Database } from "#storage/sqlite";
+import { resolveStorageDataDir } from "#storage/storage-host";
 import { decryptVaultValue, encryptVaultValue } from "#storage/vault-crypto";
 
 export type VaultDatabase = Pick<InstanceType<typeof Database>, "exec" | "prepare">;
@@ -72,7 +73,14 @@ function openVaultDatabase(dataDir: string): VaultDatabase {
 }
 
 function activeVaultDatabase(): VaultDatabase {
-  if (!vaultDb) vaultDb = openVaultDatabase(DATA_DIR);
+  if (!vaultDb) {
+    // `resolveStorageDataDir()`, not the import-time `DATA_DIR` constant: an
+    // embedding host configures its data directory during bootstrap, and any
+    // vault access that happens before `configureVaultStorage()` runs would
+    // otherwise pin the vault to Negotium's own state directory for the life of
+    // the process — silently, since both paths are valid and writable.
+    vaultDb = openVaultDatabase(resolveStorageDataDir());
+  }
   return vaultDb;
 }
 
@@ -83,7 +91,8 @@ export function configureVaultStorage(options: VaultStorageOptions): () => void
   }
   const previousDb = vaultDb;
   const previousMasterKey = vaultMasterKey;
-  const configuredDb = options.database ?? openVaultDatabase(options.dataDir ?? DATA_DIR);
+  const configuredDb =
+    options.database ?? openVaultDatabase(options.dataDir ?? resolveStorageDataDir());
   if (options.database) initializeVaultDatabase(configuredDb);
   vaultDb = configuredDb;
   vaultMasterKey = options.masterKey ?? VAULT_MASTER_KEY;

package/dist/runtime/src/version.ts

@@ -1 +1 @@
-export const NEGOTIUM_VERSION = "0.2.19";
+export const NEGOTIUM_VERSION = "0.2.20";

package/dist/runtime-helpers.js

@@ -534,11 +534,12 @@ function versionAtLeast(actualVersion, minimumVersion) {
   }
   return true;
 }
+var BROWSER_RS_VERSION_PROBE_TIMEOUT_MS = 15000;
 function browserRsMeetsMinimumVersion(candidate) {
   try {
     const output = execFileSync(candidate, ["--version"], {
       encoding: "utf8",
-      timeout: 2000,
+      timeout: BROWSER_RS_VERSION_PROBE_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     const match = output.match(/^browser-rs (\d+)\.(\d+)\.(\d+)$/);
@@ -764,12 +765,29 @@ if (isBun) {
 }
 
 // ../../packages/core/src/storage/storage-host.ts
-var configuredHost = {};
-var fallbackDatabase = null;
-var fallbackDatabasePath = null;
-var schemaInitializers = [];
-var initializedSchemas = new WeakMap;
-var initializingDatabases = new WeakSet;
+var STORAGE_HOST_STATE = Symbol.for("negotium.storage-host.state.v1");
+function storageState() {
+  const holder = globalThis;
+  const existing = holder[STORAGE_HOST_STATE];
+  if (existing)
+    return existing;
+  const created = {
+    configuredHost: {},
+    fallbackDatabase: null,
+    fallbackDatabasePath: null,
+    frames: [],
+    schemaInitializers: [],
+    initializedSchemas: new WeakMap,
+    initializingDatabases: new WeakSet
+  };
+  Object.defineProperty(holder, STORAGE_HOST_STATE, {
+    value: created,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  return created;
+}
 function envPath(name, fallback) {
   const value = process.env[name]?.trim();
   return resolve2(value || fallback);
@@ -814,37 +832,40 @@ function initializeDatabase(database) {
 }
 function defaultDatabase() {
   const path = defaultSessionsDatabasePath();
-  if (fallbackDatabase && fallbackDatabasePath === path)
-    return fallbackDatabase;
-  if (fallbackDatabase)
-    fallbackDatabase.close();
+  const state = storageState();
+  if (state.fallbackDatabase && state.fallbackDatabasePath === path)
+    return state.fallbackDatabase;
+  if (state.fallbackDatabase)
+    state.fallbackDatabase.close();
   mkdirSync4(dirname3(path), { recursive: true });
-  fallbackDatabase = new Database(path, { create: true });
-  fallbackDatabasePath = path;
-  initializeDatabase(fallbackDatabase);
-  return fallbackDatabase;
+  state.fallbackDatabase = new Database(path, { create: true });
+  state.fallbackDatabasePath = path;
+  initializeDatabase(state.fallbackDatabase);
+  return state.fallbackDatabase;
 }
 function resolveStorageDatabase() {
-  return configuredHost.database ?? defaultDatabase();
+  return storageState().configuredHost.database ?? defaultDatabase();
 }
 function resolveStorageDataDir() {
-  return configuredHost.dataDir ?? defaultDataDir();
+  return storageState().configuredHost.dataDir ?? defaultDataDir();
 }
 function registerStorageSchemaInitializer(initialize, priority = 100) {
-  schemaInitializers.push({ initialize, priority });
-  schemaInitializers.sort((a, b) => a.priority - b.priority);
+  const initializers = storageState().schemaInitializers;
+  initializers.push({ initialize, priority });
+  initializers.sort((a, b) => a.priority - b.priority);
 }
 function ensureStorageSchemas(database = resolveStorageDatabase()) {
-  if (initializingDatabases.has(database))
+  const state = storageState();
+  if (state.initializingDatabases.has(database))
     return;
-  let initialized = initializedSchemas.get(database);
+  let initialized = state.initializedSchemas.get(database);
   if (!initialized) {
     initialized = new Set;
-    initializedSchemas.set(database, initialized);
+    state.initializedSchemas.set(database, initialized);
   }
-  initializingDatabases.add(database);
+  state.initializingDatabases.add(database);
   try {
-    for (const entry of schemaInitializers) {
+    for (const entry of state.schemaInitializers) {
       if (initialized.has(entry.initialize))
         continue;
       initialized.add(entry.initialize);
@@ -856,7 +877,7 @@ function ensureStorageSchemas(database = resolveStorageDatabase()) {
       }
     }
   } finally {
-    initializingDatabases.delete(database);
+    state.initializingDatabases.delete(database);
   }
 }
 var internalStorageDatabase = new Proxy({}, {
@@ -1558,4 +1579,4 @@ export {
   CLAUDE_EFFORT_VALUES
 };
 
-//# debugId=A7EE5EAA6DA08CC064756E2164756E21
+//# debugId=E2956B1D02484F8564756E2164756E21