effect 4.0.0-beta.105 → 4.0.0-beta.106

package/src/internal/schema/toRepresentation.ts

@@ -7,17 +7,24 @@ import * as InternalAnnotations from "./annotations.ts"
 
 /** @internal */
 export function toRepresentation(
-  ast: SchemaAST.AST
+  ast: SchemaAST.AST,
+  options?: Options
 ): SchemaRepresentation.Document {
-  const { references, representations } = toRepresentations([ast])
+  const { references, representations } = toRepresentations([ast], options)
   return { representation: representations[0], references }
 }
 
 /** @internal */
 export function toRepresentations(
-  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]
+  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>],
+  options?: Options
 ): SchemaRepresentation.MultiDocument {
-  return fromASTs(asts)
+  return fromASTs(asts, options)
+}
+
+/** @internal */
+export interface Options {
+  readonly isAnonymousReferenceAllowed?: ((ast: SchemaAST.AST) => boolean) | undefined
 }
 
 type CheckRepresentationAnnotation = SchemaRepresentation.CheckRepresentationAnnotation<
@@ -28,11 +35,49 @@ function annotationsField<A>(annotations: A | undefined): { readonly annotations
   return annotations === undefined ? undefined : { annotations }
 }
 
-// Preserve repeated structural nodes as references without adding noise for leaf nodes.
-function isShareable(ast: SchemaAST.AST): boolean {
-  return SchemaAST.isArrays(ast) ||
-    SchemaAST.isObjects(ast) ||
-    (SchemaAST.isUnion(ast) && ast.types.some(isShareable))
+function hasShareableStructure(
+  ast: SchemaAST.AST,
+  isAnonymousReferenceAllowed: Options["isAnonymousReferenceAllowed"]
+): boolean {
+  if (isAnonymousReferenceAllowed?.(ast) === false) return false
+  switch (ast._tag) {
+    case "Arrays":
+    case "Objects":
+    case "Suspend":
+      return true
+    case "Declaration":
+      return true
+    case "Union":
+      return ast.types.some((ast) => hasShareableStructure(ast, isAnonymousReferenceAllowed))
+    default:
+      return false
+  }
+}
+
+function isWorthReferencing(bodyCost: number, occurrences: number): boolean {
+  return occurrences * bodyCost > bodyCost + occurrences + 1
+}
+
+function isAnonymousReferenceEligible(
+  ast: SchemaAST.AST,
+  occurrences: number,
+  isAnonymousReferenceAllowed: Options["isAnonymousReferenceAllowed"]
+): boolean {
+  if (isAnonymousReferenceAllowed?.(ast) === false) return false
+  if (hasShareableStructure(ast, isAnonymousReferenceAllowed)) return true
+  switch (ast._tag) {
+    case "Union":
+      return isWorthReferencing(ast.types.length + 1, occurrences)
+    case "Enum":
+      return isWorthReferencing(ast.enums.length + 1, occurrences)
+    case "TemplateLiteral":
+      return isWorthReferencing(ast.parts.length + 1, occurrences)
+    case "Literal":
+      return typeof ast.literal === "string" &&
+        isWorthReferencing(ast.literal.length / 32 + 1, occurrences)
+    default:
+      return false
+  }
 }
 
 interface ReferenceIdentifier {
@@ -54,17 +99,15 @@ function resolveReferenceIdentifier(
 }
 
 function fromASTs(
-  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>]
+  asts: readonly [SchemaAST.AST, ...Array<SchemaAST.AST>],
+  options: Options | undefined
 ): SchemaRepresentation.MultiDocument {
   const references: Record<string, SchemaRepresentation.Representation> = {}
   const anonymousReferences = new Map<SchemaAST.AST, string>()
   const referenceOwners = new Map<string, SchemaAST.AST>()
-  const valueIds = new Map<unknown, number>()
-  const canonicalByKey = new Map<string, SchemaAST.AST>()
-  let nextValueId = 0
   const buildingReferences = new Set<string>()
   const visiting = new Set<SchemaAST.AST>()
-  const visited = new Set<SchemaAST.AST>()
+  const occurrences = new Map<SchemaAST.AST, number>()
   const shared = new Set<SchemaAST.AST>()
 
   for (const ast of asts) visit(ast)
@@ -84,35 +127,6 @@ function fromASTs(
     return candidate
   }
 
-  function getValueId(value: unknown): number {
-    if (typeof value === "number" && globalThis.Number.isNaN(value)) {
-      return nextValueId++
-    }
-    const found = valueIds.get(value)
-    if (found !== undefined) return found
-    const id = nextValueId++
-    valueIds.set(value, id)
-    return id
-  }
-
-  function getIdentityKey(ast: SchemaAST.AST): string {
-    let identity = ast._tag
-    for (const [key, value] of Object.entries(ast)) {
-      if (key !== "_tag" && key !== "context") identity += `:${getValueId(value)}`
-    }
-    return identity
-  }
-
-  function getCanonicalAST(ast: SchemaAST.AST): SchemaAST.AST {
-    const key = getIdentityKey(ast)
-    const canonical = canonicalByKey.get(key)
-    if (canonical === undefined) {
-      canonicalByKey.set(key, ast)
-      return ast
-    }
-    return canonical
-  }
-
   function annotateReference(
     ast: SchemaAST.AST,
     referenceIdentifier: ReferenceIdentifier,
@@ -143,12 +157,16 @@ function fromASTs(
 
   function visit(input: SchemaAST.AST): void {
     const ast = SchemaAST.getLastEncoding(input)
-    const owner = getCanonicalAST(ast)
-    if (visited.has(owner)) {
-      if (isShareable(ast)) shared.add(owner)
+    const owner = SchemaAST.getContextOwner(ast)
+    const count = (occurrences.get(owner) ?? 0) + 1
+    occurrences.set(owner, count)
+    if (count > 1) {
+      if (
+        !shared.has(owner) &&
+        isAnonymousReferenceEligible(owner, count, options?.isAnonymousReferenceAllowed)
+      ) shared.add(owner)
       return
     }
-    visited.add(owner)
     visitChecks(ast.checks)
     switch (ast._tag) {
       case "Declaration":
@@ -178,7 +196,7 @@ function fromASTs(
 
   function recur(input: SchemaAST.AST): SchemaRepresentation.Representation {
     const ast = SchemaAST.getLastEncoding(input)
-    const owner = getCanonicalAST(ast)
+    const owner = SchemaAST.getContextOwner(ast)
     const referenceIdentifier = resolveReferenceIdentifier(input, ast)
     if (referenceIdentifier !== undefined) {
       const reference = getReference(referenceIdentifier.identifier, owner)

package/src/testing/TestSchema.ts

@@ -172,7 +172,7 @@ export class Asserts<S extends Schema.Constraint> {
   }) {
     const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(this.schema)
     const encodeEffect = SchemaParser.encodeEffect(this.schema)
-    const arbitrary = Schema.toArbitrary(this.schema)
+    const arbitrary = Schema.toArbitrary(this.schema)(FastCheck)
     return FastCheck.assert(
       FastCheck.asyncProperty(arbitrary, async (t) => {
         const r = await Effect.runPromise(
@@ -280,7 +280,7 @@ export class Asserts<S extends Schema.Constraint> {
       }) {
         const params = options?.params
         const is = Schema.is(schema)
-        const arb = Schema.toArbitrary(schema)
+        const arb = Schema.toArbitrary(schema)(FastCheck)
         FastCheck.assert(FastCheck.property(arb, (a) => is(a)), { numRuns: 20, ...params })
       }
     }

package/src/unstable/ai/McpServer.ts

@@ -489,7 +489,7 @@ const runWithProtocolState = Effect.fnUntraced(function*(options: {
   const isHttp = Option.isSome(yield* Effect.serviceOption(HttpRouter.HttpRouter))
   const sessions = protocolState.sessions
   const clientProtocols = new Map<number, McpProtocol.ProtocolAdapter>()
-  const cancelledRequests = new Map<number, Set<string>>()
+  const activeRequests = new Map<number, Map<string, boolean>>()
   const handlers = yield* Layer.build(layerHandlers(options, {
     sessions,
     protocolRegistry
@@ -577,11 +577,13 @@ const runWithProtocolState = Effect.fnUntraced(function*(options: {
     ...protocol,
     send: (clientId, response) => {
       if (response._tag === "Exit") {
-        const requests = cancelledRequests.get(clientId)
-        if (requests?.delete(requestKey(response.requestId)) === true) {
-          if (requests.size === 0) {
-            cancelledRequests.delete(clientId)
-          }
+        const requests = activeRequests.get(clientId)
+        const key = requestKey(response.requestId)
+        const cancelled = requests?.get(key)
+        if (requests !== undefined && requests.delete(key) && requests.size === 0) {
+          activeRequests.delete(clientId)
+        }
+        if (cancelled === true) {
           return Effect.void
         }
       }
@@ -670,9 +672,12 @@ const runWithProtocolState = Effect.fnUntraced(function*(options: {
               if (request.tag === "notifications/cancelled") {
                 return decodeCancelledNotification(request.payload).pipe(
                   Effect.flatMap(({ requestId }) => {
-                    const requests = cancelledRequests.get(clientId) ?? new Set<string>()
-                    requests.add(requestKey(requestId))
-                    cancelledRequests.set(clientId, requests)
+                    const key = requestKey(requestId)
+                    const requests = activeRequests.get(clientId)
+                    if (requests?.has(key) !== true) {
+                      return Effect.void
+                    }
+                    requests.set(key, true)
                     return f(clientId, {
                       _tag: "Interrupt",
                       requestId: RpcMessage.RequestId(requestId)
@@ -732,7 +737,14 @@ const runWithProtocolState = Effect.fnUntraced(function*(options: {
             }
             return selectedProtocol.payloadCodecs(rpc).decode(request.payload).pipe(
               Effect.matchEffect({
-                onSuccess: () => f(clientId, routedRequest),
+                onSuccess: () => {
+                  if (request.isNotification !== true) {
+                    const requests = activeRequests.get(clientId) ?? new Map<string, boolean>()
+                    requests.set(requestKey(request.id), false)
+                    activeRequests.set(clientId, requests)
+                  }
+                  return f(clientId, routedRequest)
+                },
                 onFailure: () =>
                   request.isNotification
                     ? Effect.void
@@ -752,7 +764,7 @@ const runWithProtocolState = Effect.fnUntraced(function*(options: {
           case "Interrupt":
             return f(clientId, request)
           case "Eof":
-            cancelledRequests.delete(clientId)
+            activeRequests.delete(clientId)
             return f(clientId, request)
           case "Pong":
           case "Exit":

package/src/unstable/ai/Prompt.ts

@@ -2004,11 +2004,23 @@ export const make = (input: RawInput): Prompt => {
  */
 export const fromMessages = (messages: ReadonlyArray<Message>): Prompt => makePrompt(messages)
 
+const mergeOptions = (left: ProviderOptions, right: ProviderOptions): ProviderOptions => {
+  const result: Record<string, ProviderOptions[string]> = { ...left }
+  for (const [provider, metadata] of Object.entries(right)) {
+    const previous = result[provider]
+    result[provider] = Predicate.isObject(previous) && Predicate.isObject(metadata)
+      ? Object.assign({}, previous, metadata)
+      : metadata
+  }
+  return result
+}
+
 /**
  * Creates a `Prompt` from response parts by folding completed text and
- * reasoning streams into assistant parts, placing tool calls and approval
- * requests in an assistant message, and placing non-preliminary tool results
- * in a tool message using their encoded results.
+ * reasoning streams into assistant parts, preserving provider metadata as
+ * prompt options, placing tool calls and approval requests in an assistant
+ * message, and placing non-preliminary tool results in a tool message using
+ * their encoded results.
  *
  * **Example** (Creating prompts from response parts)
  *
@@ -2052,55 +2064,63 @@ export const fromResponseParts = (parts: ReadonlyArray<Response.AnyPart>): Promp
   const assistantParts: Array<AssistantMessagePart> = []
   const toolParts: Array<ToolMessagePart> = []
 
-  const activeTextDeltas = new Map<string, { text: string }>()
-  const activeReasoningDeltas = new Map<string, { text: string }>()
+  const activeTextDeltas = new Map<string, { text: string; options: ProviderOptions }>()
+  const activeReasoningDeltas = new Map<string, { text: string; options: ProviderOptions }>()
 
   for (const part of parts) {
     switch (part.type) {
       // Text Parts
       case "text": {
-        assistantParts.push(makePart("text", { text: part.text }))
+        assistantParts.push(makePart("text", { text: part.text, options: part.metadata }))
         break
       }
 
       // Text Parts (streaming)
       case "text-start": {
-        activeTextDeltas.set(part.id, { text: "" })
+        activeTextDeltas.set(part.id, { text: "", options: part.metadata })
         break
       }
       case "text-delta": {
         if (activeTextDeltas.has(part.id)) {
-          activeTextDeltas.get(part.id)!.text += part.delta
+          const active = activeTextDeltas.get(part.id)!
+          active.text += part.delta
+          active.options = mergeOptions(active.options, part.metadata)
         }
         break
       }
       case "text-end": {
         if (activeTextDeltas.has(part.id)) {
-          assistantParts.push(makePart("text", activeTextDeltas.get(part.id)!))
+          const active = activeTextDeltas.get(part.id)!
+          active.options = mergeOptions(active.options, part.metadata)
+          assistantParts.push(makePart("text", active))
         }
         break
       }
 
       // Reasoning Parts
       case "reasoning": {
-        assistantParts.push(makePart("reasoning", { text: part.text }))
+        assistantParts.push(makePart("reasoning", { text: part.text, options: part.metadata }))
         break
       }
 
       // Reasoning Parts (streaming)
       case "reasoning-start": {
-        activeReasoningDeltas.set(part.id, { text: "" })
+        activeReasoningDeltas.set(part.id, { text: "", options: part.metadata })
         break
       }
       case "reasoning-delta": {
         if (activeReasoningDeltas.has(part.id)) {
-          activeReasoningDeltas.get(part.id)!.text += part.delta
+          const active = activeReasoningDeltas.get(part.id)!
+          active.text += part.delta
+          active.options = mergeOptions(active.options, part.metadata)
         }
         break
       }
       case "reasoning-end": {
         if (activeReasoningDeltas.has(part.id)) {
-          assistantParts.push(makePart("reasoning", activeReasoningDeltas.get(part.id)!))
+          const active = activeReasoningDeltas.get(part.id)!
+          active.options = mergeOptions(active.options, part.metadata)
+          assistantParts.push(makePart("reasoning", active))
         }
         break
       }
@@ -2111,7 +2131,8 @@ export const fromResponseParts = (parts: ReadonlyArray<Response.AnyPart>): Promp
           id: part.id,
           name: part.name,
           params: part.params,
-          providerExecuted: part.providerExecuted ?? false
+          providerExecuted: part.providerExecuted ?? false,
+          options: part.metadata
         }))
         break
       }
@@ -2125,7 +2146,8 @@ export const fromResponseParts = (parts: ReadonlyArray<Response.AnyPart>): Promp
             name: part.name,
             isFailure: part.isFailure,
             result: part.encodedResult,
-            providerExecuted: part.providerExecuted ?? false
+            providerExecuted: part.providerExecuted ?? false,
+            options: part.metadata
           }))
         }
         break

package/src/unstable/cluster/Entity.ts

@@ -34,7 +34,12 @@ import * as RpcClient from "../rpc/RpcClient.ts"
 import * as RpcGroup from "../rpc/RpcGroup.ts"
 import * as RpcSchema from "../rpc/RpcSchema.ts"
 import * as RpcServer from "../rpc/RpcServer.ts"
-import type { AlreadyProcessingMessage, MailboxFull, PersistenceError } from "./ClusterError.ts"
+import type {
+  AlreadyProcessingMessage,
+  EntityNotAssignedToRunner,
+  MailboxFull,
+  PersistenceError
+} from "./ClusterError.ts"
 import { Persisted, ShardGroup, Uninterruptible } from "./ClusterSchema.ts"
 import { EntityAddress } from "./EntityAddress.ts"
 import type { EntityId } from "./EntityId.ts"
@@ -117,7 +122,7 @@ export interface Entity<
       entityId: string
     ) => RpcClient.RpcClient.From<
       Rpcs,
-      MailboxFull | AlreadyProcessingMessage | PersistenceError
+      MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotAssignedToRunner
     >,
     never,
     Sharding

package/src/unstable/cluster/EntityProxy.ts

@@ -14,7 +14,7 @@ import * as HttpApiEndpoint from "../httpapi/HttpApiEndpoint.ts"
 import * as HttpApiGroup from "../httpapi/HttpApiGroup.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import * as RpcGroup from "../rpc/RpcGroup.ts"
-import { AlreadyProcessingMessage, MailboxFull, PersistenceError } from "./ClusterError.ts"
+import { AlreadyProcessingMessage, EntityNotAssignedToRunner, MailboxFull, PersistenceError } from "./ClusterError.ts"
 import type * as Entity from "./Entity.ts"
 import type { EntityId } from "./EntityId.ts"
 
@@ -24,6 +24,11 @@ const clientErrors = [
   PersistenceError
 ] as const
 
+const requestErrors = [
+  ...clientErrors,
+  EntityNotAssignedToRunner
+] as const
+
 /**
  * Derives an `RpcGroup` from an `Entity`.
  *
@@ -75,7 +80,7 @@ export const toRpcGroup = <Type extends string, Rpcs extends Rpc.Any>(
     }
     const rpc = Rpc.make(`${entity.type}.${parentRpc._tag}`, {
       payload: payloadSchema,
-      error: Schema.Union([parentRpc.errorSchema, ...clientErrors]),
+      error: Schema.Union([parentRpc.errorSchema, ...requestErrors]),
       success: parentRpc.successSchema
     }).annotateMerge(parentRpc.annotations)
     const rpcDiscard = Rpc.make(`${entity.type}.${parentRpc._tag}Discard`, {
@@ -115,11 +120,12 @@ export type ConvertRpcs<Rpcs extends Rpc.Any, Prefix extends string> = Rpcs exte
       }>,
       _Success,
       Schema.Codec<
-        _Error["Type"] | MailboxFull | AlreadyProcessingMessage | PersistenceError,
+        _Error["Type"] | MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotAssignedToRunner,
         | _Error["Encoded"]
         | typeof MailboxFull["Encoded"]
         | typeof AlreadyProcessingMessage["Encoded"]
-        | typeof PersistenceError["Encoded"],
+        | typeof PersistenceError["Encoded"]
+        | typeof EntityNotAssignedToRunner["Encoded"],
         _Error["DecodingServices"],
         _Error["EncodingServices"]
       >
@@ -193,7 +199,7 @@ export const toHttpApiGroup = <const Name extends string, Type extends string, R
       params: entityIdPath,
       payload: parentRpc.payloadSchema,
       success: parentRpc.successSchema,
-      error: [parentRpc.errorSchema, ...clientErrors]
+      error: [parentRpc.errorSchema, ...requestErrors]
     }).annotateMerge(parentRpc.annotations)
     const endpointDiscard = HttpApiEndpoint.post(
       `${parentRpc._tag}Discard`,
@@ -250,6 +256,7 @@ export type ConvertHttpApi<Rpcs extends Rpc.Any> = Rpcs extends Rpc.Rpc<
       | typeof MailboxFull
       | typeof AlreadyProcessingMessage
       | typeof PersistenceError
+      | typeof EntityNotAssignedToRunner
     >
     | HttpApiEndpoint.HttpApiEndpoint<
       `${_Tag}Discard`,

package/src/unstable/cluster/Sharding.ts

@@ -124,7 +124,7 @@ export class Sharding extends Context.Service<Sharding, {
       entityId: string
     ) => RpcClient.RpcClient.From<
       Rpcs,
-      MailboxFull | AlreadyProcessingMessage | PersistenceError
+      MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotAssignedToRunner
     >
   >
 
@@ -178,7 +178,7 @@ export class Sharding extends Context.Service<Sharding, {
     discard: boolean
   ) => Effect.Effect<
     void,
-    MailboxFull | AlreadyProcessingMessage | PersistenceError
+    MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotAssignedToRunner
   >
 
   /**
@@ -967,18 +967,40 @@ const make = Effect.gen(function*() {
     retries?: number
   ): Effect.Effect<
     void,
-    MailboxFull | AlreadyProcessingMessage | PersistenceError
+    MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotAssignedToRunner
   > {
     const isPersisted = Context.get(
       message._tag === "OutgoingRequest" ? message.annotations : message.rpc.annotations,
       Persisted
     )
+    const shouldFail = !discard &&
+      (message._tag === "OutgoingRequest" || message.envelope._tag === "AckChunk")
+    const abandon = (error: EntityNotAssignedToRunner) => {
+      if (!isPersisted) {
+        return shouldFail
+          ? Effect.fail(error)
+          : Effect.logDebug("Abandoning outgoing message during shutdown", message.envelope.address)
+      }
+      const persist = message._tag === "OutgoingRequest"
+        ? storage.saveRequest(message)
+        : storage.saveEnvelope(message)
+      return Effect.catchTag(persist, "MalformedMessage", Effect.die).pipe(
+        Effect.andThen(
+          shouldFail
+            ? Effect.fail(error)
+            : Effect.logWarning("Persisting outgoing message abandoned during shutdown", message.envelope.address)
+        )
+      )
+    }
     return Effect.catchFilter(
       Effect.suspend(() => {
         const address = message.envelope.address
         if (isPersisted && !storageEnabled) {
           return Effect.die("Sharding.sendOutgoing: Persisted messages require MessageStorage")
         }
+        if (shouldFail && MutableRef.get(isShutdown)) {
+          return Effect.fail(new EntityNotAssignedToRunner({ address }))
+        }
         const maybeRunner = MutableHashMap.get(shardAssignments, address.shardId)
         const runnerIsLocal = Option.isSome(maybeRunner) && isLocalRunner(maybeRunner.value)
         if (isPersisted) {
@@ -1003,17 +1025,7 @@ const make = Effect.gen(function*() {
           const cannotRecover = MutableRef.get(isShutdown) ||
             (targetManager !== undefined && targetManager.status !== "alive")
           if (cannotRecover) {
-            if (!isPersisted) {
-              return Effect.logDebug("Abandoning outgoing message during shutdown", message.envelope.address)
-            }
-            const persist = message._tag === "OutgoingRequest"
-              ? storage.saveRequest(message)
-              : storage.saveEnvelope(message)
-            return Effect.catchTag(persist, "MalformedMessage", Effect.die).pipe(
-              Effect.andThen(
-                Effect.logWarning("Persisting outgoing message abandoned during shutdown", message.envelope.address)
-              )
-            )
+            return abandon(error)
           }
         }
         if (retries === 0) {
@@ -1183,7 +1195,7 @@ const make = Effect.gen(function*() {
     Entity<any, any>,
     (entityId: string) => RpcClient.RpcClient<
       any,
-      MailboxFull | AlreadyProcessingMessage
+      MailboxFull | AlreadyProcessingMessage | EntityNotAssignedToRunner
     >,
     never
   > = yield* ResourceMap.make(
@@ -1196,7 +1208,7 @@ const make = Effect.gen(function*() {
         flatten: true,
         onFromClient(options): Effect.Effect<
           void,
-          MailboxFull | AlreadyProcessingMessage | PersistenceError
+          MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotAssignedToRunner
         > {
           const address = Context.getUnsafe(options.context, ClientAddressTag)
           switch (options.message._tag) {
@@ -1337,7 +1349,7 @@ const make = Effect.gen(function*() {
   const makeClient = <Type extends string, Rpcs extends Rpc.Any>(entity: Entity<Type, Rpcs>): Effect.Effect<
     (
       entityId: string
-    ) => RpcClient.RpcClient.From<Rpcs, MailboxFull | AlreadyProcessingMessage>
+    ) => RpcClient.RpcClient.From<Rpcs, MailboxFull | AlreadyProcessingMessage | EntityNotAssignedToRunner>
   > => clients.get(entity) as any
 
   const clientRespondDiscard = (_reply: Reply.Reply<any>) => Effect.void

package/src/unstable/eventlog/EventLogEncryption.ts

@@ -19,14 +19,15 @@ import type { Identity } from "./EventLog.ts"
 import { makeGetIdentityRootSecretMaterial } from "./internal/identityRootSecretDerivation.ts"
 
 /**
- * Schema for an encrypted journal entry paired with the id of the original
- * entry.
+ * Schema for an encrypted journal entry paired with its initialization vector
+ * and the id of the original entry.
  *
  * @category models
  * @since 4.0.0
  */
 export const EncryptedEntry = Schema.Struct({
   entryId: EntryId,
+  iv: Transferable.Uint8Array,
   encryptedEntry: Transferable.Uint8Array
 })
 
@@ -76,10 +77,12 @@ export class EventLogEncryption extends Context.Service<EventLogEncryption, {
   readonly encrypt: (
     identity: Identity["Service"],
     entries: ReadonlyArray<Entry>
-  ) => Effect.Effect<{
-    readonly iv: Uint8Array<ArrayBuffer>
-    readonly encryptedEntries: ReadonlyArray<Uint8Array<ArrayBuffer>>
-  }>
+  ) => Effect.Effect<
+    ReadonlyArray<{
+      readonly iv: Uint8Array<ArrayBuffer>
+      readonly encryptedEntry: Uint8Array<ArrayBuffer>
+    }>
+  >
   readonly decrypt: (
     identity: Identity["Service"],
     entries: ReadonlyArray<EncryptedRemoteEntry>
@@ -104,22 +107,18 @@ export const makeEncryptionSubtle = (crypto: Crypto): Effect.Effect<EventLogEncr
       encrypt: Effect.fnUntraced(function*(identity, entries) {
         const data = yield* Effect.orDie(Entry.encodeArray(entries))
         const key = (yield* getIdentityRootSecretMaterial(identity)).encryptionKey
-        const iv = crypto.getRandomValues(new Uint8Array(12))
-        const encryptedEntries = yield* Effect.promise(() =>
+        return yield* Effect.promise(() =>
           Promise.all(
-            data.map((entry) =>
-              crypto.subtle.encrypt(
+            data.map((entry) => {
+              const iv = crypto.getRandomValues(new Uint8Array(12))
+              return crypto.subtle.encrypt(
                 { name: "AES-GCM", iv: toBufferSource(iv), tagLength: 128 },
                 key,
                 toBufferSource(entry)
-              )
-            )
+              ).then((encryptedEntry) => ({ iv, encryptedEntry: new Uint8Array(encryptedEntry) }))
+            })
           )
         )
-        return {
-          iv,
-          encryptedEntries: encryptedEntries.map((entry) => new Uint8Array(entry))
-        }
       }),
       decrypt: Effect.fnUntraced(function*(identity, entries) {
         const key = (yield* getIdentityRootSecretMaterial(identity)).encryptionKey

package/src/unstable/eventlog/EventLogMessage.ts

@@ -261,8 +261,8 @@ export class WriteChunkedRpc extends Rpc.make("EventLog.WriteChunked", {
  *
  * **Details**
  *
- * It includes the client public key, target store id, AES-GCM initialization
- * vector, and encrypted entries.
+ * It includes the client public key, target store id, and encrypted entries
+ * with their AES-GCM initialization vectors.
  *
  * @category protocols
  * @since 4.0.0
@@ -270,7 +270,6 @@ export class WriteChunkedRpc extends Rpc.make("EventLog.WriteChunked", {
 export class WriteEntries extends Schema.Class<WriteEntries>("effect/eventlog/EventLogRemote/WriteEntries")({
   publicKey: Schema.String,
   storeId: StoreId,
-  iv: Transferable.Uint8Array,
   encryptedEntries: Schema.Array(EncryptedEntry)
 }) {
   static FromMsgpack = Msgpack.schema(WriteEntries)

package/src/unstable/eventlog/EventLogRemote.ts

@@ -307,14 +307,14 @@ export const makeEncrypted = Effect.gen(function*(): Effect.fn.Return<
   return yield* makeWith({
     encodeWrite: (options) =>
       encryption.encrypt(options.identity, options.entries).pipe(
-        Effect.flatMap((msg) =>
+        Effect.flatMap((encryptedEntries) =>
           new WriteEntries({
             publicKey: options.identity.publicKey,
             storeId: options.storeId,
-            iv: msg.iv,
-            encryptedEntries: msg.encryptedEntries.map((entry, i) => ({
+            encryptedEntries: encryptedEntries.map((entry, i) => ({
               entryId: options.entries[i].id,
-              encryptedEntry: entry
+              iv: entry.iv,
+              encryptedEntry: entry.encryptedEntry
             }))
           }).encoded
         )