@ponraaj/dimple-sdk 0.0.0-alpha.7 → 0.0.0-alpha.8

package/README.md

@@ -54,18 +54,19 @@ promise with a closed `_tag` (`"Sdk.NotFound"`, `"Sdk.InputError"`, …);
 
 ## API surface
 
-| Method                                                    | What it does                                              |
-| --------------------------------------------------------- | --------------------------------------------------------- |
-| `write(input, { embed })`                                 | Store a memory (idempotent per `logicalKey`)              |
-| `get(id)` / `forget(id)`                                  | Fetch / remove by id or logical key                       |
-| `query(text, options)`                                    | Hybrid search — profiles, budgets, content-type filter    |
-| `updateEmbedding(id, vec, modelKey?)`                     | Attach an external embedding                              |
-| `index({ paths })`                                        | Codebase ingestion (idempotent re-index)                  |
-| `graph.addEdge/confirm/reject/expire/candidates/coverage` | Memory relationships: supports / supersedes / contradicts |
-| `explain({ kind, id }, options)`                          | Bounded graph neighborhood                                |
-| `dream(modelKey?)` / `repair(modelKey?)`                  | Consolidation + maintenance jobs                          |
-| `health(modelKey?)`                                       | Topic-tree invariant health                               |
-| `reload(input?)`                                          | Blue-green config reload                                  |
+| Method                                                    | What it does                                                                                                                                                            |
+| --------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `write(input, { embed })`                                 | Store a memory (idempotent per `logicalKey`)                                                                                                                            |
+| `writeMany(units, { embed })`                             | Bulk ingest: batch insert + batch embed + routing in one pass (skips the per-write candidate scan — quadratic under bulk; run the dream job afterwards for graph edges) |
+| `get(id)` / `forget(id)`                                  | Fetch / remove by id or logical key                                                                                                                                     |
+| `query(text, options)`                                    | Hybrid search — profiles, budgets, content-type filter                                                                                                                  |
+| `updateEmbedding(id, vec, modelKey?)`                     | Attach an external embedding                                                                                                                                            |
+| `index({ paths })`                                        | Codebase ingestion (idempotent re-index)                                                                                                                                |
+| `graph.addEdge/confirm/reject/expire/candidates/coverage` | Memory relationships: supports / supersedes / contradicts                                                                                                               |
+| `explain({ kind, id }, options)`                          | Bounded graph neighborhood                                                                                                                                              |
+| `dream(modelKey?)` / `repair(modelKey?)`                  | Consolidation + maintenance jobs                                                                                                                                        |
+| `health(modelKey?)`                                       | Topic-tree invariant health                                                                                                                                             |
+| `reload(input?)`                                          | Blue-green config reload                                                                                                                                                |
 
 Errors are a closed hierarchy (`InputError`, `NotFound`, `DuplicateKey`,
 `JobFailed`, `LLMNotConfigured`, `StoreFailure`) — see the docs site.
@@ -93,5 +94,5 @@ and in `docs/MCP.md` in the repository.
 
 ## Changelog
 
-[Release history](https://dimple.ponraaj.me/changelog/sdk) · repository
+[Release history](https://dimple.ponraaj.me/changelog/sdk/) · repository
 [`CHANGELOG.md`](./CHANGELOG.md)

package/dist/dimple.d.ts

@@ -117,6 +117,12 @@ export interface Dimple {
      * `stats` use when no model is passed. */
     readonly defaultModelId: string;
     readonly write: (input: WriteMemoryInput, options?: WriteOptions) => Promise<MemoryUnit>;
+    /** Bulk write: batch insert + batch embed + topic routing in ONE pass.
+     * Skips the per-write graph candidate scan (O(leaf size) per write —
+     * quadratic under bulk ingest); callers that need near-duplicate/
+     * conflict edges on bulk content should run the dream job afterwards.
+     * All-or-nothing: a duplicate logical key rejects the whole batch. */
+    readonly writeMany: (units: readonly WriteMemoryInput[], options?: WriteOptions) => Promise<readonly MemoryUnit[]>;
     readonly get: (id: string) => Promise<MemoryUnit>;
     readonly query: (text: string, options?: QueryOptions) => Promise<AugmentedMemory[]>;
     readonly forget: (id: string) => Promise<void>;

package/dist/index.js

@@ -766,6 +766,7 @@ import { Effect as Effect7, Schema as Schema7 } from "effect";
 import { parse, parseTree, printParseErrorCode } from "jsonc-parser";
 var CONFIG_FILE_NAMES = ["dimple.jsonc", "dimple.json"];
 var GLOBAL_DIR = ".config/dimple";
+var resolveCwd = () => process.env["DIMPLE_CWD"] ?? process.cwd();
 var defaults = {
   storeUrl: "file:./.dimple/dimple.db",
   defaultK: 60,
@@ -871,7 +872,7 @@ var loadFs = () => Effect7.tryPromise(() => import("node:fs"));
 var findProjectConfig = () => Effect7.gen(function* () {
   const fs = yield* loadFs();
   const path = yield* Effect7.tryPromise(() => import("node:path"));
-  let dir = process.cwd();
+  let dir = resolveCwd();
   for (let i = 0;i < 20; i++) {
     for (const name of CONFIG_FILE_NAMES) {
       const p = path.join(dir, name);
@@ -940,6 +941,23 @@ var resolveEnvVars = (value) => {
   }
   return value;
 };
+var resolveCwdUrls = (value) => {
+  const cwd = process.env["DIMPLE_CWD"];
+  if (cwd === undefined)
+    return value;
+  if (typeof value === "string" && value.startsWith("file:./")) {
+    return `file:${cwd}${cwd.endsWith("/") ? "" : "/"}${value.slice("file:./".length)}`;
+  }
+  if (Array.isArray(value))
+    return value.map(resolveCwdUrls);
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value))
+      result[k] = resolveCwdUrls(v);
+    return result;
+  }
+  return value;
+};
 var deepMerge = (base, over) => {
   const out = { ...base };
   for (const [key, value] of Object.entries(over)) {
@@ -957,7 +975,7 @@ var loadConfigFromFile = (path) => Effect7.gen(function* () {
   const parsed = yield* parseJsoncEffect(content, (cause) => new Error(`config parse ${path}: ${cause.message}`));
   const merged = deepMerge(defaults, parsed);
   const resolved = resolveEnvVars(merged);
-  return yield* Schema7.decodeUnknownEffect(DimpleConfig, { errors: "all" })(resolved).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
+  return yield* Schema7.decodeUnknownEffect(DimpleConfig, { errors: "all" })(resolveCwdUrls(resolved)).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
 });
 var loadConfig = (overrides) => Effect7.gen(function* () {
   const fileParts = yield* loadFromFiles();
@@ -970,7 +988,7 @@ var loadConfig = (overrides) => Effect7.gen(function* () {
   if (overrides)
     merged = deepMerge(merged, overrides);
   const resolved = resolveEnvVars(merged);
-  return yield* Schema7.decodeUnknownEffect(DimpleConfig, { errors: "all" })(resolved).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
+  return yield* Schema7.decodeUnknownEffect(DimpleConfig, { errors: "all" })(resolveCwdUrls(resolved)).pipe(Effect7.mapError((e) => new Error(`config validation: ${e.message}`)));
 });
 
 // ../config/src/service.ts
@@ -1236,7 +1254,7 @@ var makeBackend = (url, client, db, migrationFolder) => ({
                ORDER BY f.rank
                LIMIT ?`,
       args: [
-        `"${query.replaceAll('"', '""')}"`,
+        query.split(/\s+/).filter((token) => token.length > 0).map((token) => `"${token.replaceAll('"', '""')}"`).join(" "),
         namespace,
         ...topicKeys && topicKeys.length > 0 ? [...topicKeys, modelKey ?? ""] : [],
         ...typeof contentType === "string" ? [contentType] : contentType ?? [],
@@ -4610,6 +4628,58 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       embeddingModel: undefined
     };
   });
+  const writeMany = Effect26.fn("Store.writeMany")(function* (inputs) {
+    if (inputs.length === 0)
+      return [];
+    for (const input of inputs) {
+      if (input.content.includes("\x00")) {
+        return yield* new StoreError({
+          message: "Store.writeMany: content contains a NUL byte (libSQL would silently truncate it)"
+        });
+      }
+    }
+    const now = Date.now();
+    const rows = inputs.map((input) => {
+      const metadataBlob = input.typedMetadata !== undefined ? mergeMetadataBlob(input.metadata, input.typedMetadata) : input.metadata ?? null;
+      return {
+        id: crypto.randomUUID(),
+        logicalKey: input.logicalKey,
+        content: input.content,
+        contentType: input.contentType ?? "text/plain",
+        createdAt: now,
+        ttlSecs: input.ttlSecs === null ? null : input.ttlSecs ?? defaultTtlSecs,
+        namespace: input.namespace ?? "default",
+        metadata: metadataBlob
+      };
+    });
+    yield* Effect26.tryPromise({
+      try: () => db.transaction(async (tx) => {
+        await tx.insert(memories2).values(rows);
+        await tx.insert(memoryEvents2).values(rows.map((row) => ({
+          memoryId: row.id,
+          eventType: "created",
+          createdAt: now
+        })));
+      }),
+      catch: (cause) => backend.isUniqueViolation(cause) ? new DuplicateActiveKey({
+        logicalKey: inputs[0].logicalKey,
+        namespace: inputs[0].namespace ?? "default"
+      }) : new StoreError({ message: `Store.writeMany: ${cause}` })
+    });
+    return rows.map((row) => ({
+      id: row.id,
+      logicalKey: row.logicalKey,
+      content: row.content,
+      contentType: row.contentType,
+      state: "active",
+      createdAt: row.createdAt,
+      ttlSecs: row.ttlSecs,
+      namespace: row.namespace,
+      metadata: row.metadata ?? undefined,
+      embedding: undefined,
+      embeddingModel: undefined
+    }));
+  });
   const get = Effect26.fn("Store.get")(function* (id) {
     const rows = yield* Effect26.tryPromise({
       try: () => db.select(memoryFields).from(memories2).where(eq8(memories2.id, id)).limit(1),
@@ -4972,7 +5042,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
     }
     return yield* topicHealth(modelKey, topicsConfig).pipe(Effect26.provideService(Service2, backend));
   });
-  const updateEmbedding = Effect26.fn("Store.updateEmbedding")(function* (id, embedding, modelName) {
+  const updateEmbedding = Effect26.fn("Store.updateEmbedding")(function* (id, embedding, modelName, options) {
     const now = Date.now();
     const affected = yield* Effect26.tryPromise({
       try: () => db.transaction(async (tx) => {
@@ -5028,7 +5098,9 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
       yield* backend.insertVector(id, embedding, modelConfig);
       if (topicsEnabled) {
         const routed = yield* routeInsert(id, embedding, modelConfig, topicsConfig).pipe(Effect26.provideService(Service2, backend), Effect26.mapError((cause) => new StoreError({ message: `Store.updateEmbedding topic route: ${cause}` })));
-        yield* scanLeafCandidates(id, embedding, routed.topicKey, modelConfig);
+        if (options?.scanCandidates !== false) {
+          yield* scanLeafCandidates(id, embedding, routed.topicKey, modelConfig);
+        }
         if (routed.overflow) {
           const enqueueSplit = topicsOptions?.enqueueSplit;
           if (enqueueSplit) {
@@ -5588,6 +5660,7 @@ var makeStore2 = (backend, modelConfig, topicsOptions, graphConfig, auditOptions
   });
   return {
     write,
+    writeMany,
     writeSuperseding,
     reconcile,
     reconcileRenameCandidates,
@@ -6553,10 +6626,16 @@ import { existsSync as existsSync2, readFileSync } from "node:fs";
 import { join as join2 } from "node:path";
 import { pathToFileURL } from "node:url";
 
-// ../embedder/src/auto-install.ts
-import { execFile } from "node:child_process";
+// ../installer/src/index.ts
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+
+class InstallerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InstallerError";
+  }
+}
 var detectPackageManager = (cwd) => {
   let dir = cwd;
   while (true) {
@@ -6571,38 +6650,74 @@ var detectPackageManager = (cwd) => {
       return { pm: "npm", root: dir };
     const parent = join(dir, "..");
     if (parent === dir)
-      return { pm: "bun", root: cwd };
+      return { pm: "npm", root: cwd };
     dir = parent;
   }
 };
-var installCommand = (pm) => {
-  switch (pm) {
-    case "bun":
-      return ["bun", "add", "@huggingface/transformers"];
-    case "npm":
-      return [
-        "npm",
-        "install",
-        "@huggingface/transformers",
-        "--ignore-scripts",
-        "--no-audit",
-        "--no-fund"
-      ];
-    case "pnpm":
-      return ["pnpm", "add", "@huggingface/transformers", "--ignore-scripts"];
-    case "yarn":
-      return ["yarn", "add", "@huggingface/transformers", "--ignore-scripts"];
-  }
+var resolveExecutable = (pm, platform = process.platform) => platform === "win32" && pm !== "bun" ? `${pm}.cmd` : pm;
+var installArgs = (pm, packages, root) => {
+  const argv = [pm === "npm" ? "install" : "add", ...packages];
+  if (pm !== "bun")
+    argv.push("--ignore-scripts");
+  if (pm === "npm")
+    argv.push("--no-audit", "--no-fund");
+  if (pm === "pnpm" && existsSync(join(root, "pnpm-workspace.yaml")))
+    argv.push("-w");
+  return argv;
 };
-var installTransformers = (cwd) => new Promise((resolve, reject) => {
+var installOnce = async (target, packages, opts) => {
+  const { spawn } = await import("node:child_process");
+  return new Promise((resolve, reject) => {
+    const timeoutMs = opts.timeoutMs ?? 300000;
+    const cmd = resolveExecutable(target.pm, opts.platform);
+    const args = installArgs(target.pm, packages, target.root);
+    const manual = `${cmd} ${args.join(" ")}`;
+    const child = spawn(cmd, args, { cwd: target.root, stdio: "ignore" });
+    let settled = false;
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      if (settled)
+        return;
+      settled = true;
+      reject(new InstallerError(`auto-install timed out after ${timeoutMs} ms — the child was killed; run it manually: ${manual}`));
+    }, timeoutMs);
+    child.on("error", (cause) => {
+      clearTimeout(timer);
+      if (settled)
+        return;
+      settled = true;
+      reject(new InstallerError(`auto-install failed to start (${manual}): ${cause.message} — run it manually`));
+    });
+    child.on("exit", (code, signal) => {
+      clearTimeout(timer);
+      if (settled)
+        return;
+      settled = true;
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new InstallerError(`auto-install failed (${manual} exited ${signal !== null ? `with ${signal}` : `code ${code ?? "?"}`}) — run it manually`));
+    });
+  });
+};
+var inflight = new Map;
+var installOptionalPeers = (packages, opts) => {
+  const cwd = opts?.cwd ?? process.cwd();
   const target = detectPackageManager(cwd);
-  const [cmd, ...args] = installCommand(target.pm);
-  execFile(cmd, args, { cwd: target.root, encoding: "utf8" }, (error) => {
-    if (error) {
-      reject(new Error(`auto-install of @huggingface/transformers failed (${target.pm} add …): ${error.message} — ` + "run it manually or set `autoInstall: false` and configure a hosted embedding provider"));
-      return;
-    }
-    resolve();
+  const key = `${target.root}\x00${packages.join(",")}`;
+  const existing = inflight.get(key);
+  if (existing !== undefined)
+    return existing;
+  const run = installOnce(target, packages, opts ?? {});
+  inflight.set(key, run);
+  run.then(() => inflight.delete(key), () => inflight.delete(key));
+  return run;
+};
+// ../embedder/src/auto-install.ts
+var installTransformers = (cwd) => installOptionalPeers(["@huggingface/transformers"], { cwd, timeoutMs: 300000 }).catch((cause) => {
+  throw new EmbeddingError({
+    message: cause instanceof InstallerError ? `${cause.message} — or set \`autoInstall: false\` and configure a hosted embedding provider` : `auto-install of @huggingface/transformers failed: ${String(cause)} — run it manually ` + "or set `autoInstall: false` and configure a hosted embedding provider"
   });
 });
 
@@ -6667,9 +6782,12 @@ var make5 = (options) => {
       }
       return Effect32.gen(function* () {
         yield* Effect32.logInfo("auto-installing @huggingface/transformers (first local-embed use — scripts skipped)").pipe(Effect32.annotateLogs({ scope: "@dimple/embedder", event: "embedder.auto-install" }));
-        yield* Effect32.tryPromise(() => installTransformers(process.cwd())).pipe(Effect32.timeout("5 minutes"), Effect32.catch((cause) => Effect32.fail(new EmbeddingError({
-          message: cause._tag === "TimeoutError" ? "auto-install of @huggingface/transformers timed out (5 minutes) — run " + "`bun add @huggingface/transformers` manually" : cause.cause instanceof Error ? cause.cause.message : cause instanceof Error ? cause.message : `auto-install failed: ${String(cause)}`
-        }))));
+        yield* Effect32.tryPromise(() => installTransformers(process.cwd())).pipe(Effect32.catch((cause) => {
+          const inner = cause.cause;
+          return Effect32.fail(inner instanceof EmbeddingError ? inner : new EmbeddingError({
+            message: `auto-install failed: ${inner instanceof Error ? inner.message : String(cause)}`
+          }));
+        }));
         return yield* Effect32.tryPromise(importFromDisk).pipe(Effect32.mapError(() => new EmbeddingError({
           message: "@huggingface/transformers still unavailable after auto-install — run `bun add " + "@huggingface/transformers` manually (or set `autoInstall: false` and configure a hosted embedding provider)"
         })));
@@ -8417,8 +8535,8 @@ var walkFiles = (paths2, extensions) => {
   const files = [];
   const errors3 = [];
   let unsupported = 0;
-  const resolved = paths2.map((p) => resolve(p));
-  const root = commonRoot([...resolved, process.cwd()]);
+  const resolved = paths2.map((p) => resolve(process.env["DIMPLE_CWD"] ?? process.cwd(), p));
+  const root = commonRoot([...resolved, process.env["DIMPLE_CWD"] ?? process.cwd()]);
   const visit = (path2) => {
     let stat;
     try {
@@ -8811,6 +8929,30 @@ var makeFacade = (state, reload, dispose) => {
         return yield* invalid;
       return yield* writeUnit(input, options?.embed !== false);
     })),
+    writeMany: (units, options) => run(Effect49.gen(function* () {
+      if (!Array.isArray(units)) {
+        return yield* new InputError({ message: "writeMany: units must be an array" });
+      }
+      for (const input of units) {
+        const invalid = validateWriteInput(input);
+        if (invalid !== undefined)
+          return yield* invalid;
+      }
+      const mems = yield* core().store.writeMany(units);
+      if (options?.embed !== false) {
+        yield* core().store.ensureTopicTree(core().defaultModel.id);
+        const vectors = yield* core().defaultEmbedder.embed(mems.map((m) => m.content));
+        for (let i = 0;i < mems.length; i++) {
+          yield* core().store.updateEmbedding(mems[i].id, [...vectors[i]], core().defaultModel.id, {
+            scanCandidates: false
+          });
+        }
+        return yield* Effect49.forEach(mems, (mem) => core().store.get(mem.id), {
+          discard: false
+        });
+      }
+      return mems;
+    })),
     get: (id) => run(resolveMemory(id)),
     query: runQuery,
     forget: (id) => run(resolveMemory(id).pipe(Effect49.flatMap((memory) => core().store.forget(memory.id)))),
@@ -9111,7 +9253,7 @@ var makeDimple = async (options) => {
   let disposed = false;
   let gate = Promise.resolve();
   let releaseGate;
-  let inflight = 0;
+  let inflight2 = 0;
   let drainWaiters = [];
   let reloadChain = Promise.resolve();
   const run = (effect) => {
@@ -9123,12 +9265,12 @@ var makeDimple = async (options) => {
         return Promise.reject(new StoreFailure({ message: "SDK disposed" }));
       }
       const stack = current;
-      inflight += 1;
+      inflight2 += 1;
       return stack.runPromise(effect.pipe(Effect50.mapError(remapError))).catch((cause) => {
         return Promise.reject(remapError(cause));
       }).finally(() => {
-        inflight -= 1;
-        if (inflight === 0 && drainWaiters.length > 0) {
+        inflight2 -= 1;
+        if (inflight2 === 0 && drainWaiters.length > 0) {
           const waiters = drainWaiters;
           drainWaiters = [];
           for (const wake of waiters)
@@ -9149,7 +9291,7 @@ var makeDimple = async (options) => {
     release?.();
   };
   const drain = () => {
-    if (inflight === 0)
+    if (inflight2 === 0)
       return Promise.resolve();
     return new Promise((resolve2) => {
       drainWaiters.push(resolve2);

package/dist/internal/embedder/auto-install.d.ts

@@ -1,35 +1,10 @@
-/**
- * First-use auto-install of the OPTIONAL `@huggingface/transformers` peer.
- *
- * `@huggingface/transformers` is an optional peer (its tree pulls the
- * `sharp` + `onnxruntime-node` postinstall scripts that abort npm 11
- * installs). When the config declares a `transformers` provider model,
- * the intent is explicit — so the FIRST local-embed use installs the
- * package automatically with the project's own package manager, instead
- * of failing with a manual step.
- *
- * Safety notes:
- * - The install is scoped to the detected project root (the manifest's
- *   directory) and uses the manager the project already uses.
- * - EVERY install runs `--ignore-scripts` (npm/pnpm/yarn) or bun's
- *   default script-blocking — verified harmless: the onnxruntime-node
- *   binaries ship in the package; its postinstall is not required for
- *   embedding, and sharp is never loaded for text embeddings.
- * - Failure (offline, restricted env) is a typed EmbeddingError with the
- *   manual command — never a crash.
- */
-export type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
-export interface InstallTarget {
-    readonly pm: PackageManager;
-    readonly root: string;
-}
-/** Detect the project's package manager by walking UP from `cwd` for a
- * lockfile (bun.lock/bun.lockb → bun, package-lock.json → npm,
- * pnpm-lock.yaml → pnpm, yarn.lock → yarn). Falls back to bun + cwd. */
-export declare const detectPackageManager: (cwd: string) => InstallTarget;
-/** The install argv for a manager. `--ignore-scripts` on npm/pnpm/yarn:
- * the blocked postinstalls are proven unnecessary for embedding (bun
- * blocks them by default already). */
+import { type PackageManager } from "./internal/installer/index.js";
+export type { InstallTarget, PackageManager } from "./internal/installer/index.js";
+export { detectPackageManager } from "./internal/installer/index.js";
+/** The install argv for a manager with the transformers package (kept for
+ * callers/tests that assert the shape). */
 export declare const installCommand: (pm: PackageManager) => readonly [string, ...string[]];
-/** Run the install for the project at `cwd`; rejects on non-zero exit. */
+/** Install transformers at the project root detected from `cwd`. The
+ * shared installer kills the child on timeout and dedups concurrent
+ * first-use installs; failures reject with the manual command. */
 export declare const installTransformers: (cwd: string) => Promise<void>;

package/dist/internal/installer/index.d.ts

@@ -0,0 +1,26 @@
+export type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
+export interface InstallTarget {
+    readonly pm: PackageManager;
+    readonly root: string;
+}
+export declare class InstallerError extends Error {
+    constructor(message: string);
+}
+/** Detect the project's package manager by walking UP from `cwd` for a
+ * lockfile. NO lockfile → npm (the most universal — a bun fallback broke
+ * Node-only machines with ENOENT). */
+export declare const detectPackageManager: (cwd: string) => InstallTarget;
+/** The executable name for a manager. win32 ships `.cmd` shims for
+ * npm/pnpm/yarn — the bare names fail with ENOENT. */
+export declare const resolveExecutable: (pm: PackageManager, platform?: NodeJS.Platform) => string;
+/** The base install argv for a manager. Scripts are skipped everywhere;
+ * pnpm at a workspace root additionally gets `-w`. */
+export declare const installArgs: (pm: PackageManager, packages: readonly string[], root: string) => string[];
+export interface InstallOptions {
+    readonly cwd?: string;
+    /** Hard deadline; the child is SIGKILLed when it trips (default 5 min). */
+    readonly timeoutMs?: number;
+    /** Injectable for tests (defaults to process.platform). */
+    readonly platform?: NodeJS.Platform;
+}
+export declare const installOptionalPeers: (packages: readonly string[], opts?: InstallOptions) => Promise<void>;

package/dist/internal/store/service.d.ts

@@ -65,6 +65,11 @@ export interface ExplainResult {
 }
 export interface Interface {
     readonly write: (input: WriteMemoryInput) => Effect.Effect<MemoryUnit, StoreError | DuplicateActiveKey>;
+    /** Bulk write: batch insert in ONE transaction (all-or-nothing; a
+     * duplicate logical key fails the whole batch with DuplicateActiveKey).
+     * The per-write graph candidate scan is NOT part of this — pair with
+     * `updateEmbedding(..., { scanCandidates: false })` for bulk ingest. */
+    readonly writeMany: (inputs: readonly WriteMemoryInput[]) => Effect.Effect<readonly MemoryUnit[], StoreError | DuplicateActiveKey>;
     /** Upsert for the index path — the identity rule (same logical key ⇒
      * confirmed `memory_supersedes`) made reachable for ACTIVE keys: demote
      * the active holder of the key (if any), write the new unit, and link
@@ -139,7 +144,9 @@ export interface Interface {
     readonly forget: (id: string) => Effect.Effect<void, NotFound | StoreError>;
     readonly sweep: (namespace: string) => Effect.Effect<SweepResult, StoreError>;
     readonly events: (memoryId: string) => Effect.Effect<readonly MemoryEvent[], StoreError>;
-    readonly updateEmbedding: (id: string, embedding: ReadonlyArray<number>, model: string) => Effect.Effect<void, NotFound | StoreError>;
+    readonly updateEmbedding: (id: string, embedding: ReadonlyArray<number>, model: string, options?: {
+        readonly scanCandidates?: boolean;
+    }) => Effect.Effect<void, NotFound | StoreError>;
     readonly findStale: (model: string) => Effect.Effect<readonly string[], StoreError>;
     readonly createConcept: (name: string, embedding: ReadonlyArray<number>) => Effect.Effect<Concept, StoreError>;
     readonly getConcept: (id: string) => Effect.Effect<Concept, NotFound | StoreError>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ponraaj/dimple-sdk",
-  "version": "0.0.0-alpha.7",
+  "version": "0.0.0-alpha.8",
   "private": false,
   "files": [
     "dist"