@ponraaj/dimple-sdk 0.0.0-alpha.11 → 0.0.0-alpha.13

package/dist/index.js

@@ -33,7 +33,7 @@ import { Effect as Effect39, Layer as Layer15, Schedule as Schedule2, Schema as
 
 // ../store/src/store.ts
 import { Config as Config4, Effect as Effect25, Layer as Layer10, Schema as Schema23 } from "effect";
-import { eq as eq8, and as and8, desc as desc2, asc as asc5, inArray as inArray4, ne as ne4, or, isNull as isNull2, like, sql as sql7 } from "drizzle-orm";
+import { eq as eq8, and as and8, desc as desc2, asc as asc5, inArray as inArray4, ne as ne4, or, isNull as isNull2, like, sql as sql8 } from "drizzle-orm";
 
 // ../store/src/db-backend.ts
 import { Context as Context2 } from "effect";
@@ -840,6 +840,43 @@ var IndexConfig = Schema8.Struct({
   maxNeighbors: Schema8.optional(Schema8.Number),
   searchL: Schema8.optional(Schema8.Number)
 });
+var ThreadCount = Schema8.Number.pipe(Schema8.refine((n) => Number.isInteger(n) && n >= 0 && n <= 1024, {
+  identifier: "ThreadCount"
+}));
+var SessionOptions = Schema8.Struct({
+  intraOpNumThreads: Schema8.optional(ThreadCount),
+  interOpNumThreads: Schema8.optional(ThreadCount),
+  executionMode: Schema8.optional(Schema8.Literals(["sequential", "parallel"])),
+  graphOptimizationLevel: Schema8.optional(Schema8.Literals(["disabled", "basic", "extended", "all", "layout"])),
+  enableCpuMemArena: Schema8.optional(Schema8.Boolean),
+  enableMemPattern: Schema8.optional(Schema8.Boolean),
+  gpuMemLimit: Schema8.optional(Schema8.Number),
+  arenaExtendStrategy: Schema8.optional(Schema8.Literals([0, 1]))
+});
+var mergeSessionOptions = (global, model) => {
+  const pick = (key) => model?.[key] ?? global?.[key];
+  const intraOpNumThreads = pick("intraOpNumThreads");
+  const interOpNumThreads = pick("interOpNumThreads");
+  const executionMode = pick("executionMode");
+  const graphOptimizationLevel = pick("graphOptimizationLevel");
+  const enableCpuMemArena = pick("enableCpuMemArena");
+  const enableMemPattern = pick("enableMemPattern");
+  const gpuMemLimit = pick("gpuMemLimit");
+  const arenaExtendStrategy = pick("arenaExtendStrategy");
+  const empty = intraOpNumThreads === undefined && interOpNumThreads === undefined && executionMode === undefined && graphOptimizationLevel === undefined && enableCpuMemArena === undefined && enableMemPattern === undefined && gpuMemLimit === undefined && arenaExtendStrategy === undefined;
+  if (empty)
+    return;
+  return {
+    ...intraOpNumThreads !== undefined ? { intraOpNumThreads } : undefined,
+    ...interOpNumThreads !== undefined ? { interOpNumThreads } : undefined,
+    ...executionMode !== undefined ? { executionMode } : undefined,
+    ...graphOptimizationLevel !== undefined ? { graphOptimizationLevel } : undefined,
+    ...enableCpuMemArena !== undefined ? { enableCpuMemArena } : undefined,
+    ...enableMemPattern !== undefined ? { enableMemPattern } : undefined,
+    ...gpuMemLimit !== undefined ? { gpuMemLimit } : undefined,
+    ...arenaExtendStrategy !== undefined ? { arenaExtendStrategy } : undefined
+  };
+};
 var EmbeddingModelConfig = Schema8.Struct({
   id: Schema8.String,
   provider: Schema8.String,
@@ -877,14 +914,13 @@ var EmbeddingModelConfig = Schema8.Struct({
   pooling: Schema8.optional(Schema8.Literals(["mean", "cls", "none"])),
   normalize: Schema8.optional(Schema8.Boolean),
   cacheDir: Schema8.optional(Schema8.String),
-  sessionOptions: Schema8.optional(Schema8.Struct({
-    gpuMemLimit: Schema8.optional(Schema8.Number),
-    arenaExtendStrategy: Schema8.optional(Schema8.Literals([0, 1]))
-  })),
+  sessionOptions: Schema8.optional(SessionOptions),
+  wasm: Schema8.optional(Schema8.Struct({ numThreads: Schema8.optional(ThreadCount) })),
   autoInstall: Schema8.optional(Schema8.Boolean)
 });
 var EmbeddingConfig = Schema8.Struct({
   defaultModel: Schema8.String,
+  sessionOptions: Schema8.optional(SessionOptions),
   models: Schema8.Array(EmbeddingModelConfig)
 });
 var MaxAttempts = Schema8.Number.pipe(Schema8.refine((n) => Number.isInteger(n) && n > 0 && n <= 100, {
@@ -2736,8 +2772,8 @@ var resolveTopics = Effect11.fn("topics.resolveTopics")(function* (queryVector,
 });
 
 // ../store/src/topics/lifecycle.ts
-import { Clock as Clock3, Effect as Effect20 } from "effect";
-import { and as and3, eq as eq3, inArray, ne } from "drizzle-orm";
+import { Clock as Clock3, Cause as Cause3, Effect as Effect20, Exit as Exit6 } from "effect";
+import { and as and3, eq as eq3, inArray, ne, sql as sql3 } from "drizzle-orm";
 
 // ../workflow/src/queue.ts
 import { Effect as Effect12, Schema as Schema13 } from "effect";
@@ -2820,6 +2856,16 @@ var MemoryEmbed = JobDefinition.make("memory.embed", {
   error: Schema13.String,
   idempotencyKey: (p) => `embed:${p.memoryId}:${p.modelKey}`
 });
+var MemoryEmbedBatch = JobDefinition.make("memory.embed.batch", {
+  payload: {
+    memoryIds: Schema13.Array(Schema13.String),
+    modelKey: Schema13.String,
+    nonce: Schema13.String
+  },
+  success: Schema13.Void,
+  error: Schema13.String,
+  idempotencyKey: (p) => `embed-batch:${p.modelKey}:${p.nonce}`
+});
 var TopicMerge = JobDefinition.make("topic.merge", {
   payload: { topicId: Schema13.String, modelKey: Schema13.String },
   success: Schema13.Void,
@@ -2877,6 +2923,7 @@ var AuditWrite = JobDefinition.make("audit.write", {
 var queues = [
   TopicSplit,
   MemoryEmbed,
+  MemoryEmbedBatch,
   TopicMerge,
   TopicRebalance,
   ConceptCluster,
@@ -3703,46 +3750,136 @@ var setActiveModel = Effect20.fn("topics.setActiveModel")(function* (model, conf
   }).pipe(routingFailure3("topics.setActiveModel.deactivate"));
   return { routed, alreadyInTree, deactivated };
 });
+var embedOneMemory = (deps, payload, ctx) => Effect20.gen(function* () {
+  const envelope = payload;
+  const model = deps.getModelConfig(envelope.modelKey);
+  if (!model) {
+    return yield* Effect20.fail(new JobFailure({
+      jobId: ctx.jobId,
+      message: `memory.embed: unknown model "${envelope.modelKey}"`
+    }));
+  }
+  const content = yield* deps.getMemoryContent(envelope.memoryId).pipe(Effect20.catchTag("Store.NotFound", () => Effect20.succeed(undefined)), Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: load content: ${e}` })));
+  if (content === undefined) {
+    yield* Effect20.logDebug("embed.stale-reoffer").pipe(Effect20.annotateLogs({
+      scope: "@dimple/store",
+      event: "embed.stale-reoffer",
+      memoryId: envelope.memoryId,
+      modelKey: envelope.modelKey
+    }));
+    return;
+  }
+  const vector = yield* deps.embedOne(content, model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: embed: ${e}` })));
+  const backend = yield* Service2;
+  const db = backend.db;
+  const existing = yield* Effect20.tryPromise({
+    try: () => db.select({ memoryId: topicMemberships.memoryId }).from(topicMemberships).where(and3(eq3(topicMemberships.memoryId, envelope.memoryId), eq3(topicMemberships.modelKey, model.id))),
+    catch: (cause) => new StoreError({ message: `memory.embed: membership check: ${cause}` })
+  }).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: membership check: ${e}` })));
+  yield* ensureTopicTree(model, deps.config).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: seed tree: ${e}` })));
+  yield* backend.ensureVectorTable(model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: vector table: ${e}` })));
+  yield* backend.insertVector(envelope.memoryId, [...vector], model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: insert vector: ${e}` })));
+  yield* Effect20.tryPromise({
+    try: () => db.update(memories).set({ embedding: [...vector], embeddingModel: model.id }).where(eq3(memories.id, envelope.memoryId)),
+    catch: (cause) => new StoreError({ message: `memory.embed: stamp embedding: ${cause}` })
+  }).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: stamp embedding: ${e}` })));
+  if (existing.length === 0) {
+    yield* routeInsert(envelope.memoryId, [...vector], model, deps.config).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: route: ${e}` })));
+  }
+  yield* Effect20.logInfo("embed.completed").pipe(Effect20.annotateLogs({
+    scope: "@dimple/store",
+    event: "embed.completed",
+    memoryId: envelope.memoryId,
+    modelKey: envelope.modelKey,
+    reroute: existing.length === 0
+  }));
+  return;
+});
 function memoryEmbedHandler(deps) {
+  const run = (payload, ctx) => embedOneMemory(deps, payload, ctx);
+  return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect20.provideService(Service2, deps.backend)) : run;
+}
+var logBatchCompleted = (modelKey, embedded, failed, ctx) => Effect20.logInfo("embed.batch.completed").pipe(Effect20.annotateLogs({
+  scope: "@dimple/store",
+  event: "embed.batch.completed",
+  jobId: ctx.jobId,
+  modelKey,
+  embedded,
+  failed
+}));
+var batchFailure = (ctx, failed, total, first) => Effect20.fail(new JobFailure({
+  jobId: ctx.jobId,
+  message: `memory.embed.batch: ${failed}/${total} failed — ${first}`
+}));
+function memoryEmbedBatchHandler(deps) {
   const run = (payload, ctx) => Effect20.gen(function* () {
-    const envelope = payload;
-    const model = deps.getModelConfig(envelope.modelKey);
+    const model = deps.getModelConfig(payload.modelKey);
     if (!model) {
       return yield* Effect20.fail(new JobFailure({
         jobId: ctx.jobId,
-        message: `memory.embed: unknown model "${envelope.modelKey}"`
+        message: `memory.embed: unknown model "${payload.modelKey}"`
       }));
     }
-    const content = yield* deps.getMemoryContent(envelope.memoryId).pipe(Effect20.catchTag("Store.NotFound", () => Effect20.succeed(undefined)), Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: load content: ${e}` })));
-    if (content === undefined) {
+    const backend = yield* Service2;
+    const db = backend.db;
+    let failed = 0;
+    let first;
+    const embedded = [];
+    const stale = [];
+    yield* Effect20.forEach(payload.memoryIds, (memoryId) => Effect20.gen(function* () {
+      const content = yield* deps.getMemoryContent(memoryId).pipe(Effect20.catchTag("Store.NotFound", () => Effect20.succeed(undefined)), Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: load content: ${e}` })));
+      if (content === undefined) {
+        stale.push(memoryId);
+        return;
+      }
+      const vector = yield* deps.embedOne(content, model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: embed: ${e}` })));
+      embedded.push({ memoryId, vector });
+    }).pipe(Effect20.exit, Effect20.tap((exit) => {
+      if (Exit6.isSuccess(exit))
+        return Effect20.void;
+      failed += 1;
+      first ??= Cause3.pretty(exit.cause);
+      return Effect20.void;
+    })), { concurrency: 1, discard: true });
+    for (const memoryId of stale) {
       yield* Effect20.logDebug("embed.stale-reoffer").pipe(Effect20.annotateLogs({
         scope: "@dimple/store",
         event: "embed.stale-reoffer",
-        memoryId: envelope.memoryId,
-        modelKey: envelope.modelKey
+        memoryId,
+        modelKey: payload.modelKey
       }));
+    }
+    if (embedded.length === 0) {
+      yield* logBatchCompleted(payload.modelKey, 0, failed, ctx);
+      if (failed > 0) {
+        return yield* batchFailure(ctx, failed, payload.memoryIds.length, first);
+      }
       return;
     }
-    const vector = yield* deps.embedOne(content, model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: embed: ${e}` })));
-    const backend = yield* Service2;
-    const db = backend.db;
-    const existing = yield* Effect20.tryPromise({
-      try: () => db.select({ memoryId: topicMemberships.memoryId }).from(topicMemberships).where(and3(eq3(topicMemberships.memoryId, envelope.memoryId), eq3(topicMemberships.modelKey, model.id))),
-      catch: (cause) => new StoreError({ message: `memory.embed: membership check: ${cause}` })
-    }).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: membership check: ${e}` })));
     yield* ensureTopicTree(model, deps.config).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: seed tree: ${e}` })));
     yield* backend.ensureVectorTable(model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: vector table: ${e}` })));
-    yield* backend.insertVector(envelope.memoryId, [...vector], model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: insert vector: ${e}` })));
-    if (existing.length === 0) {
-      yield* routeInsert(envelope.memoryId, [...vector], model, deps.config).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: route: ${e}` })));
+    const ids = embedded.map((e) => e.memoryId);
+    const members = yield* Effect20.tryPromise({
+      try: () => db.select({ memoryId: topicMemberships.memoryId }).from(topicMemberships).where(and3(eq3(topicMemberships.modelKey, model.id), inArray(topicMemberships.memoryId, ids))),
+      catch: (cause) => new StoreError({ message: `memory.embed: membership check: ${cause}` })
+    }).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: membership check: ${e}` })));
+    const memberSet = new Set(members.map((r) => r.memoryId));
+    const entries = embedded.map((e) => ({ memoryId: e.memoryId, vector: [...e.vector] }));
+    yield* backend.insertVectors(entries, model).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: insert vectors: ${e}` })));
+    yield* Effect20.tryPromise({
+      try: () => db.transaction(async (tx) => {
+        await tx.run(sql3`UPDATE ${memories} SET embedding = CASE id ${sql3.join(entries.map((entry) => sql3`WHEN ${entry.memoryId} THEN ${new Float32Array(entry.vector).buffer}`), sql3` `)} END, embedding_model = ${model.id} WHERE id IN (${sql3.join(entries.map((entry) => sql3`${entry.memoryId}`), sql3`, `)})`);
+      }),
+      catch: (cause) => new StoreError({ message: `memory.embed: stamp embeddings: ${cause}` })
+    }).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: stamp embeddings: ${e}` })));
+    const fresh = entries.filter((entry) => !memberSet.has(entry.memoryId));
+    if (fresh.length > 0) {
+      yield* routeInsertMany(fresh, model, deps.config).pipe(Effect20.mapError((e) => new JobFailure({ jobId: ctx.jobId, message: `memory.embed: route: ${e}` })));
+    }
+    yield* logBatchCompleted(payload.modelKey, embedded.length, failed, ctx);
+    if (failed > 0) {
+      return yield* batchFailure(ctx, failed, payload.memoryIds.length, first);
     }
-    yield* Effect20.logInfo("embed.completed").pipe(Effect20.annotateLogs({
-      scope: "@dimple/store",
-      event: "embed.completed",
-      memoryId: envelope.memoryId,
-      modelKey: envelope.modelKey,
-      reroute: existing.length === 0
-    }));
     return;
   });
   return deps.backend ? (payload, ctx) => run(payload, ctx).pipe(Effect20.provideService(Service2, deps.backend)) : run;
@@ -3750,19 +3887,19 @@ function memoryEmbedHandler(deps) {
 
 // ../store/src/topics/jobs.ts
 import { Clock as Clock4, Effect as Effect21 } from "effect";
-import { and as and4, asc as asc3, eq as eq4, inArray as inArray2, sql as sql4 } from "drizzle-orm";
+import { and as and4, asc as asc3, eq as eq4, inArray as inArray2, sql as sql5 } from "drizzle-orm";
 
 // ../store/src/topics/topic-vectors.ts
-import { sql as sql3 } from "drizzle-orm";
+import { sql as sql4 } from "drizzle-orm";
 var topicVectorTableName2 = (model) => `topic_vec_${model.dimensions}_${model.id.replace(/[^a-zA-Z0-9_]/g, "_")}`;
 var deleteTopicVectorRow = async (runner, model, topicKey) => {
   const table = topicVectorTableName2(model);
-  await runner.run(sql3`DELETE FROM ${sql3.raw(table)} WHERE topic_key = ${topicKey}`);
+  await runner.run(sql4`DELETE FROM ${sql4.raw(table)} WHERE topic_key = ${topicKey}`);
 };
 var writeTopicVector = async (runner, model, topicKey, ls) => {
   const table = topicVectorTableName2(model);
-  await runner.run(sql3`
-    INSERT OR REPLACE INTO ${sql3.raw(table)} (topic_key, sum_vector, model_key)
+  await runner.run(sql4`
+    INSERT OR REPLACE INTO ${sql4.raw(table)} (topic_key, sum_vector, model_key)
     VALUES (${topicKey}, vector32(${JSON.stringify([...ls])}), ${model.id})
   `);
 };
@@ -3853,7 +3990,7 @@ var splitTopic = Effect21.fn("TopicSplit.splitTopic")(function* (topicKey, model
         }).onConflictDoUpdate({
           target: [topicGrowthState.topicKey, topicGrowthState.modelKey],
           set: {
-            splitRejectedCount: sql4`${topicGrowthState.splitRejectedCount} + 1`,
+            splitRejectedCount: sql5`${topicGrowthState.splitRejectedCount} + 1`,
             splitDeferred: 1
           }
         });
@@ -4543,7 +4680,7 @@ var staleNoOp = (notFound, model) => Effect22.gen(function* () {
 
 // ../store/src/topics/observability.ts
 import { Effect as Effect23 } from "effect";
-import { and as and6, desc, eq as eq6, inArray as inArray3, ne as ne3, sql as sql5 } from "drizzle-orm";
+import { and as and6, desc, eq as eq6, inArray as inArray3, ne as ne3, sql as sql6 } from "drizzle-orm";
 var DEFAULT_MAX_LEAF_ITEMS3 = 128;
 var DEFAULT_SPLIT_DEFERRED_HARD_LIMIT2 = 512;
 var DEFAULT_CHANGE_LOG_LIMIT = 50;
@@ -4587,7 +4724,7 @@ var topicMetrics = Effect23.fn("topics.topicMetrics")(function* (modelKey, confi
   }
   leafMemberCounts.sort((a, b) => a - b);
   const growth = yield* Effect23.tryPromise({
-    try: () => db.select({ total: sql5`coalesce(sum(${topicGrowthState.splitRejectedCount}), 0)` }).from(topicGrowthState).where(eq6(topicGrowthState.modelKey, modelKey)),
+    try: () => db.select({ total: sql6`coalesce(sum(${topicGrowthState.splitRejectedCount}), 0)` }).from(topicGrowthState).where(eq6(topicGrowthState.modelKey, modelKey)),
     catch: (cause) => cause
   }).pipe(routingFailure4("topics.topicMetrics.growth"));
   const splitRejectedTotal = Number(growth[0]?.total ?? 0);
@@ -4643,7 +4780,7 @@ var topicHealth = Effect23.fn("topics.topicHealth")(function* (modelKey, config)
     catch: (cause) => cause
   }).pipe(routingFailure4("topics.topicHealth.topics"));
   const countRows = yield* Effect23.tryPromise({
-    try: () => db.select({ topicKey: topicMemberships.topicKey, count: sql5`count(*)` }).from(topicMemberships).where(eq6(topicMemberships.modelKey, modelKey)).groupBy(topicMemberships.topicKey),
+    try: () => db.select({ topicKey: topicMemberships.topicKey, count: sql6`count(*)` }).from(topicMemberships).where(eq6(topicMemberships.modelKey, modelKey)).groupBy(topicMemberships.topicKey),
     catch: (cause) => cause
   }).pipe(routingFailure4("topics.topicHealth.memberships"));
   const membershipCount = new Map(countRows.map((r) => [r.topicKey, Number(r.count)]));
@@ -4668,7 +4805,7 @@ var topicHealth = Effect23.fn("topics.topicHealth")(function* (modelKey, config)
 
 // ../store/src/graph/observability.ts
 import { Effect as Effect24 } from "effect";
-import { and as and7, eq as eq7, isNull, sql as sql6 } from "drizzle-orm";
+import { and as and7, eq as eq7, isNull, sql as sql7 } from "drizzle-orm";
 var graphCoverage = Effect24.fn("GraphCoverage.run")(function* (modelKey) {
   const backend = yield* Service2;
   const db = backend.db;
@@ -4682,7 +4819,7 @@ var graphCoverage = Effect24.fn("GraphCoverage.run")(function* (modelKey) {
   const coveredMemories = totalMemories - isolatedMemories;
   const coveragePercent = totalMemories === 0 ? 0 : Math.round(coveredMemories / totalMemories * 1000) / 10;
   const pendingRows = yield* Effect24.tryPromise({
-    try: () => db.select({ count: sql6`count(*)` }).from(artifactEdges).where(and7(eq7(artifactEdges.status, "pending"), isNull(artifactEdges.expiredAt))),
+    try: () => db.select({ count: sql7`count(*)` }).from(artifactEdges).where(and7(eq7(artifactEdges.status, "pending"), isNull(artifactEdges.expiredAt))),
     catch: (cause) => new StoreError({ message: `graphCoverage: pending: ${cause}` })
   });
   const pendingCandidates = totalMemories === 0 ? 0 : Number(pendingRows[0]?.count ?? 0);
@@ -5303,7 +5440,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
       const relRows = await tx.select({ parentKey: topicRelations.parentKey }).from(topicRelations).where(and8(eq8(topicRelations.childKey, membership.topicKey), eq8(topicRelations.modelKey, membership.modelKey), eq8(topicRelations.relationKind, "parent_child")));
       let ancestorKey = relRows[0]?.parentKey;
       while (ancestorKey) {
-        await tx.update(topics).set({ memberCount: sql7`max(0, ${topics.memberCount} - 1)`, updatedAt: Date.now() }).where(and8(eq8(topics.topicKey, ancestorKey), eq8(topics.modelKey, membership.modelKey)));
+        await tx.update(topics).set({ memberCount: sql8`max(0, ${topics.memberCount} - 1)`, updatedAt: Date.now() }).where(and8(eq8(topics.topicKey, ancestorKey), eq8(topics.modelKey, membership.modelKey)));
         const up = await tx.select({ parentKey: topicRelations.parentKey }).from(topicRelations).where(and8(eq8(topicRelations.childKey, ancestorKey), eq8(topicRelations.modelKey, membership.modelKey), eq8(topicRelations.relationKind, "parent_child")));
         ancestorKey = up[0]?.parentKey;
       }
@@ -5597,7 +5734,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
     const now = Date.now();
     yield* Effect25.tryPromise({
       try: () => db.transaction(async (tx) => {
-        await tx.run(sql7`UPDATE ${memories2} SET embedding = CASE id ${sql7.join(entries.map((entry) => sql7`WHEN ${entry.id} THEN ${new Float32Array(entry.embedding).buffer}`), sql7` `)} END, embedding_model = ${modelName} WHERE id IN (${sql7.join(entries.map((entry) => entry.id), sql7`, `)})`);
+        await tx.run(sql8`UPDATE ${memories2} SET embedding = CASE id ${sql8.join(entries.map((entry) => sql8`WHEN ${entry.id} THEN ${new Float32Array(entry.embedding).buffer}`), sql8` `)} END, embedding_model = ${modelName} WHERE id IN (${sql8.join(entries.map((entry) => entry.id), sql8`, `)})`);
         await tx.insert(memoryEvents2).values(entries.map((entry) => ({
           memoryId: entry.id,
           eventType: "embedding_updated",
@@ -5646,7 +5783,7 @@ var makeStore = (backend, modelConfig, topicsOptions, graphConfig, auditOptions,
   });
   const findStale = Effect25.fn("Store.findStale")(function* (model) {
     const rows = yield* Effect25.tryPromise({
-      try: () => db.select({ id: memories2.id }).from(memories2).where(and8(eq8(memories2.state, "active"), sql7`(embedding IS NULL OR embedding_model IS NULL OR embedding_model != ${model})`)),
+      try: () => db.select({ id: memories2.id }).from(memories2).where(and8(eq8(memories2.state, "active"), sql8`(embedding IS NULL OR embedding_model IS NULL OR embedding_model != ${model})`)),
       catch: storeError("Store.findStale")
     });
     return rows.map((row) => row.id);
@@ -6284,6 +6421,7 @@ __export(exports_topics, {
   radiusOf: () => radiusOf,
   mergeOrBorrow: () => mergeOrBorrow,
   memoryEmbedHandler: () => memoryEmbedHandler,
+  memoryEmbedBatchHandler: () => memoryEmbedBatchHandler,
   lloydRefine: () => lloydRefine,
   isActive: () => isActive,
   farthestPair: () => farthestPair,
@@ -6358,7 +6496,7 @@ __export(exports_graph, {
 
 // ../store/src/graph/concepts.ts
 import { Clock as Clock6, Effect as Effect27 } from "effect";
-import { and as and9, asc as asc6, eq as eq9, isNotNull, sql as sql8 } from "drizzle-orm";
+import { and as and9, asc as asc6, eq as eq9, isNotNull, sql as sql9 } from "drizzle-orm";
 var DEFAULT_CLUSTER_K = 8;
 var DEFAULT_CLUSTER_MIN_SIZE = 3;
 var DEFAULT_CLUSTER_PASSES = 2;
@@ -6551,7 +6689,7 @@ var persistClusters = (db, members, config, now) => Effect27.tryPromise({
       }).onConflictDoUpdate({
         target: concepts.id,
         set: {
-          occurrenceCount: sql8`${concepts.occurrenceCount} + 1`,
+          occurrenceCount: sql9`${concepts.occurrenceCount} + 1`,
           lastSeen: now
         }
       });
@@ -6565,7 +6703,7 @@ var persistClusters = (db, members, config, now) => Effect27.tryPromise({
         };
       })).onConflictDoUpdate({
         target: [memoryConcepts.conceptId, memoryConcepts.memoryId],
-        set: { confidence: sql8`excluded.confidence`, assignedAt: now }
+        set: { confidence: sql9`excluded.confidence`, assignedAt: now }
       });
       conceptCount++;
       annotated += memberIndices.length;
@@ -6601,7 +6739,7 @@ function conceptClusterHandler(deps) {
 }
 // ../store/src/graph/dream.ts
 import { Clock as Clock7, Effect as Effect28 } from "effect";
-import { and as and10, asc as asc7, eq as eq10, gt, inArray as inArray5, isNull as isNull3, sql as sql9 } from "drizzle-orm";
+import { and as and10, asc as asc7, eq as eq10, gt, inArray as inArray5, isNull as isNull3, sql as sql10 } from "drizzle-orm";
 var dreamStateDefaults = {
   minHours: 24,
   minNewMemories: 20,
@@ -6732,7 +6870,7 @@ var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
     };
   }
   const sinceCountRows = yield* Effect28.tryPromise({
-    try: () => db.select({ count: sql9`count(*)` }).from(memories).where(gt(memories.createdAt, lastDreamAt)),
+    try: () => db.select({ count: sql10`count(*)` }).from(memories).where(gt(memories.createdAt, lastDreamAt)),
     catch: (cause) => new StoreError({ message: `memory.dream: count new: ${cause}` })
   });
   const memoriesSinceWatermark = Number(sinceCountRows[0]?.count ?? 0);
@@ -6911,7 +7049,7 @@ var runDream = Effect28.fn("MemoryDream.run")(function* (model, classify) {
         if (outcome.inserted)
           created++;
       }
-      const countRows = await tx.select({ count: sql9`count(*)` }).from(memories);
+      const countRows = await tx.select({ count: sql10`count(*)` }).from(memories);
       const totalMemories = Number(countRows[0]?.count ?? 0);
       await tx.insert(dreamState).values({
         modelKey: model.id,
@@ -6950,7 +7088,7 @@ function graphDreamHandler(deps) {
 }
 // ../store/src/graph/repair.ts
 import { Clock as Clock8, Effect as Effect29 } from "effect";
-import { and as and11, eq as eq11, isNotNull as isNotNull2, lt, or as or2, sql as sql10 } from "drizzle-orm";
+import { and as and11, eq as eq11, isNotNull as isNotNull2, lt, or as or2, sql as sql11 } from "drizzle-orm";
 var DEFAULT_EXPIRED_GRACE_MS = 7 * 24 * 60 * 60 * 1000;
 var runRepair = (db, includePurgeExpired, expiredGraceMs, now) => Effect29.tryPromise({
   try: () => db.transaction(async (tx) => {
@@ -6962,15 +7100,15 @@ var runRepair = (db, includePurgeExpired, expiredGraceMs, now) => Effect29.tryPr
       edgeKind: artifactEdges.edgeKind,
       fromMemoryId: artifactEdges.fromMemoryId,
       toMemoryId: artifactEdges.toMemoryId,
-      fromMissing: sql10`NOT EXISTS (
+      fromMissing: sql11`NOT EXISTS (
               SELECT 1 FROM memories WHERE memories.id = ${artifactEdges.fromMemoryId}
             )`,
-      toMissing: sql10`NOT EXISTS (
+      toMissing: sql11`NOT EXISTS (
               SELECT 1 FROM memories WHERE memories.id = ${artifactEdges.toMemoryId}
             )`
-    }).from(artifactEdges).where(or2(sql10`NOT EXISTS (
+    }).from(artifactEdges).where(or2(sql11`NOT EXISTS (
                 SELECT 1 FROM memories WHERE memories.id = ${artifactEdges.fromMemoryId}
-              )`, sql10`NOT EXISTS (
+              )`, sql11`NOT EXISTS (
                 SELECT 1 FROM memories WHERE memories.id = ${artifactEdges.toMemoryId}
               )`));
     for (const row of orphanRows) {
@@ -6993,12 +7131,12 @@ var runRepair = (db, includePurgeExpired, expiredGraceMs, now) => Effect29.tryPr
     const staleRows = await tx.select({
       conceptId: memoryConcepts.conceptId,
       memoryId: memoryConcepts.memoryId,
-      memoryMissing: sql10`NOT EXISTS (
+      memoryMissing: sql11`NOT EXISTS (
               SELECT 1 FROM memories WHERE memories.id = ${memoryConcepts.memoryId}
             )`
-    }).from(memoryConcepts).where(or2(sql10`NOT EXISTS (
+    }).from(memoryConcepts).where(or2(sql11`NOT EXISTS (
                 SELECT 1 FROM concepts WHERE concepts.id = ${memoryConcepts.conceptId}
-              )`, sql10`NOT EXISTS (
+              )`, sql11`NOT EXISTS (
                 SELECT 1 FROM memories WHERE memories.id = ${memoryConcepts.memoryId}
               )`));
     for (const row of staleRows) {
@@ -7321,16 +7459,32 @@ var importFromDisk = () => new Promise((resolve, reject) => {
     reject(cause);
   }
 });
-var buildSessionOptions = (opts) => ({
-  executionProviders: [
-    {
-      name: "cuda",
-      device_id: 0,
-      ...opts.gpuMemLimit !== undefined ? { gpu_mem_limit: opts.gpuMemLimit } : undefined,
-      ...opts.arenaExtendStrategy !== undefined ? { arena_extend_strategy: opts.arenaExtendStrategy } : undefined
-    }
-  ]
-});
+var buildSessionOptions = (opts) => {
+  const cuda = opts.gpuMemLimit !== undefined || opts.arenaExtendStrategy !== undefined;
+  return {
+    enableCpuMemArena: opts.enableCpuMemArena ?? false,
+    ...opts.intraOpNumThreads !== undefined ? { intraOpNumThreads: opts.intraOpNumThreads } : undefined,
+    ...opts.interOpNumThreads !== undefined ? { interOpNumThreads: opts.interOpNumThreads } : undefined,
+    ...opts.executionMode !== undefined ? { executionMode: opts.executionMode } : undefined,
+    ...opts.graphOptimizationLevel !== undefined ? { graphOptimizationLevel: opts.graphOptimizationLevel } : undefined,
+    ...opts.enableMemPattern !== undefined ? { enableMemPattern: opts.enableMemPattern } : undefined,
+    ...cuda ? {
+      executionProviders: [
+        {
+          name: "cuda",
+          device_id: 0,
+          ...opts.gpuMemLimit !== undefined ? { gpu_mem_limit: opts.gpuMemLimit } : undefined,
+          ...opts.arenaExtendStrategy !== undefined ? { arena_extend_strategy: opts.arenaExtendStrategy } : undefined
+        }
+      ]
+    } : undefined
+  };
+};
+var applyWasmOptions = (env, wasm) => {
+  if (wasm?.numThreads === undefined)
+    return;
+  env.backends.onnx.wasm.numThreads = wasm.numThreads;
+};
 var defaults2 = {
   modelId: "Xenova/all-MiniLM-L6-v2",
   device: "cpu",
@@ -7372,10 +7526,11 @@ var make6 = (options) => {
     }));
     if (options.cacheDir)
       transformers.env.cacheDir = options.cacheDir;
+    applyWasmOptions(transformers.env, options.wasm);
     pipe = yield* Effect32.tryPromise(() => transformers.pipeline("feature-extraction", options.modelId ?? defaults2.modelId, {
       device: options.device ?? defaults2.device,
       dtype: options.dtype ?? defaults2.dtype,
-      ...options.sessionOptions !== undefined ? { sessionOptions: buildSessionOptions(options.sessionOptions) } : undefined
+      session_options: buildSessionOptions(options.sessionOptions ?? {})
     })).pipe(Effect32.mapError((cause) => new EmbeddingError({ message: `load model: ${cause}` })));
     return pipe;
   });
@@ -7676,7 +7831,7 @@ var configured8 = (options, deps) => make({
   deps
 });
 // ../llm/src/llm.ts
-import { Cause as Cause3, Effect as Effect36, Option as Option12, Schema as Schema28 } from "effect";
+import { Cause as Cause4, Effect as Effect36, Option as Option12, Schema as Schema28 } from "effect";
 import {
   generateText as generateTextCall,
   NoSuchToolError,
@@ -7733,7 +7888,7 @@ var makeLLM = (model, defaults3 = {}) => {
         ...input.system !== undefined ? { system: input.system } : undefined,
         ...callOptions(input)
       }).then((result) => result.text),
-      catch: (cause) => new LLMError({ message: "LLM text generation failed", cause: Cause3.die(cause) })
+      catch: (cause) => new LLMError({ message: "LLM text generation failed", cause: Cause4.die(cause) })
     });
     yield* Effect36.logDebug("llm.generate-text").pipe(Effect36.annotateLogs({
       scope: "@dimple/llm",
@@ -7785,7 +7940,7 @@ ${schemaJson}`,
           return Promise.reject(extracted.error);
         return input.schema.parse(extracted.value);
       },
-      catch: (cause) => new LLMError({ message: "LLM structured generation failed", cause: Cause3.die(cause) })
+      catch: (cause) => new LLMError({ message: "LLM structured generation failed", cause: Cause4.die(cause) })
     });
     yield* Effect36.logDebug("llm.generate-object").pipe(Effect36.annotateLogs({
       scope: "@dimple/llm",
@@ -7897,7 +8052,8 @@ var embedderFromConfig = (model) => model.provider === "transformers" ? Effect39
   ...model.normalize !== undefined ? { normalize: model.normalize } : undefined,
   ...model.cacheDir !== undefined ? { cacheDir: model.cacheDir } : undefined,
   ...model.autoInstall !== undefined ? { autoInstall: model.autoInstall } : undefined,
-  ...model.sessionOptions !== undefined ? { sessionOptions: model.sessionOptions } : undefined
+  ...model.sessionOptions !== undefined ? { sessionOptions: model.sessionOptions } : undefined,
+  ...model.wasm !== undefined ? { wasm: model.wasm } : undefined
 })) : model.provider === "openai" ? model.apiKey === undefined ? Effect39.fail(new EmbeddingError({ message: `OpenAI model ${model.id} requires an apiKey` })) : Effect39.succeed(makeHostedEmbeddingModel({
   modelId: model.id,
   model: model.model,
@@ -7987,6 +8143,13 @@ var layer13 = (options) => {
       config: topicConfig,
       backend
     }));
+    yield* register("memory.embed.batch", exports_topics.memoryEmbedBatchHandler({
+      getModelConfig,
+      embedOne: (text4, model) => options.embedderFor(model).pipe(Effect39.flatMap((m) => m.embedSingle(text4))),
+      getMemoryContent: (memoryId) => store2.get(memoryId).pipe(Effect39.map((m) => m.content)),
+      config: topicConfig,
+      backend
+    }));
     yield* register("concept.cluster", exports_graph.conceptClusterHandler({ getModelConfig, config: graphConfig, backend }));
     if (options.llm !== undefined) {
       yield* register("memory.dream", exports_graph.graphDreamHandler({
@@ -8062,6 +8225,13 @@ var layerConfig7 = (options) => Layer15.unwrap(Effect39.gen(function* () {
     });
   }
   const llm = cfg.config.llm;
+  const models2 = embedding.models.map((model) => {
+    const sessionOptions = mergeSessionOptions(embedding.sessionOptions, model.sessionOptions);
+    return {
+      ...model,
+      ...sessionOptions !== undefined ? { sessionOptions } : undefined
+    };
+  });
   return layer13({
     storeUrl: cfg.config.storeUrl,
     ...cfg.config.defaultK !== undefined ? { defaultK: cfg.config.defaultK } : undefined,
@@ -8069,7 +8239,7 @@ var layerConfig7 = (options) => Layer15.unwrap(Effect39.gen(function* () {
     ...cfg.config.defaultTtlSecs !== undefined ? { defaultTtlSecs: cfg.config.defaultTtlSecs } : undefined,
     jobsUrl,
     ...options?.migrationFolder !== undefined ? { migrationFolder: options.migrationFolder } : undefined,
-    models: embedding.models,
+    models: models2,
     defaultModelId: embedding.defaultModel,
     embedderFor: embedderFromConfig,
     ...cfg.config.topics !== undefined ? { topics: { config: cfg.config.topics } } : undefined,
@@ -8204,7 +8374,7 @@ var remapError = (cause) => {
 };
 
 // src/make.ts
-import { Effect as Effect50, Exit as Exit7, Layer as Layer26, ManagedRuntime, Scope as Scope5 } from "effect";
+import { Effect as Effect50, Exit as Exit8, Layer as Layer26, ManagedRuntime, Scope as Scope5 } from "effect";
 
 // ../extractor/src/code-extractor.ts
 import { Context as Context13, Effect as Effect40, Layer as Layer16 } from "effect";
@@ -9098,7 +9268,7 @@ var resolveConfigInput = Effect48.fn("Sdk.resolveConfigInput")(function* (input)
 var configLayerFromInput = (input) => Layer25.effect(Service4, resolveConfigInput(input).pipe(Effect48.map((config) => Service4.of({ config }))));
 
 // src/dimple.ts
-import { Cause as Cause4, Effect as Effect49, Exit as Exit6, Option as Option15, Schema as Schema40 } from "effect";
+import { Cause as Cause5, Effect as Effect49, Exit as Exit7, Option as Option15, Schema as Schema40 } from "effect";
 
 // src/indexer.ts
 import { execFileSync } from "node:child_process";
@@ -9585,6 +9755,8 @@ var makeFacade = (state, reload, dispose) => {
       const keyPrefix = options.keyPrefix ?? "code-";
       const namespace = options.namespace;
       const embed = options.embed !== false;
+      const deferEmbed = embed && options.deferEmbed === true;
+      const embedUnits = embed && !deferEmbed;
       const maxFileBytes = options.maxFileBytes ?? 64 * 1024;
       const maxChunkBytes = options.maxChunkBytes ?? 8 * 1024;
       const extensions = [...options.extensions ?? INDEXABLE_EXTENSIONS];
@@ -9602,6 +9774,7 @@ var makeFacade = (state, reload, dispose) => {
       let skipped = 0;
       const unitIds = new Map;
       const freshIds = [];
+      const pendingEmbedIds = [];
       const pendingEdges = [];
       const pendingCallEdges = [];
       const stableChunkId = (chunkId) => chunkId.replace(/:\d+$/, "");
@@ -9612,6 +9785,8 @@ var makeFacade = (state, reload, dispose) => {
           return;
         return parentAndMethod.split(".")[0];
       };
+      if (embedUnits)
+        yield* core().store.ensureTopicTree(core().defaultModel.id);
       for (const filePath of walk.files) {
         const relative = keyForPath(walk.root, filePath);
         const language = languageForPath(filePath);
@@ -9629,77 +9804,143 @@ var makeFacade = (state, reload, dispose) => {
           let upd = 0;
           let dups = 0;
           const fileKey = `${keyPrefix}${relative}`;
-          const fileOutcome = yield* upsertUnit({
-            logicalKey: fileKey,
-            content: source,
-            ...namespace !== undefined ? { namespace } : undefined,
-            ttlSecs: null,
-            metadata: JSON.stringify({
-              filePath,
-              language,
-              kind: "file",
-              imports: extracted.imports ?? [],
-              ...commit !== null ? { codeVersion: commit } : undefined
-            }),
-            contentType: `text/x-${language}`
-          }, embed);
-          if (fileOutcome.kind === "skipped") {
-            dups += 1;
-            unitIds.set(fileKey, fileOutcome.id);
-          } else {
-            if (fileOutcome.kind === "updated")
-              upd += 1;
-            else
-              units += 1;
-            unitIds.set(fileKey, fileOutcome.id);
-            freshIds.push(fileOutcome.id);
-          }
           const classKeys = new Map;
           for (const chunk of extracted.chunks) {
             if (chunk.kind === "class" || chunk.kind.endsWith("class")) {
               classKeys.set(chunk.name, chunkKeyOf(chunk.id));
             }
           }
+          const specs = [
+            {
+              key: fileKey,
+              input: {
+                logicalKey: fileKey,
+                content: source,
+                ...namespace !== undefined ? { namespace } : undefined,
+                ttlSecs: null,
+                metadata: JSON.stringify({
+                  filePath,
+                  language,
+                  kind: "file",
+                  imports: extracted.imports ?? [],
+                  ...commit !== null ? { codeVersion: commit } : undefined
+                }),
+                contentType: `text/x-${language}`
+              }
+            }
+          ];
           for (const chunk of extracted.chunks) {
             const chunkKey = chunkKeyOf(chunk.id);
             const content = [chunk.docstring, chunk.sourceText].filter((c) => c !== undefined && c.length > 0).join(`
 
 `).slice(0, maxChunkBytes);
-            const chunkOutcome = yield* upsertUnit({
-              logicalKey: chunkKey,
-              content,
-              ...namespace !== undefined ? { namespace } : undefined,
-              ttlSecs: null,
-              metadata: JSON.stringify({
-                filePath,
-                language,
-                kind: chunk.kind,
-                name: chunk.name,
-                startLine: chunk.startLine,
-                endLine: chunk.endLine,
-                ...chunk.docstring !== undefined ? { docstring: chunk.docstring } : undefined,
-                ...commit !== null ? { codeVersion: commit } : undefined
-              }),
-              contentType: `text/x-${language}`
-            }, embed);
-            if (chunkOutcome.kind === "skipped") {
+            const parent = chunk.kind === "method" ? parentClassOf(chunk.id) : undefined;
+            const classKey = parent === undefined ? undefined : classKeys.get(parent);
+            specs.push({
+              key: chunkKey,
+              input: {
+                logicalKey: chunkKey,
+                content,
+                ...namespace !== undefined ? { namespace } : undefined,
+                ttlSecs: null,
+                metadata: JSON.stringify({
+                  filePath,
+                  language,
+                  kind: chunk.kind,
+                  name: chunk.name,
+                  startLine: chunk.startLine,
+                  endLine: chunk.endLine,
+                  ...chunk.docstring !== undefined ? { docstring: chunk.docstring } : undefined,
+                  ...commit !== null ? { codeVersion: commit } : undefined
+                }),
+                contentType: `text/x-${language}`
+              },
+              ...classKey !== undefined ? { containedBy: classKey } : undefined
+            });
+          }
+          const outcomes = new Map;
+          const record = (key, kind, id) => {
+            outcomes.set(key, kind);
+            if (kind === "skipped") {
               dups += 1;
-              unitIds.set(chunkKey, chunkOutcome.id);
-            } else {
-              if (chunkOutcome.kind === "updated")
-                upd += 1;
-              else
-                units += 1;
-              unitIds.set(chunkKey, chunkOutcome.id);
-              freshIds.push(chunkOutcome.id);
+              unitIds.set(key, id);
+              return;
             }
-            if (chunkOutcome.kind !== "skipped" && chunk.kind === "method") {
-              const parent = parentClassOf(chunk.id);
-              const classKey = parent === undefined ? undefined : classKeys.get(parent);
-              if (classKey !== undefined) {
-                pendingEdges.push({ from: classKey, to: chunkKey });
+            if (kind === "updated")
+              upd += 1;
+            else
+              units += 1;
+            unitIds.set(key, id);
+            freshIds.push(id);
+          };
+          const upsertAll = (candidates2) => Effect49.gen(function* () {
+            const ids = [];
+            for (const spec of candidates2) {
+              const outcome = yield* upsertUnit(spec.input, embedUnits);
+              record(spec.key, outcome.kind, outcome.id);
+              ids.push(outcome.id);
+            }
+            return ids;
+          });
+          if (deferEmbed) {
+            const fresh = [];
+            for (const spec of specs) {
+              const existing = yield* core().store.getByKey(spec.key, namespace ?? "default").pipe(Effect49.catchTag("Store.NotFound", () => Effect49.succeed(undefined)));
+              if (existing === undefined) {
+                fresh.push(spec);
+                continue;
+              }
+              const outcome = yield* upsertUnit(spec.input, false);
+              record(spec.key, outcome.kind, outcome.id);
+              if (outcome.kind !== "skipped" || existing.embedding == null || existing.embeddingModel !== core().defaultModel.id) {
+                pendingEmbedIds.push(outcome.id);
               }
             }
+            if (fresh.length > 0) {
+              const freshKeys = fresh.map((spec) => spec.key);
+              if (new Set(freshKeys).size !== freshKeys.length) {
+                pendingEmbedIds.push(...yield* upsertAll(fresh));
+              } else {
+                const mems = yield* core().store.writeMany(fresh.map((spec) => spec.input));
+                for (const mem of mems) {
+                  record(mem.logicalKey, "indexed", mem.id);
+                  pendingEmbedIds.push(mem.id);
+                }
+              }
+            }
+          } else if (!embedUnits) {
+            yield* upsertAll(specs);
+          } else {
+            const fresh = [];
+            for (const spec of specs) {
+              const existing = yield* core().store.getByKey(spec.key, namespace ?? "default").pipe(Effect49.catchTag("Store.NotFound", () => Effect49.succeed(undefined)));
+              if (existing === undefined) {
+                fresh.push(spec);
+                continue;
+              }
+              const outcome = yield* upsertUnit(spec.input, embed);
+              record(spec.key, outcome.kind, outcome.id);
+            }
+            if (fresh.length > 0) {
+              const freshKeys = fresh.map((spec) => spec.key);
+              if (new Set(freshKeys).size !== freshKeys.length) {
+                yield* upsertAll(fresh);
+              } else {
+                const mems = yield* core().store.writeMany(fresh.map((spec) => spec.input));
+                const vectors = [];
+                for (const spec of fresh) {
+                  vectors.push(yield* core().defaultEmbedder.embedSingle(spec.input.content));
+                }
+                yield* core().store.updateEmbeddingMany(mems.map((mem, i) => ({ id: mem.id, embedding: [...vectors[i]] })), core().defaultModel.id);
+                for (const mem of mems)
+                  record(mem.logicalKey, "indexed", mem.id);
+              }
+            }
+          }
+          for (const spec of specs) {
+            if (spec.containedBy !== undefined && outcomes.get(spec.key) !== "skipped") {
+              pendingEdges.push({ from: spec.containedBy, to: spec.key });
+            }
           }
           const importTargets = resolveImports(filePath, (extracted.imports ?? []).map((imp) => imp.source), extensions);
           for (const target of importTargets) {
@@ -9726,8 +9967,8 @@ var makeFacade = (state, reload, dispose) => {
           }
           return { units, upd, dups };
         }));
-        if (Exit6.isFailure(exit)) {
-          failed.push({ filePath, message: Cause4.pretty(exit.cause) });
+        if (Exit7.isFailure(exit)) {
+          failed.push({ filePath, message: Cause5.pretty(exit.cause) });
         } else {
           indexed += exit.value.units;
           updated += exit.value.upd;
@@ -9762,6 +10003,16 @@ var makeFacade = (state, reload, dispose) => {
       for (const edge of pendingCallEdges) {
         yield* Effect49.exit(edgeEffect({ ...edge, edgeKind: "code_calls" }));
       }
+      const EMBED_BATCH = 512;
+      if (deferEmbed) {
+        for (let i = 0;i < pendingEmbedIds.length; i += EMBED_BATCH) {
+          yield* core().runtime.enqueue(MemoryEmbedBatch, {
+            memoryIds: pendingEmbedIds.slice(i, i + EMBED_BATCH),
+            modelKey: core().defaultModel.id,
+            nonce: crypto.randomUUID()
+          });
+        }
+      }
       return {
         files: walk.files.length,
         indexed,
@@ -9770,7 +10021,8 @@ var makeFacade = (state, reload, dispose) => {
         skipped,
         unsupported: walk.unsupported,
         commit,
-        failed
+        failed,
+        ...deferEmbed ? { pendingEmbeddings: pendingEmbedIds.length } : undefined
       };
     })),
     updateEmbedding: (id, embedding, modelKey) => run(Effect49.gen(function* () {
@@ -9857,10 +10109,10 @@ var bootStack = async (options) => {
       core,
       parser,
       extractor,
-      dispose: () => Effect50.runPromise(Scope5.close(scope, Exit7.void).pipe(Effect50.andThen(rt.disposeEffect)))
+      dispose: () => Effect50.runPromise(Scope5.close(scope, Exit8.void).pipe(Effect50.andThen(rt.disposeEffect)))
     };
   } catch (cause) {
-    await Effect50.runPromise(Scope5.close(scope, Exit7.void).pipe(Effect50.andThen(runtime?.disposeEffect ?? Effect50.void))).catch(() => {
+    await Effect50.runPromise(Scope5.close(scope, Exit8.void).pipe(Effect50.andThen(runtime?.disposeEffect ?? Effect50.void))).catch(() => {
       return;
     });
     return Promise.reject(cause);