effect 4.0.0-beta.44 → 4.0.0-beta.46

package/src/Equal.ts

@@ -317,6 +317,11 @@ function compareObjects(self: object, that: object): boolean {
         return false
       }
       return compareArrays(self, that)
+    } else if (ArrayBuffer.isView(self)) {
+      if (!ArrayBuffer.isView(that) || self.byteLength !== that.byteLength) {
+        return false
+      }
+      return compareTypedArrays(self as Uint8Array, that as Uint8Array)
     } else if (self instanceof Map) {
       if (!(that instanceof Map) || self.size !== that.size) {
         return false
@@ -370,6 +375,18 @@ function compareArrays(self: Array<unknown>, that: Array<unknown>): boolean {
   return true
 }
 
+function compareTypedArrays(self: Uint8Array, that: Uint8Array): boolean {
+  if (self.length !== that.length) {
+    return false
+  }
+  for (let i = 0; i < self.length; i++) {
+    if (self[i] !== that[i]) {
+      return false
+    }
+  }
+  return true
+}
+
 function compareRecords(
   self: Record<PropertyKey, unknown>,
   that: Record<PropertyKey, unknown>

package/src/Hash.ts

@@ -116,8 +116,8 @@ export const hash: <A>(self: A) => number = <A>(self: A) => {
             return self[symbol]()
           } else if (typeof self === "function") {
             return random(self)
-          } else if (Array.isArray(self)) {
-            return array(self)
+          } else if (Array.isArray(self) || ArrayBuffer.isView(self)) {
+            return array(self as any)
           } else if (self instanceof Map) {
             return hashMap(self)
           } else if (self instanceof Set) {

package/src/Semaphore.ts

@@ -55,7 +55,7 @@ export interface Semaphore {
    * If insufficient permits are available, the function will wait until they
    * are released by other tasks.
    */
-  withPermit<A, E, R>(this: Semaphore, self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
+  withPermit<A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>
 
   /**
    * Runs an effect only if the specified number of permits are immediately
@@ -220,9 +220,7 @@ class SemaphoreImpl implements Semaphore {
       )
   }
 
-  get withPermit(): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> {
-    return this.withPermits(1)
-  }
+  readonly withPermit = this.withPermits(1)
 
   withPermitsIfAvailable(n: number) {
     return <A, E, R>(self: Effect.Effect<A, E, R>) =>

package/src/unstable/ai/McpServer.ts

@@ -24,7 +24,7 @@ import { appendPreResponseHandlerUnsafe } from "../http/HttpEffect.ts"
 import * as HttpRouter from "../http/HttpRouter.ts"
 import * as HttpServerRequest from "../http/HttpServerRequest.ts"
 import * as HttpServerResponse from "../http/HttpServerResponse.ts"
-import type * as Rpc from "../rpc/Rpc.ts"
+import * as Rpc from "../rpc/Rpc.ts"
 import * as RpcClient from "../rpc/RpcClient.ts"
 import type * as RpcGroup from "../rpc/RpcGroup.ts"
 import * as RpcMessage from "../rpc/RpcMessage.ts"
@@ -353,9 +353,11 @@ export const run: (options: {
         Effect.provideServiceEffect(
           RpcClient.Protocol,
           RpcClient.Protocol.make(Effect.fnUntraced(function*(writeResponse) {
-            write = writeResponse
+            let cid = 0
+            write = (message) => writeResponse(cid, message)
             return {
-              send(request, _transferables) {
+              send(id, request, _transferables) {
+                cid = id
                 return protocol.send(clientId, {
                   ...request,
                   headers: undefined,
@@ -377,8 +379,8 @@ export const run: (options: {
     idleTimeToLive: 10000
   })
 
-  const clientMiddleware = McpServerClientMiddleware.of((effect, { clientId, headers, rpc }) => {
-    const initializePayload = getInitializedClient(clientSessions, clientId, headers)
+  const clientMiddleware = McpServerClientMiddleware.of((effect, { client, headers, rpc }) => {
+    const initializePayload = getInitializedClient(clientSessions, client.id, headers)
     const isInitialize = rpc._tag === "initialize"
     if (!isInitialize && !initializePayload) {
       return Effect.die(new Error(`Mcp-Session-Id does not exist`))
@@ -387,9 +389,9 @@ export const run: (options: {
       effect,
       McpServerClient,
       McpServerClient.of({
-        clientId,
+        clientId: client.id,
         initializePayload: initializePayload!,
-        getClient: RcMap.get(clients, clientId).pipe(
+        getClient: RcMap.get(clients, client.id).pipe(
           Effect.map(({ client }) => client)
         )
       })
@@ -429,7 +431,7 @@ export const run: (options: {
                 ? handler.handler(request.payload, {
                   rpc,
                   requestId: RpcMessage.RequestId(request.id),
-                  clientId,
+                  client: new Rpc.ServerClient(clientId),
                   headers: Headers.fromInput(request.headers)
                 }) as Effect.Effect<void>
                 : Effect.void
@@ -1176,7 +1178,7 @@ const layerHandlers = (serverInfo: {
       return ClientRpcs.of({
         // Requests
         ping: () => Effect.succeed({}),
-        initialize(params, { clientId }) {
+        initialize(params, { client }) {
           const requestedVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(params.protocolVersion)
             ? params.protocolVersion
             : LATEST_PROTOCOL_VERSION
@@ -1215,7 +1217,7 @@ const layerHandlers = (serverInfo: {
                   [mcpProtocolVersionHeader]: requestedVersion
                 })))
             } else {
-              options.clientSessions.set(String(clientId), params)
+              options.clientSessions.set(String(client.id), params)
             }
             return Effect.succeed({
               capabilities,
@@ -1255,15 +1257,15 @@ const layerHandlers = (serverInfo: {
           server.getPromptResult(r).pipe(
             Effect.provideService(CurrentLogLevel, currentLogLevel)
           ),
-        "prompts/list": (_, { clientId, headers }) =>
+        "prompts/list": (_, { client, headers }) =>
           Effect.sync(() => {
-            const client = getInitializedClient(options.clientSessions, clientId, headers)
-            return new ListPromptsResult({ prompts: filterByClient(client, server.prompts, "prompt") })
+            const initialized = getInitializedClient(options.clientSessions, client.id, headers)
+            return new ListPromptsResult({ prompts: filterByClient(initialized, server.prompts, "prompt") })
           }),
-        "resources/list": (_, { clientId, headers }) =>
+        "resources/list": (_, { client, headers }) =>
           Effect.sync(() => {
-            const client = getInitializedClient(options.clientSessions, clientId, headers)
-            return new ListResourcesResult({ resources: filterByClient(client, server.resources, "resource") })
+            const initialized = getInitializedClient(options.clientSessions, client.id, headers)
+            return new ListResourcesResult({ resources: filterByClient(initialized, server.resources, "resource") })
           }),
         "resources/read": ({ uri }) =>
           server.findResource(uri).pipe(
@@ -1273,22 +1275,22 @@ const layerHandlers = (serverInfo: {
           InternalError.notImplemented.asEffect(),
         "resources/unsubscribe": () =>
           InternalError.notImplemented.asEffect(),
-        "resources/templates/list": (_, { clientId, headers }) =>
+        "resources/templates/list": (_, { client, headers }) =>
           Effect.sync(() => {
-            const client = getInitializedClient(options.clientSessions, clientId, headers)
+            const initialized = getInitializedClient(options.clientSessions, client.id, headers)
             return new ListResourceTemplatesResult({
-              resourceTemplates: filterByClient(client, server.resourceTemplates, "template")
+              resourceTemplates: filterByClient(initialized, server.resourceTemplates, "template")
             })
           }),
         "tools/call": (r) =>
           server.callTool(r).pipe(
             Effect.provideService(CurrentLogLevel, currentLogLevel)
           ),
-        "tools/list": (_, { clientId, headers }) =>
+        "tools/list": (_, { client, headers }) =>
           Effect.sync(() => {
-            const client = getInitializedClient(options.clientSessions, clientId, headers)
+            const initialized = getInitializedClient(options.clientSessions, client.id, headers)
             return new ListToolsResult({
-              tools: filterByClient(client, server.tools, "tool")
+              tools: filterByClient(initialized, server.tools, "tool")
             })
           }),
 

package/src/unstable/eventlog/Event.ts

@@ -38,7 +38,6 @@ export interface Event<
 > {
   readonly [TypeId]: TypeId
   readonly tag: Tag
-  readonly key: string
   readonly primaryKey: (payload: Schema.Schema.Type<Payload>) => string
   readonly payload: Payload
   readonly payloadMsgPack: Msgpack.schema<Payload>
@@ -62,7 +61,6 @@ export interface EventHandler<in out Tag extends string> {
 export interface Any {
   readonly [TypeId]: TypeId
   readonly tag: string
-  readonly key: string
   readonly primaryKey: (payload: any) => string
   readonly payload: Schema.Top
   readonly payloadMsgPack: Msgpack.schema<Schema.Top>
@@ -312,7 +310,6 @@ export function make(options: {
   const error = options.error ?? Schema.Never
   return Object.assign(Object.create(Proto), {
     tag: options.tag,
-    key: serviceKey(options.tag),
     primaryKey: options.primaryKey,
     payload,
     payloadMsgPack: Msgpack.schema(payload),
@@ -338,8 +335,3 @@ export function addError(event: Any, error: Schema.Top): Any {
     error: Schema.Union([event.error, error])
   })
 }
-
-/**
- * @since 4.0.0
- */
-export const serviceKey = (tag: string): string => `effect/eventlog/Event/${tag}`

package/src/unstable/eventlog/EventGroup.ts

@@ -37,8 +37,6 @@ export const isEventGroup = (u: unknown): u is Any => Predicate.hasProperty(u, T
 export interface EventGroup<
   out Events extends Event.Any = Event.Any
 > extends Pipeable {
-  readonly _?: symbol
-  readonly __type?: Events | undefined
   readonly [TypeId]: TypeId
   readonly events: Record.ReadonlyRecord<string, Events>
 
@@ -112,8 +110,6 @@ const makeProto = <
   const EventGroupClass = (_: never) => {}
   const group = Object.assign(EventGroupClass, {
     [TypeId]: TypeId,
-    _: Symbol.for("~effect/eventlog/EventGroup"),
-    __type: undefined,
     events: options.events,
     add<
       Tag extends string,

package/src/unstable/eventlog/EventJournal.ts

@@ -8,10 +8,13 @@ import * as Data from "../../Data.ts"
 import * as DateTime from "../../DateTime.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
+import * as Order from "../../Order.ts"
 import * as PubSub from "../../PubSub.ts"
 import * as Schema from "../../Schema.ts"
 import type { Scope } from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import * as Msgpack from "../encoding/Msgpack.ts"
+import type { StoreId } from "./EventLogMessage.ts"
 
 /**
  * @since 4.0.0
@@ -44,17 +47,16 @@ export class EventJournal extends Context.Service<EventJournal, {
       readonly remoteId: RemoteId
       readonly entries: ReadonlyArray<RemoteEntry>
       readonly compact?:
-        | ((uncommitted: ReadonlyArray<RemoteEntry>) => Effect.Effect<
-          ReadonlyArray<[compacted: ReadonlyArray<Entry>, remoteEntries: ReadonlyArray<RemoteEntry>]>,
-          EventJournalError
-        >)
+        | ((uncommitted: ReadonlyArray<RemoteEntry>) => Effect.Effect<ReadonlyArray<Entry>, EventJournalError>)
         | undefined
       readonly effect: (options: {
         readonly entry: Entry
         readonly conflicts: ReadonlyArray<Entry>
       }) => Effect.Effect<void, EventJournalError>
     }
-  ) => Effect.Effect<void, EventJournalError>
+  ) => Effect.Effect<{
+    readonly duplicateEntries: ReadonlyArray<Entry>
+  }, EventJournalError>
 
   /**
    * Return the uncommitted entries for a remote source.
@@ -78,6 +80,11 @@ export class EventJournal extends Context.Service<EventJournal, {
    * Remove all data
    */
   readonly destroy: Effect.Effect<void, EventJournalError>
+
+  /**
+   * Run an effect with a lock on the journal.
+   */
+  readonly withLock: (storeId: StoreId) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
 }>()("effect/eventlog/EventJournal") {}
 
 const TypeId = "effect/eventlog/EventJournal/EventJournalError" as const
@@ -142,13 +149,28 @@ export type EntryIdTypeId = "effect/eventlog/EventJournal/EntryId"
  * @since 4.0.0
  * @category entry
  */
-export type EntryId = Uint8Array & Brand<EntryIdTypeId>
+export type EntryId = Uint8Array<ArrayBuffer> & Brand<EntryIdTypeId>
+
+/**
+ * @since 4.0.0
+ * @category entry
+ */
+export const EntryId = (Schema.Uint8Array as Schema.instanceOf<Uint8Array<ArrayBuffer>>).pipe(
+  Schema.brand(EntryIdTypeId)
+)
 
 /**
  * @since 4.0.0
  * @category entry
  */
-export const EntryId = Schema.Uint8Array.pipe(Schema.brand(EntryIdTypeId))
+export const EntryIdOrder = Order.make<EntryId>((a, b) => {
+  for (let i = 0; i < 16; i++) {
+    if (a[i] !== b[i]) {
+      return (a[i] - b[i]) < 0 ? -1 : 1
+    }
+  }
+  return 0
+})
 
 /**
  * @since 4.0.0
@@ -192,6 +214,11 @@ export class Entry extends Schema.Class<Entry>("effect/eventlog/EventJournal/Ent
    */
   static decodeArray = Schema.decodeUnknownEffect(Entry.arrayMsgpack)
 
+  /**
+   * @since 4.0.0
+   */
+  static Order = Order.make<Entry>((a, b) => EntryIdOrder(a.id, b.id))
+
   /**
    * @since 4.0.0
    */
@@ -232,6 +259,15 @@ export const makeMemory: Effect.Effect<EventJournal["Service"]> = Effect.gen(fun
   const byId = new Map<string, Entry>()
   const remotes = new Map<string, { sequence: number; missing: Array<Entry> }>()
   const pubsub = yield* PubSub.unbounded<Entry>()
+  const storeSemaphores = new Map<StoreId, Semaphore.Semaphore>()
+  const withLock = (storeId: StoreId) => {
+    let semaphore = storeSemaphores.get(storeId)
+    if (!semaphore) {
+      semaphore = Semaphore.makeUnsafe(1)
+      storeSemaphores.set(storeId, semaphore)
+    }
+    return semaphore.withPermit
+  }
 
   const ensureRemote = (remoteId: RemoteId) => {
     const remoteIdString = Uuid.stringify(remoteId)
@@ -271,8 +307,10 @@ export const makeMemory: Effect.Effect<EventJournal["Service"]> = Effect.gen(fun
       const remote = ensureRemote(options.remoteId)
       const uncommittedRemotes: Array<RemoteEntry> = []
       const uncommitted: Array<Entry> = []
+      const duplicateEntries: Array<Entry> = []
       for (const remoteEntry of options.entries) {
         if (byId.has(remoteEntry.entry.idString)) {
+          duplicateEntries.push(remoteEntry.entry)
           if (remoteEntry.remoteSequence > remote.sequence) {
             remote.sequence = remoteEntry.remoteSequence
           }
@@ -282,36 +320,38 @@ export const makeMemory: Effect.Effect<EventJournal["Service"]> = Effect.gen(fun
         uncommitted.push(remoteEntry.entry)
       }
 
-      const brackets = options.compact
+      const compacted = options.compact
         ? yield* options.compact(uncommittedRemotes)
-        : [[uncommitted, uncommittedRemotes]] as const
-
-      for (const [compacted, remoteEntries] of brackets) {
-        for (const originEntry of compacted) {
-          const entryMillis = entryIdMillis(originEntry.id)
-          const conflicts: Array<Entry> = []
-          for (let i = journal.length - 1; i >= -1; i--) {
-            const entry = journal[i]
-            if (entry !== undefined && entry.createdAtMillis > entryMillis) {
-              continue
-            }
-            for (let j = i + 2; j < journal.length; j++) {
-              const scannedEntry = journal[j]!
-              if (scannedEntry.event === originEntry.event && scannedEntry.primaryKey === originEntry.primaryKey) {
-                conflicts.push(scannedEntry)
-              }
+        : uncommitted
+
+      for (const originEntry of compacted) {
+        const entryMillis = entryIdMillis(originEntry.id)
+        const conflicts: Array<Entry> = []
+        for (let i = journal.length - 1; i >= -1; i--) {
+          const entry = journal[i]
+          if (entry !== undefined && entry.createdAtMillis > entryMillis) {
+            continue
+          }
+          for (let j = i + 2; j < journal.length; j++) {
+            const scannedEntry = journal[j]!
+            if (scannedEntry.event === originEntry.event && scannedEntry.primaryKey === originEntry.primaryKey) {
+              conflicts.push(scannedEntry)
             }
-            yield* options.effect({ entry: originEntry, conflicts })
-            break
           }
+          yield* options.effect({ entry: originEntry, conflicts })
+          break
         }
-        for (const remoteEntry of remoteEntries) {
-          journal.push(remoteEntry.entry)
-          if (remoteEntry.remoteSequence > remote.sequence) {
-            remote.sequence = remoteEntry.remoteSequence
-          }
+      }
+      for (const remoteEntry of uncommittedRemotes) {
+        journal.push(remoteEntry.entry)
+        byId.set(remoteEntry.entry.idString, remoteEntry.entry)
+        if (remoteEntry.remoteSequence > remote.sequence) {
+          remote.sequence = remoteEntry.remoteSequence
         }
-        journal.sort((a, b) => a.createdAtMillis - b.createdAtMillis)
+      }
+      journal.sort((a, b) => a.createdAtMillis - b.createdAtMillis)
+      return {
+        duplicateEntries
       }
     }),
     withRemoteUncommited: (remoteId, f) =>
@@ -338,7 +378,8 @@ export const makeMemory: Effect.Effect<EventJournal["Service"]> = Effect.gen(fun
       journal.length = 0
       byId.clear()
       remotes.clear()
-    })
+    }),
+    withLock
   })
 })
 
@@ -413,6 +454,7 @@ export const makeIndexedDb = (options?: {
       writeFromRemote: Effect.fnUntraced(function*(options) {
         const uncommitted: Array<Entry> = []
         const uncommittedRemotes: Array<RemoteEntry> = []
+        const duplicateEntries: Array<Entry> = []
 
         yield* Effect.callback<void, EventJournalError>((resume) => {
           const tx = db.transaction(["entries", "remotes"], "readwrite")
@@ -426,6 +468,7 @@ export const makeIndexedDb = (options?: {
             const entryIdKey = entry.id as IDBValidKey
             entries.get(entryIdKey).onsuccess = (event) => {
               if (event.target && "result" in event.target && event.target.result) {
+                duplicateEntries.push(entry)
                 remotes.put({
                   remoteId: options.remoteId,
                   entryId: entry.id,
@@ -445,58 +488,58 @@ export const makeIndexedDb = (options?: {
           return Effect.sync(() => tx.abort())
         })
 
-        const brackets = options.compact
+        const compacted = options.compact
           ? yield* options.compact(uncommittedRemotes)
-          : [[uncommitted, uncommittedRemotes]] as const
-
-        for (const [compacted, remoteEntries] of brackets) {
-          for (const originEntry of compacted) {
-            const conflicts: Array<Entry> = []
-            yield* Effect.callback<void, EventJournalError>((resume) => {
-              const tx = db.transaction("entries", "readonly")
-              const entries = tx.objectStore("entries")
-              const cursorRequest = entries.index("id").openCursor(
-                IDBKeyRange.lowerBound(originEntry.id as IDBValidKey, true),
-                "next"
-              )
-              cursorRequest.onsuccess = () => {
-                const cursor = cursorRequest.result
-                if (!cursor) return
-                const decodedEntry = decodeEntryIdb(cursor.value)
-                if (
-                  decodedEntry.event === originEntry.event &&
-                  decodedEntry.primaryKey === originEntry.primaryKey
-                ) {
-                  conflicts.push(decodedEntry)
-                }
-                cursor.continue()
-              }
-              tx.oncomplete = () => resume(Effect.void)
-              tx.onerror = () =>
-                resume(Effect.fail(new EventJournalError({ method: "writeFromRemote", cause: tx.error })))
-              return Effect.sync(() => tx.abort())
-            })
-
-            yield* options.effect({ entry: originEntry, conflicts })
-          }
+          : uncommitted
 
+        for (const originEntry of compacted) {
+          const conflicts: Array<Entry> = []
           yield* Effect.callback<void, EventJournalError>((resume) => {
-            const tx = db.transaction(["entries", "remotes"], "readwrite")
+            const tx = db.transaction("entries", "readonly")
             const entries = tx.objectStore("entries")
-            const remotes = tx.objectStore("remotes")
-            for (const remoteEntry of remoteEntries) {
-              entries.add(encodeEntryIdb(remoteEntry.entry))
-              remotes.put({
-                remoteId: options.remoteId,
-                entryId: remoteEntry.entry.id,
-                sequence: remoteEntry.remoteSequence
-              })
+            const cursorRequest = entries.index("id").openCursor(
+              IDBKeyRange.lowerBound(originEntry.id as IDBValidKey, true),
+              "next"
+            )
+            cursorRequest.onsuccess = () => {
+              const cursor = cursorRequest.result
+              if (!cursor) return
+              const decodedEntry = decodeEntryIdb(cursor.value)
+              if (
+                decodedEntry.event === originEntry.event &&
+                decodedEntry.primaryKey === originEntry.primaryKey
+              ) {
+                conflicts.push(decodedEntry)
+              }
+              cursor.continue()
             }
             tx.oncomplete = () => resume(Effect.void)
             tx.onerror = () =>
               resume(Effect.fail(new EventJournalError({ method: "writeFromRemote", cause: tx.error })))
             return Effect.sync(() => tx.abort())
           })
+
+          yield* options.effect({ entry: originEntry, conflicts })
+        }
+
+        yield* Effect.callback<void, EventJournalError>((resume) => {
+          const tx = db.transaction(["entries", "remotes"], "readwrite")
+          const entries = tx.objectStore("entries")
+          const remotes = tx.objectStore("remotes")
+          for (const remoteEntry of uncommittedRemotes) {
+            entries.add(encodeEntryIdb(remoteEntry.entry))
+            remotes.put({
+              remoteId: options.remoteId,
+              entryId: remoteEntry.entry.id,
+              sequence: remoteEntry.remoteSequence
+            })
+          }
+          tx.oncomplete = () => resume(Effect.void)
+          tx.onerror = () => resume(Effect.fail(new EventJournalError({ method: "writeFromRemote", cause: tx.error })))
+          return Effect.sync(() => tx.abort())
+        })
+        return {
+          duplicateEntries
         }
       }),
       withRemoteUncommited: (remoteId, f) =>
@@ -570,10 +613,35 @@ export const makeIndexedDb = (options?: {
       changes: PubSub.subscribe(pubsub),
       destroy: Effect.sync(() => {
         indexedDB.deleteDatabase(database)
-      })
+      }),
+      withLock: yield* makeBrowserWithLock(database)
     })
   })
 
+const makeBrowserWithLock = Effect.fnUntraced(function*(key: string) {
+  if (typeof navigator !== "undefined" && "locks" in navigator) {
+    return (storeId: StoreId) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
+      Effect.callback<A, E, R>((resume, signal) => {
+        navigator.locks.request(`${key}/${storeId}`, { signal }, () =>
+          new Promise<void>((resolve) => {
+            resume(Effect.onExit(self, () => {
+              resolve()
+              return Effect.void
+            }))
+          })).catch((defect) => resume(Effect.die(defect)))
+      })
+  }
+  const semaphores = new Map<StoreId, Semaphore.Semaphore>()
+  return (storeId: StoreId) => {
+    let semaphore = semaphores.get(storeId)
+    if (!semaphore) {
+      semaphore = Semaphore.makeUnsafe(1)
+      semaphores.set(storeId, semaphore)
+    }
+    return semaphore.withPermit
+  }
+})
+
 const decodeEntryIdb = Schema.decodeSync(Entry)
 const encodeEntryIdb = Schema.encodeSync(Entry)
 const EntryIdbArray = Schema.Array(Entry)