@effect-agent/storage-memory 0.1.0-beta.39 → 0.1.0-beta.40

package/dist/index.d.mts

@@ -1,5 +1,6 @@
+import { MemoryIndexError, SemanticMemoryIndex, SemanticMemoryProfile } from "@effect-agent/core";
 import { ScheduleStore, SourcePartition, SubmissionLedger, SubscriptionError, SubscriptionStore, ThreadStore } from "@effect-agent/thread";
-import { Crypto, Effect, Layer, Option } from "effect";
+import { Crypto, Effect, Layer, Option, Schema } from "effect";
 //#region src/memory-ledger.d.ts
 /** Construction options for the in-memory reference SubmissionLedger. */
 interface MemorySubmissionLedgerOptions {
@@ -33,5 +34,20 @@ declare const MemoryThreadStoreLive: Layer.Layer<ThreadStore, never, Crypto.Cryp
  */
 declare const MemoryStorageLive: Layer.Layer<ThreadStore, never, Crypto.Crypto>;
 //#endregion
-export { MemoryScheduleStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, MemorySubmissionLedgerOptions, MemoryThreadStoreLive, memoryScheduleStoreLayer, memorySubmissionLedgerLayer, memorySubscriptionStoreLayer };
+//#region src/semantic-memory-index.d.ts
+declare const InMemorySemanticIndexCapacity_base: Schema.Class<InMemorySemanticIndexCapacity, Schema.Struct<{
+  readonly maxSources: Schema.Int;
+  readonly maxChunks: Schema.Int;
+  readonly maxSourceBytes: Schema.optionalKey<Schema.Int>;
+}>, {}>;
+/**
+ * Hard per-Layer bounds for disposable semantic index state. maxChunks times profile dimensions
+ * must not exceed 16,777,216 vector components. maxSourceBytes bounds the aggregate UTF-8 JSON
+ * of retained source identities and defaults to 16 MiB; it is not a general heap limit.
+ */
+declare class InMemorySemanticIndexCapacity extends InMemorySemanticIndexCapacity_base {}
+/** Scoped disposable semantic index. No persistent build or recovery state is retained. */
+declare const inMemorySemanticIndexLayer: (profile: SemanticMemoryProfile, capacity: InMemorySemanticIndexCapacity) => Layer.Layer<SemanticMemoryIndex, MemoryIndexError>;
+//#endregion
+export { InMemorySemanticIndexCapacity, MemoryScheduleStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, MemorySubmissionLedgerOptions, MemoryThreadStoreLive, inMemorySemanticIndexLayer, memoryScheduleStoreLayer, memorySubmissionLedgerLayer, memorySubscriptionStoreLayer };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { AttemptId, ReceiptId, SubmissionId, ThreadId } from "@effect-agent/core";
+import { AttemptId, MemoryIndexCandidate, MemoryIndexError, MemoryIndexQuery, MemoryIndexReplacement, MemoryIndexSearch, MemoryIndexSource, MemoryKey, ReceiptId, SemanticMemoryChunk, SemanticMemoryIndex, SemanticMemoryProfile, SubmissionId, ThreadId } from "@effect-agent/core";
 import { AbortCommand, AbortIntent, AcceptedEvent, AdmissionAdmitted, AdmissionConflict, AdmissionIndeterminate, AdmissionNotAdmitted, AdmissionRequest, AdmissionResult, AppendConflict, AppendResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, CanonicalRecordEnvelope, CanonicalSequence, CheckpointRejected, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, DEFAULT_OWNERSHIP_LEASE_DURATION, DeliveryChange, Digest, EMPTY_TAIL_DIGEST, FenceRejected, FencedAppendRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, LoadCheckpointRequest, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, ObservationOffset, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, OwnershipToken, PersistedJson, ProducerEpoch, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, SaveCheckpointRequest, ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, Settlement, SettlementConflict, SettlementFinalization, SettlementReservation, SettlementReservationSnapshot, SourcePartition, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SubscriptionDelivery, SubscriptionDeliveryKey, SubscriptionError, SubscriptionFailpoint, SubscriptionKey, SubscriptionLimits, SubscriptionName, SubscriptionRecord, SubscriptionScanCursors, SubscriptionStore, SuspendRequest, SuspensionSnapshot, ThreadExport, ThreadExportRequest, ThreadMaterialization, ThreadNotMaterialized, ThreadObservation, ThreadRead, ThreadStore, ThreadStoreError, ThreadTail, ThreadTailRequest, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, applyScheduleChange, applySubscriptionDeliveryChange, compareScheduleKeys, compareScheduleNames, defaultSchedulingLimits, digestCanonicalBatch, scheduleDeadline, scheduleKeyOf, scheduleKeyString, scheduleOwnerKey, scheduleUsesCapacity, settlementFailureFromRecord, subscriptionCanSelect, subscriptionDeliveryCanSelect, subscriptionDeliveryKeyString, subscriptionKeyString } from "@effect-agent/thread";
 import { Clock, Crypto, DateTime, Duration, Effect, Encoding, Layer, Option, PubSub, Ref, Result, Schema, Stream } from "effect";
 //#region src/memory-ledger.ts
@@ -1151,22 +1151,22 @@ const memoryScheduleStoreLayer = () => Layer.effect(ScheduleStore, makeScheduleS
 const MemoryScheduleStoreLive = memoryScheduleStoreLayer();
 //#endregion
 //#region src/memory-subscription-store.ts
-const error = (reason, code) => SubscriptionError.make({
+const error$1 = (reason, code) => SubscriptionError.make({
 	reason,
 	code
 });
 const samePartition = (left, right) => left.tenantId === right.tenantId && left.address === right.address;
-const sameSource = (left, right) => left.name === right.name && left.version === right.version;
+const sameSource$1 = (left, right) => left.name === right.name && left.version === right.version;
 const encode = (schema, value, code) => Result.try({
 	try: () => Schema.encodeSync(Schema.fromJsonString(schema))(value),
-	catch: () => error("corrupt", code)
+	catch: () => error$1("corrupt", code)
 });
 const decode = (schema, value, code) => Result.try({
 	try: () => Schema.decodeSync(Schema.fromJsonString(schema))(value),
-	catch: () => error("corrupt", code)
+	catch: () => error$1("corrupt", code)
 });
 const decodeEffect = (schema, value, code) => Effect.fromResult(decode(schema, value, code));
-const validate$1 = (schema, value, code) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => error("validation", code)));
+const validate$1 = (schema, value, code) => Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError(() => error$1("validation", code)));
 const jsonBytes = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
 const sameDeliveryIdentity = (left, right) => subscriptionDeliveryKeyString(left.key) === subscriptionDeliveryKeyString(right.key) && left.deliveryId === right.deliveryId && left.source.name === right.source.name && left.source.version === right.source.version && left.threadId === right.threadId && left.admissionKey === right.admissionKey && left.subscriptionFingerprint === right.subscriptionFingerprint && left.eventDigest === right.eventDigest;
 const candidateIndexKey = (record) => JSON.stringify([
@@ -1179,8 +1179,8 @@ const eventCandidateIndexKey = (event) => JSON.stringify([
 	event.source.version,
 	event.matchingKey
 ]);
-const sameEventIdentity = (left, right) => samePartition(left.partition, right.partition) && left.eventId === right.eventId && sameSource(left.source, right.source) && left.matchingKey === right.matchingKey && left.payloadDigest === right.payloadDigest;
-const deliveryBelongsTo = (delivery, record, event) => subscriptionKeyString(delivery.key.subscription) === subscriptionKeyString(record.key) && delivery.key.eventId === event.eventId && sameSource(delivery.source, event.source);
+const sameEventIdentity = (left, right) => samePartition(left.partition, right.partition) && left.eventId === right.eventId && sameSource$1(left.source, right.source) && left.matchingKey === right.matchingKey && left.payloadDigest === right.payloadDigest;
+const deliveryBelongsTo = (delivery, record, event) => subscriptionKeyString(delivery.key.subscription) === subscriptionKeyString(record.key) && delivery.key.eventId === event.eventId && sameSource$1(delivery.source, event.source);
 const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(function* (ownedPartition) {
 	const partition = yield* validate$1(SourcePartition, ownedPartition, "partition");
 	const state = yield* Ref.make({
@@ -1201,7 +1201,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		}
 	});
 	const failpoint = yield* SubscriptionFailpoint;
-	const requirePartition = (value, code) => samePartition(value.partition, partition) ? Effect.succeed(value) : Effect.fail(error("validation", code));
+	const requirePartition = (value, code) => samePartition(value.partition, partition) ? Effect.succeed(value) : Effect.fail(error$1("validation", code));
 	const requireKey = (key, code) => validate$1(SubscriptionKey, key, code).pipe(Effect.flatMap((decoded) => requirePartition(decoded, code)));
 	const register = Effect.fn("MemorySubscriptionStore.register")(function* (input, inputLimits) {
 		const record = yield* validate$1(SubscriptionRecord, input, "register-record");
@@ -1214,14 +1214,14 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			if (existingText !== void 0) {
 				const existing = decode(SubscriptionRecord, existingText, "register-existing");
 				if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
-				return existing.success.creationFingerprint === record.creationFingerprint ? [Result.succeed(existing.success), current] : [Result.fail(error("conflict", "registration-identity")), current];
+				return existing.success.creationFingerprint === record.creationFingerprint ? [Result.succeed(existing.success), current] : [Result.fail(error$1("conflict", "registration-identity")), current];
 			}
-			if (jsonBytes(record.configuration.context) > limits.maxContextBytes) return [Result.fail(error("capacity", "context-bytes")), current];
-			if (jsonBytes(record.configuration.parameters) > limits.maxPayloadBytes) return [Result.fail(error("capacity", "parameters-bytes")), current];
-			if (record.configuration.expiresAtMillis - record.createdAtMillis > limits.maxLifetimeMillis) return [Result.fail(error("capacity", "lifetime")), current];
-			if (current.registrations.size >= limits.maxRegistrations) return [Result.fail(error("capacity", "registrations")), current];
+			if (jsonBytes(record.configuration.context) > limits.maxContextBytes) return [Result.fail(error$1("capacity", "context-bytes")), current];
+			if (jsonBytes(record.configuration.parameters) > limits.maxPayloadBytes) return [Result.fail(error$1("capacity", "parameters-bytes")), current];
+			if (record.configuration.expiresAtMillis - record.createdAtMillis > limits.maxLifetimeMillis) return [Result.fail(error$1("capacity", "lifetime")), current];
+			if (current.registrations.size >= limits.maxRegistrations) return [Result.fail(error$1("capacity", "registrations")), current];
 			const ownerCount = current.ownerRegistrationCounts.get(record.key.ownerId) ?? 0;
-			if (ownerCount >= limits.maxRegistrationsPerOwner) return [Result.fail(error("capacity", "owner-registrations")), current];
+			if (ownerCount >= limits.maxRegistrationsPerOwner) return [Result.fail(error$1("capacity", "owner-registrations")), current];
 			const assigned = {
 				...record,
 				ordinal: current.sequence + 1
@@ -1260,13 +1260,13 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		return text === void 0 ? null : yield* decodeEffect(SubscriptionRecord, text, "get-record");
 	});
 	const list = Effect.fn("MemorySubscriptionStore.list")(function* (ownerId, after, limit) {
-		if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit <= 0) return yield* error("validation", "list-page");
+		if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit <= 0) return yield* error$1("validation", "list-page");
 		const current = yield* Ref.get(state);
 		const records = [];
 		for (const [storageKey, indexed] of current.registrationIndex) {
 			if (indexed.key.ownerId !== ownerId || indexed.ordinal <= after) continue;
 			const text = current.registrations.get(storageKey);
-			if (text === void 0) return yield* error("corrupt", "list-index");
+			if (text === void 0) return yield* error$1("corrupt", "list-index");
 			records.push(yield* decodeEffect(SubscriptionRecord, text, "list-record"));
 		}
 		records.sort((a, b) => a.ordinal - b.ordinal);
@@ -1278,7 +1278,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
 			const storageKey = subscriptionKeyString(key);
 			const text = current.registrations.get(storageKey);
-			if (text === void 0) return [Result.fail(error("not-found", "subscription")), current];
+			if (text === void 0) return [Result.fail(error$1("not-found", "subscription")), current];
 			const decoded = decode(SubscriptionRecord, text, "cancel-record");
 			if (Result.isFailure(decoded)) return [decoded, current];
 			if (decoded.success.state === "cancelled") return [Result.succeed(decoded.success), current];
@@ -1293,7 +1293,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			registrations.set(storageKey, encoded.success);
 			const registrationIndex = new Map(current.registrationIndex);
 			const indexed = registrationIndex.get(storageKey);
-			if (indexed === void 0) return [Result.fail(error("corrupt", "cancel-index")), current];
+			if (indexed === void 0) return [Result.fail(error$1("corrupt", "cancel-index")), current];
 			registrationIndex.set(storageKey, {
 				...indexed,
 				state: "cancelled",
@@ -1318,10 +1318,10 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			if (existingText !== void 0) {
 				const existing = decode(AcceptedEvent, existingText, "accept-existing");
 				if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
-				return sameEventIdentity(existing.success, event) ? [Result.succeed(existing.success), current] : [Result.fail(error("conflict", "event-identity")), current];
+				return sameEventIdentity(existing.success, event) ? [Result.succeed(existing.success), current] : [Result.fail(error$1("conflict", "event-identity")), current];
 			}
-			if (jsonBytes(event.payload) > limits.maxPayloadBytes) return [Result.fail(error("capacity", "payload-bytes")), current];
-			if (current.events.size >= limits.maxEvents) return [Result.fail(error("capacity", "events")), current];
+			if (jsonBytes(event.payload) > limits.maxPayloadBytes) return [Result.fail(error$1("capacity", "payload-bytes")), current];
+			if (current.events.size >= limits.maxEvents) return [Result.fail(error$1("capacity", "events")), current];
 			const accepted = {
 				...event,
 				cutoff: current.sequence + 1,
@@ -1362,15 +1362,15 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		const accepted = yield* validate$1(AcceptedEvent, input, "candidates-event");
 		yield* requirePartition(accepted, "candidates-partition");
 		const stored = yield* event(accepted.eventId);
-		if (stored === null || !sameEventIdentity(stored, accepted)) return yield* error(stored === null ? "not-found" : "conflict", "event");
+		if (stored === null || !sameEventIdentity(stored, accepted)) return yield* error$1(stored === null ? "not-found" : "conflict", "event");
 		const current = yield* Ref.get(state);
 		const records = [];
 		for (const storageKey of current.candidateIndex.get(eventCandidateIndexKey(stored)) ?? []) {
 			const indexed = current.registrationIndex.get(storageKey);
-			if (indexed === void 0) return yield* error("corrupt", "candidate-index");
+			if (indexed === void 0) return yield* error$1("corrupt", "candidate-index");
 			if (indexed.ordinal <= stored.cursor || indexed.ordinal > stored.cutoff) continue;
 			const text = current.registrations.get(storageKey);
-			if (text === void 0) return yield* error("corrupt", "candidate-record");
+			if (text === void 0) return yield* error$1("corrupt", "candidate-record");
 			records.push(yield* decodeEffect(SubscriptionRecord, text, "candidate-record"));
 		}
 		records.sort((a, b) => a.ordinal - b.ordinal);
@@ -1385,13 +1385,13 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		const effectiveNowMillis = Math.max(nowMillis, yield* Clock.currentTimeMillis);
 		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
 			const eventText = current.events.get(suppliedEvent.eventId);
-			if (eventText === void 0) return [Result.fail(error("not-found", "event")), current];
+			if (eventText === void 0) return [Result.fail(error$1("not-found", "event")), current];
 			const decodedEvent = decode(AcceptedEvent, eventText, "select-event-record");
 			if (Result.isFailure(decodedEvent)) return [Result.fail(decodedEvent.failure), current];
 			const accepted = decodedEvent.success;
-			if (!sameEventIdentity(accepted, suppliedEvent) || suppliedEvent.cursor !== accepted.cursor) return [Result.fail(error("conflict", "event-cursor")), current];
-			if (accepted.routingComplete) return [complete && cursor === accepted.cursor ? Result.void : Result.fail(error("conflict", "routing-complete")), current];
-			if (!Number.isSafeInteger(cursor) || cursor < accepted.cursor || cursor > accepted.cutoff) return [Result.fail(error("validation", "cursor")), current];
+			if (!sameEventIdentity(accepted, suppliedEvent) || suppliedEvent.cursor !== accepted.cursor) return [Result.fail(error$1("conflict", "event-cursor")), current];
+			if (accepted.routingComplete) return [complete && cursor === accepted.cursor ? Result.void : Result.fail(error$1("conflict", "routing-complete")), current];
+			if (!Number.isSafeInteger(cursor) || cursor < accepted.cursor || cursor > accepted.cutoff) return [Result.fail(error$1("validation", "cursor")), current];
 			const additions = [];
 			const updates = [];
 			const additionIndex = [];
@@ -1399,17 +1399,17 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			const owners = new Map(current.ownerDeliveryCounts);
 			for (const delivery of deliveries) {
 				const recordText = current.registrations.get(subscriptionKeyString(delivery.key.subscription));
-				if (recordText === void 0) return [Result.fail(error("not-found", "subscription")), current];
+				if (recordText === void 0) return [Result.fail(error$1("not-found", "subscription")), current];
 				const record = decode(SubscriptionRecord, recordText, "select-registration");
 				if (Result.isFailure(record)) return [Result.fail(record.failure), current];
-				if (!deliveryBelongsTo(delivery, record.success, accepted) || !subscriptionDeliveryCanSelect(delivery, record.success, accepted) || record.success.ordinal <= accepted.cursor || record.success.ordinal > cursor) return [Result.fail(error("conflict", "selection")), current];
+				if (!deliveryBelongsTo(delivery, record.success, accepted) || !subscriptionDeliveryCanSelect(delivery, record.success, accepted) || record.success.ordinal <= accepted.cursor || record.success.ordinal > cursor) return [Result.fail(error$1("conflict", "selection")), current];
 				if (!subscriptionCanSelect(record.success, accepted, effectiveNowMillis, false)) continue;
 				const deliveryKey = subscriptionDeliveryKeyString(delivery.key);
 				const existingText = current.deliveries.get(deliveryKey);
 				if (existingText !== void 0) {
 					const existing = decode(SubscriptionDelivery, existingText, "select-existing");
 					if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
-					if (!sameDeliveryIdentity(existing.success, delivery)) return [Result.fail(error("conflict", "delivery-identity")), current];
+					if (!sameDeliveryIdentity(existing.success, delivery)) return [Result.fail(error$1("conflict", "delivery-identity")), current];
 					continue;
 				}
 				const encodedDelivery = encode(SubscriptionDelivery, delivery, "select-delivery-encode");
@@ -1426,7 +1426,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 				]);
 				const ownerId = record.success.key.ownerId;
 				owners.set(ownerId, (owners.get(ownerId) ?? 0) + 1);
-				if ((owners.get(ownerId) ?? 0) > limits.maxDeliveriesPerOwner) return [Result.fail(error("capacity", "owner-deliveries")), current];
+				if ((owners.get(ownerId) ?? 0) > limits.maxDeliveriesPerOwner) return [Result.fail(error$1("capacity", "owner-deliveries")), current];
 				if (record.success.configuration.mode === "once") {
 					const consumed = {
 						...record.success,
@@ -1438,7 +1438,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 					const consumedKey = subscriptionKeyString(consumed.key);
 					updates.push([consumedKey, encodedRecord.success]);
 					const indexed = current.registrationIndex.get(consumedKey);
-					if (indexed === void 0) return [Result.fail(error("corrupt", "selection-index")), current];
+					if (indexed === void 0) return [Result.fail(error$1("corrupt", "selection-index")), current];
 					registrationUpdates.push([consumedKey, {
 						...indexed,
 						state: "consumed",
@@ -1446,7 +1446,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 					}]);
 				}
 			}
-			if (current.deliveries.size + additions.length > limits.maxDeliveries) return [Result.fail(error("capacity", "deliveries")), current];
+			if (current.deliveries.size + additions.length > limits.maxDeliveries) return [Result.fail(error$1("capacity", "deliveries")), current];
 			const registrations = new Map(current.registrations);
 			for (const [key, value] of updates) registrations.set(key, value);
 			const nextDeliveries = new Map(current.deliveries);
@@ -1493,23 +1493,23 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
 			const eventText = current.events.get(suppliedEvent.eventId);
 			const recordText = current.registrations.get(subscriptionKeyString(delivery.key.subscription));
-			if (eventText === void 0 || recordText === void 0) return [Result.fail(error("not-found", eventText === void 0 ? "event" : "subscription")), current];
+			if (eventText === void 0 || recordText === void 0) return [Result.fail(error$1("not-found", eventText === void 0 ? "event" : "subscription")), current];
 			const accepted = decode(AcceptedEvent, eventText, "catch-up-event-record");
 			if (Result.isFailure(accepted)) return [Result.fail(accepted.failure), current];
 			const record = decode(SubscriptionRecord, recordText, "catch-up-registration");
 			if (Result.isFailure(record)) return [Result.fail(record.failure), current];
-			if (!sameEventIdentity(accepted.success, suppliedEvent) || !deliveryBelongsTo(delivery, record.success, accepted.success) || !subscriptionDeliveryCanSelect(delivery, record.success, accepted.success) || record.success.configuration.mode !== "once") return [Result.fail(error("conflict", "catch-up-identity")), current];
+			if (!sameEventIdentity(accepted.success, suppliedEvent) || !deliveryBelongsTo(delivery, record.success, accepted.success) || !subscriptionDeliveryCanSelect(delivery, record.success, accepted.success) || record.success.configuration.mode !== "once") return [Result.fail(error$1("conflict", "catch-up-identity")), current];
 			const key = subscriptionDeliveryKeyString(delivery.key);
 			const existingText = current.deliveries.get(key);
 			if (existingText !== void 0) {
 				const existing = decode(SubscriptionDelivery, existingText, "catch-up-existing");
 				if (Result.isFailure(existing)) return [Result.fail(existing.failure), current];
-				return sameDeliveryIdentity(existing.success, delivery) ? [Result.void, current] : [Result.fail(error("conflict", "delivery-identity")), current];
+				return sameDeliveryIdentity(existing.success, delivery) ? [Result.void, current] : [Result.fail(error$1("conflict", "delivery-identity")), current];
 			}
-			if (!subscriptionCanSelect(record.success, accepted.success, effectiveNowMillis, true)) return [Result.fail(error("conflict", "catch-up-eligibility")), current];
-			if (current.deliveries.size >= limits.maxDeliveries) return [Result.fail(error("capacity", "deliveries")), current];
+			if (!subscriptionCanSelect(record.success, accepted.success, effectiveNowMillis, true)) return [Result.fail(error$1("conflict", "catch-up-eligibility")), current];
+			if (current.deliveries.size >= limits.maxDeliveries) return [Result.fail(error$1("capacity", "deliveries")), current];
 			const ownerCount = current.ownerDeliveryCounts.get(record.success.key.ownerId) ?? 0;
-			if (ownerCount >= limits.maxDeliveriesPerOwner) return [Result.fail(error("capacity", "owner-deliveries")), current];
+			if (ownerCount >= limits.maxDeliveriesPerOwner) return [Result.fail(error$1("capacity", "owner-deliveries")), current];
 			const encodedDelivery = encode(SubscriptionDelivery, delivery, "catch-up-delivery-encode");
 			if (Result.isFailure(encodedDelivery)) return [Result.fail(encodedDelivery.failure), current];
 			const consumed = {
@@ -1526,7 +1526,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			registrations.set(consumedKey, encodedRecord.success);
 			const registrationIndex = new Map(current.registrationIndex);
 			const indexed = registrationIndex.get(consumedKey);
-			if (indexed === void 0) return [Result.fail(error("corrupt", "catch-up-index")), current];
+			if (indexed === void 0) return [Result.fail(error$1("corrupt", "catch-up-index")), current];
 			registrationIndex.set(consumedKey, {
 				...indexed,
 				state: "consumed",
@@ -1556,7 +1556,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		yield* failpoint.hit("subscription:defer-event:before");
 		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
 			const text = current.events.get(eventId);
-			if (text === void 0) return [Result.fail(error("not-found", "event")), current];
+			if (text === void 0) return [Result.fail(error$1("not-found", "event")), current];
 			const accepted = decode(AcceptedEvent, text, "defer-event-record");
 			if (Result.isFailure(accepted)) return [Result.fail(accepted.failure), current];
 			const updated = {
@@ -1570,7 +1570,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			events.set(eventId, encoded.success);
 			const eventIndex = new Map(current.eventIndex);
 			const indexed = eventIndex.get(eventId);
-			if (indexed === void 0) return [Result.fail(error("corrupt", "defer-event-index")), current];
+			if (indexed === void 0) return [Result.fail(error$1("corrupt", "defer-event-index")), current];
 			eventIndex.set(eventId, {
 				...indexed,
 				nextAttemptAtMillis
@@ -1619,11 +1619,11 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		const result = yield* Effect.uninterruptible(Ref.modify(state, (current) => {
 			const storageKey = subscriptionDeliveryKeyString(key);
 			const text = current.deliveries.get(storageKey);
-			if (text === void 0) return [Result.fail(error("not-found", "delivery")), current];
+			if (text === void 0) return [Result.fail(error$1("not-found", "delivery")), current];
 			const decoded = decode(SubscriptionDelivery, text, "change-delivery-record");
 			if (Result.isFailure(decoded)) return [decoded, current];
 			const registrationText = current.registrations.get(subscriptionKeyString(key.subscription));
-			if (registrationText === void 0) return [Result.fail(error("corrupt", "delivery-registration")), current];
+			if (registrationText === void 0) return [Result.fail(error$1("corrupt", "delivery-registration")), current];
 			const registration = decode(SubscriptionRecord, registrationText, "delivery-registration");
 			if (Result.isFailure(registration)) return [Result.fail(registration.failure), current];
 			const transition = applySubscriptionDeliveryChange(decoded.success, registration.success, deliveryId, effectiveChange);
@@ -1636,7 +1636,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			deliveries.set(storageKey, encoded.success);
 			const deliveryIndex = new Map(current.deliveryIndex);
 			const indexed = deliveryIndex.get(storageKey);
-			if (indexed === void 0) return [Result.fail(error("corrupt", "delivery-index")), current];
+			if (indexed === void 0) return [Result.fail(error$1("corrupt", "delivery-index")), current];
 			deliveryIndex.set(storageKey, {
 				...indexed,
 				state: updated.state,
@@ -1666,7 +1666,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 		yield* Effect.uninterruptible(Ref.modify(state, (current) => {
 			const storageKey = subscriptionKeyString(key);
 			const text = current.registrations.get(storageKey);
-			if (text === void 0) return [Result.fail(error("not-found", "subscription")), current];
+			if (text === void 0) return [Result.fail(error$1("not-found", "subscription")), current];
 			const record = decode(SubscriptionRecord, text, "defer-recovery-record");
 			if (Result.isFailure(record)) return [Result.fail(record.failure), current];
 			const updated = {
@@ -1679,7 +1679,7 @@ const makeMemorySubscriptionStore = Effect.fn("makeMemorySubscriptionStore")(fun
 			registrations.set(storageKey, encoded.success);
 			const registrationIndex = new Map(current.registrationIndex);
 			const indexed = registrationIndex.get(storageKey);
-			if (indexed === void 0) return [Result.fail(error("corrupt", "recovery-index")), current];
+			if (indexed === void 0) return [Result.fail(error$1("corrupt", "recovery-index")), current];
 			registrationIndex.set(storageKey, {
 				...indexed,
 				recoveryAt: updated.recovery?.nextAttemptAtMillis ?? null
@@ -2042,6 +2042,217 @@ const MemoryThreadStoreLive = Layer.effect(ThreadStore, makeThreadStore);
 */
 const MemoryStorageLive = MemoryThreadStoreLive;
 //#endregion
-export { MemoryScheduleStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, MemoryThreadStoreLive, memoryScheduleStoreLayer, memorySubmissionLedgerLayer, memorySubscriptionStoreLayer };
+//#region src/semantic-memory-index.ts
+const PositiveCapacity = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: 65536
+}));
+const MaxStoredVectorComponents = 16777216;
+/**
+* Hard per-Layer bounds for disposable semantic index state. maxChunks times profile dimensions
+* must not exceed 16,777,216 vector components. maxSourceBytes bounds the aggregate UTF-8 JSON
+* of retained source identities and defaults to 16 MiB; it is not a general heap limit.
+*/
+var InMemorySemanticIndexCapacity = class extends Schema.Class("@effect-agent/storage-memory/InMemorySemanticIndexCapacity")({
+	maxSources: PositiveCapacity,
+	maxChunks: PositiveCapacity,
+	maxSourceBytes: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 67108864
+	})))
+}) {};
+const sameProfile = Schema.toEquivalence(SemanticMemoryProfile);
+const sameSource = Schema.toEquivalence(MemoryIndexSource.Wire);
+const error = (operation, reason) => MemoryIndexError.make({
+	operation,
+	reason
+});
+const keyString = (key) => JSON.stringify([key.namespace.address, key.id]);
+const sourceIdentityBytes = (source) => Encoding.encodeHex(JSON.stringify(source)).length / 2;
+const decodeBoundary = Effect.fn("InMemorySemanticIndex.decodeBoundary")(function* (schema, value, operation) {
+	return yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.flatMap((decoded) => Schema.encodeEffect(schema)(decoded).pipe(Effect.as(decoded))), Effect.mapError(() => error(operation, "invalid-input")));
+});
+const freezeSource = (source) => Object.freeze(MemoryIndexSource.make({
+	key: Object.freeze(MemoryKey.make({
+		...source.key,
+		namespace: Object.freeze({ address: source.key.namespace.address })
+	})),
+	source: Object.freeze({ ...source.source }),
+	sourceGeneration: source.sourceGeneration
+}));
+const freezeChunk = (chunk) => Object.freeze(SemanticMemoryChunk.make({
+	...chunk,
+	vector: Object.freeze([...chunk.vector])
+}));
+const sourceIsFenced = (source, existing) => source.sourceGeneration < existing.source.sourceGeneration || source.sourceGeneration === existing.source.sourceGeneration && !sameSource(source, existing.source);
+const squaredNorm = (vector) => {
+	let sum = 0;
+	for (const value of vector) {
+		sum += value * value;
+		if (!Number.isFinite(sum)) return null;
+	}
+	return sum > 0 ? sum : null;
+};
+const validVector = (vector, profile) => vector.length === profile.dimensions && squaredNorm(vector) !== null;
+const validateChunks = Effect.fn("InMemorySemanticIndex.validateChunks")(function* (chunks, profile, operation) {
+	let nextByte = 0;
+	const passageIds = /* @__PURE__ */ new Set();
+	for (let index = 0; index < chunks.length; index++) {
+		const chunk = chunks[index];
+		const byteLength = Encoding.encodeHex(chunk.text).length / 2;
+		if (chunk.ordinal !== index || chunk.startByte !== nextByte || chunk.endByte <= chunk.startByte || chunk.endByte - chunk.startByte !== byteLength || byteLength > profile.maxChunkBytes || passageIds.has(chunk.passageId) || !validVector(chunk.vector, profile)) return yield* error(operation, "invalid-input");
+		passageIds.add(chunk.passageId);
+		nextByte = chunk.endByte;
+	}
+});
+const cosine = (left, right) => {
+	const leftNorm = Math.sqrt(squaredNorm(left) ?? 1);
+	const rightNorm = Math.sqrt(squaredNorm(right) ?? 1);
+	let score = 0;
+	for (let index = 0; index < left.length; index++) score += left[index] / leftNorm * (right[index] / rightNorm);
+	const bounded = Math.max(-1, Math.min(1, score));
+	return bounded === 0 ? 0 : bounded;
+};
+const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const makeIndex = Effect.fn("InMemorySemanticIndex.make")(function* (rawProfile, rawCapacity) {
+	const profile = Object.freeze(SemanticMemoryProfile.make({ ...yield* decodeBoundary(SemanticMemoryProfile, rawProfile, "configure semantic memory index") }));
+	const capacity = yield* decodeBoundary(InMemorySemanticIndexCapacity, rawCapacity, "configure semantic memory index");
+	if (capacity.maxChunks * profile.dimensions > MaxStoredVectorComponents) return yield* error("configure semantic memory index", "invalid-input");
+	const maxSourceBytes = capacity.maxSourceBytes ?? 16777216;
+	const data = yield* Ref.make({
+		closed: false,
+		entries: /* @__PURE__ */ new Map(),
+		sourceBytes: 0
+	});
+	yield* Effect.addFinalizer(() => Ref.set(data, {
+		closed: true,
+		entries: /* @__PURE__ */ new Map(),
+		sourceBytes: 0
+	}));
+	const ensureOpen = Effect.fn("InMemorySemanticIndex.ensureOpen")(function* (operation) {
+		if ((yield* Ref.get(data)).closed) return yield* error(operation, "unavailable");
+	});
+	const replace = Effect.fn("InMemorySemanticIndex.replace")(function* (rawRequest) {
+		const operation = "replace semantic memory source";
+		yield* ensureOpen(operation);
+		const request = yield* decodeBoundary(MemoryIndexReplacement.Wire, rawRequest, operation);
+		const source = freezeSource(request.source);
+		const sourceBytes = sourceIdentityBytes(source);
+		const chunks = Object.freeze(request.chunks.map(freezeChunk));
+		if (source.source.id !== source.key.id) return yield* error(operation, "invalid-input");
+		if (!sameProfile(request.profile, profile)) return yield* error(operation, "incompatible");
+		yield* validateChunks(chunks, profile, operation);
+		const indexedAt = yield* Clock.currentTimeMillis;
+		const failure = yield* Ref.modify(data, (current) => {
+			if (current.closed) return [error(operation, "unavailable"), current];
+			const id = keyString(source.key);
+			const existing = current.entries.get(id);
+			if (existing !== void 0 && (existing._tag === "Withdrawn" || sourceIsFenced(source, existing))) return [error(operation, "fenced"), current];
+			if (existing === void 0 && current.entries.size >= capacity.maxSources) return [error(operation, "budget"), current];
+			const nextSourceBytes = current.sourceBytes - (existing?.sourceBytes ?? 0) + sourceBytes;
+			if (nextSourceBytes > maxSourceBytes) return [error(operation, "budget"), current];
+			let count = chunks.length;
+			for (const [entryId, entry] of current.entries) if (entryId !== id && entry._tag === "Indexed") count += entry.chunks.length;
+			if (count > capacity.maxChunks) return [error(operation, "budget"), current];
+			const entries = new Map(current.entries);
+			entries.set(id, {
+				_tag: "Indexed",
+				source,
+				sourceBytes,
+				chunks,
+				indexedAt
+			});
+			return [void 0, {
+				...current,
+				entries,
+				sourceBytes: nextSourceBytes
+			}];
+		});
+		if (failure !== void 0) return yield* failure;
+	});
+	const withdraw = Effect.fn("InMemorySemanticIndex.withdraw")(function* (rawSource) {
+		const operation = "withdraw semantic memory source";
+		yield* ensureOpen(operation);
+		const source = freezeSource(yield* decodeBoundary(MemoryIndexSource.Wire, rawSource, operation));
+		const sourceBytes = sourceIdentityBytes(source);
+		if (source.source.id !== source.key.id) return yield* error(operation, "invalid-input");
+		const failure = yield* Ref.modify(data, (current) => {
+			if (current.closed) return [error(operation, "unavailable"), current];
+			const id = keyString(source.key);
+			const existing = current.entries.get(id);
+			if (existing !== void 0) {
+				if (existing._tag === "Withdrawn") return [sameSource(source, existing.source) ? void 0 : error(operation, "fenced"), current];
+				if (sourceIsFenced(source, existing)) return [error(operation, "fenced"), current];
+			} else if (current.entries.size >= capacity.maxSources) return [error(operation, "budget"), current];
+			const nextSourceBytes = current.sourceBytes - (existing?.sourceBytes ?? 0) + sourceBytes;
+			if (nextSourceBytes > maxSourceBytes) return [error(operation, "budget"), current];
+			const entries = new Map(current.entries);
+			entries.set(id, {
+				_tag: "Withdrawn",
+				source,
+				sourceBytes
+			});
+			return [void 0, {
+				...current,
+				entries,
+				sourceBytes: nextSourceBytes
+			}];
+		});
+		if (failure !== void 0) return yield* failure;
+	});
+	const search = Effect.fn("InMemorySemanticIndex.search")(function* (rawQuery) {
+		const operation = "search semantic memory index";
+		yield* ensureOpen(operation);
+		const query = yield* decodeBoundary(MemoryIndexQuery.Wire, rawQuery, operation);
+		const vector = Object.freeze([...query.vector]);
+		if (!validVector(vector, profile)) return yield* error(operation, "invalid-input");
+		const current = yield* Ref.get(data);
+		if (current.closed) return yield* error(operation, "unavailable");
+		let scannedChunks = 0;
+		let inspectedSources = 0;
+		const candidates = [];
+		for (const entry of current.entries.values()) {
+			inspectedSources += 1;
+			if (inspectedSources % 128 === 0) yield* Effect.yieldNow;
+			if (entry.source.key.namespace.address !== query.namespace.address || entry._tag !== "Indexed") continue;
+			scannedChunks += entry.chunks.length;
+			if (scannedChunks > query.maxScannedChunks) return yield* error(operation, "budget");
+		}
+		for (const entry of current.entries.values()) {
+			if (entry.source.key.namespace.address !== query.namespace.address || entry._tag !== "Indexed") continue;
+			yield* Effect.yieldNow;
+			for (const chunk of entry.chunks) {
+				const score = cosine(vector, chunk.vector);
+				if (score < query.minScore) continue;
+				candidates.push(MemoryIndexCandidate.make({
+					...entry.source,
+					passageId: chunk.passageId,
+					ordinal: chunk.ordinal,
+					startByte: chunk.startByte,
+					endByte: chunk.endByte,
+					text: chunk.text,
+					score,
+					indexedAt: entry.indexedAt
+				}));
+			}
+		}
+		candidates.sort((left, right) => right.score - left.score || compareText(left.key.id, right.key.id) || compareText(left.source.revision, right.source.revision) || left.ordinal - right.ordinal);
+		yield* ensureOpen(operation);
+		return MemoryIndexSearch.make({
+			candidates: candidates.slice(0, query.limit),
+			scannedChunks
+		});
+	});
+	return SemanticMemoryIndex.fromAdapter({
+		profile,
+		replace,
+		withdraw,
+		search
+	});
+});
+/** Scoped disposable semantic index. No persistent build or recovery state is retained. */
+const inMemorySemanticIndexLayer = (profile, capacity) => Layer.effect(SemanticMemoryIndex, makeIndex(profile, capacity));
+//#endregion
+export { InMemorySemanticIndexCapacity, MemoryScheduleStoreLive, MemoryStorageLive, MemorySubmissionLedgerLive, MemoryThreadStoreLive, inMemorySemanticIndexLayer, memoryScheduleStoreLayer, memorySubmissionLedgerLayer, memorySubscriptionStoreLayer };
 
 //# sourceMappingURL=index.mjs.map