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

package/dist/dimple.d.ts

@@ -55,6 +55,12 @@ export interface IndexOptions {
     readonly namespace?: string;
     /** Embed + topic-route every unit (default true). */
     readonly embed?: boolean;
+    /** Write the units and hand every one that needs a vector to the durable
+     * `memory.embed.batch` job instead of embedding inline: units are stored
+     * (and lexically searchable) when `index` returns, vectors + topic routing
+     * land whenever a worker drains the queue. Ignored when `embed` is
+     * `false`. */
+    readonly deferEmbed?: boolean;
     /** Cap for the whole-file memory content (default 64 KiB). */
     readonly maxFileBytes?: number;
     /** Cap for each extracted chunk's content (default 8 KiB). */
@@ -83,6 +89,10 @@ export interface IndexResult {
     readonly skipped: number;
     /** Files skipped because the extension is not indexable. */
     readonly unsupported: number;
+    /** `memory.embed.batch` jobs enqueued by the deferred path (`deferEmbed`) —
+     * units stored without a vector, counted after the enqueue. Absent in the
+     * synchronous path, where every unit is embedded before returning. */
+    readonly pendingEmbeddings?: number;
     readonly commit: string | null;
     /** Files that could not be walked/read/parsed/extracted/written. */
     readonly failed: readonly {

package/dist/errors.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";
@@ -2736,8 +2736,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 +2820,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 +2887,7 @@ var AuditWrite = JobDefinition.make("audit.write", {
 var queues = [
   TopicSplit,
   MemoryEmbed,
+  MemoryEmbedBatch,
   TopicMerge,
   TopicRebalance,
   ConceptCluster,
@@ -3703,46 +3714,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 +3851,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 +3954,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 +4644,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 +4688,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 +4744,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 +4769,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 +4783,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 +5404,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 +5698,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 +5747,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 +6385,7 @@ __export(exports_topics, {
   radiusOf: () => radiusOf,
   mergeOrBorrow: () => mergeOrBorrow,
   memoryEmbedHandler: () => memoryEmbedHandler,
+  memoryEmbedBatchHandler: () => memoryEmbedBatchHandler,
   lloydRefine: () => lloydRefine,
   isActive: () => isActive,
   farthestPair: () => farthestPair,
@@ -6358,7 +6460,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 +6653,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 +6667,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 +6703,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 +6834,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 +7013,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 +7052,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 +7064,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 +7095,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) {
@@ -7375,7 +7477,10 @@ var make6 = (options) => {
     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: {
+        enableCpuMemArena: false,
+        ...options.sessionOptions !== undefined ? buildSessionOptions(options.sessionOptions) : undefined
+      }
     })).pipe(Effect32.mapError((cause) => new EmbeddingError({ message: `load model: ${cause}` })));
     return pipe;
   });
@@ -7676,7 +7781,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 +7838,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 +7890,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",
@@ -7987,6 +8092,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({