@effect/cluster 0.37.2 → 0.38.1

package/src/Sharding.ts

@@ -21,6 +21,7 @@ import * as HashMap from "effect/HashMap"
 import * as Iterable from "effect/Iterable"
 import * as Layer from "effect/Layer"
 import * as MutableHashMap from "effect/MutableHashMap"
+import * as MutableHashSet from "effect/MutableHashSet"
 import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
@@ -74,7 +75,7 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
    * Returns the `ShardId` of the shard to which the entity at the specified
    * `address` is assigned.
    */
-  readonly getShardId: (entityId: EntityId) => ShardId
+  readonly getShardId: (entityId: EntityId, group: string) => ShardId
 
   /**
    * Returns `true` if sharding is shutting down, `false` otherwise.
@@ -115,7 +116,10 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
    */
   readonly registerSingleton: <E, R>(
     name: string,
-    run: Effect.Effect<void, E, R>
+    run: Effect.Effect<void, E, R>,
+    options?: {
+      readonly shardGroup?: string | undefined
+    }
   ) => Effect.Effect<void, never, Exclude<R, Scope.Scope>>
 
   /**
@@ -182,10 +186,10 @@ const make = Effect.gen(function*() {
   const entityManagers = new Map<EntityType, EntityManagerState>()
 
   const shardAssignments = MutableHashMap.empty<ShardId, RunnerAddress>()
-  const selfShards = new Set<ShardId>()
+  const selfShards = MutableHashSet.empty<ShardId>()
 
   // the active shards are the ones that we have acquired the lock for
-  const acquiredShards = new Set<ShardId>()
+  const acquiredShards = MutableHashSet.empty<ShardId>()
   const activeShardsLatch = yield* Effect.makeLatch(false)
 
   const events = yield* PubSub.unbounded<ShardingRegistrationEvent>()
@@ -194,12 +198,13 @@ const make = Effect.gen(function*() {
   const isLocalRunner = (address: RunnerAddress) =>
     Option.isSome(config.runnerAddress) && Equal.equals(address, config.runnerAddress.value)
 
-  function getShardId(entityId: EntityId): ShardId {
-    return ShardId.make((Math.abs(hashString(entityId) % config.numberOfShards)) + 1)
+  function getShardId(entityId: EntityId, group: string): ShardId {
+    const id = Math.abs(hashString(entityId) % config.shardsPerGroup) + 1
+    return ShardId.make({ group, id }, { disableValidation: true })
   }
 
   function isEntityOnLocalShards(address: EntityAddress): boolean {
-    return acquiredShards.has(address.shardId)
+    return MutableHashSet.has(acquiredShards, address.shardId)
   }
 
   // --- Shard acquisition ---
@@ -211,30 +216,30 @@ const make = Effect.gen(function*() {
       return Effect.ignore(shardStorage.releaseAll(selfAddress))
     })
 
-    const releasingShards = new Set<ShardId>()
+    const releasingShards = MutableHashSet.empty<ShardId>()
     yield* Effect.gen(function*() {
       while (true) {
         yield* activeShardsLatch.await
 
         // if a shard is no longer assigned to this runner, we release it
         for (const shardId of acquiredShards) {
-          if (selfShards.has(shardId)) continue
-          acquiredShards.delete(shardId)
-          releasingShards.add(shardId)
+          if (MutableHashSet.has(selfShards, shardId)) continue
+          MutableHashSet.remove(acquiredShards, shardId)
+          MutableHashSet.add(releasingShards, shardId)
         }
         // if a shard has been assigned to this runner, we acquire it
-        const unacquiredShards = new Set<ShardId>()
+        const unacquiredShards = MutableHashSet.empty<ShardId>()
         for (const shardId of selfShards) {
-          if (acquiredShards.has(shardId) || releasingShards.has(shardId)) continue
-          unacquiredShards.add(shardId)
+          if (MutableHashSet.has(acquiredShards, shardId) || MutableHashSet.has(releasingShards, shardId)) continue
+          MutableHashSet.add(unacquiredShards, shardId)
         }
 
-        if (releasingShards.size > 0) {
+        if (MutableHashSet.size(releasingShards) > 0) {
           yield* Effect.forkIn(syncSingletons, shardingScope)
           yield* releaseShards
         }
 
-        if (unacquiredShards.size === 0) {
+        if (MutableHashSet.size(unacquiredShards) === 0) {
           yield* activeShardsLatch.close
           continue
         }
@@ -242,7 +247,7 @@ const make = Effect.gen(function*() {
         const acquired = yield* shardStorage.acquire(selfAddress, unacquiredShards)
         yield* Effect.ignore(storage.resetShards(acquired))
         for (const shardId of acquired) {
-          acquiredShards.add(shardId)
+          MutableHashSet.add(acquiredShards, shardId)
         }
         if (acquired.length > 0) {
           yield* storageReadLatch.open
@@ -272,12 +277,12 @@ const make = Effect.gen(function*() {
     ).pipe(
       Effect.flatMap((acquired) => {
         for (const shardId of acquiredShards) {
-          if (!acquired.includes(shardId)) {
-            acquiredShards.delete(shardId)
-            releasingShards.add(shardId)
+          if (!acquired.some((_) => _[Equal.symbol](shardId))) {
+            MutableHashSet.remove(acquiredShards, shardId)
+            MutableHashSet.add(releasingShards, shardId)
           }
         }
-        return releasingShards.size > 0 ?
+        return MutableHashSet.size(releasingShards) > 0 ?
           Effect.andThen(
             Effect.forkIn(syncSingletons, shardingScope),
             releaseShards
@@ -315,7 +320,7 @@ const make = Effect.gen(function*() {
                 runner: selfAddress
               }),
               Effect.andThen(() => {
-                releasingShards.delete(shardId)
+                MutableHashSet.remove(releasingShards, shardId)
               })
             ),
           { concurrency: "unbounded", discard: true }
@@ -325,7 +330,7 @@ const make = Effect.gen(function*() {
   }
 
   const clearSelfShards = Effect.suspend(() => {
-    selfShards.clear()
+    MutableHashSet.clear(selfShards)
     return activeShardsLatch.open
   })
 
@@ -336,9 +341,10 @@ const make = Effect.gen(function*() {
   const withSingletonLock = Effect.unsafeMakeSemaphore(1).withPermits(1)
 
   const registerSingleton: Sharding["Type"]["registerSingleton"] = Effect.fnUntraced(
-    function*(name, run) {
+    function*(name, run, options) {
+      const shardGroup = options?.shardGroup ?? "default"
       const address = new SingletonAddress({
-        shardId: getShardId(EntityId.make(name)),
+        shardId: getShardId(EntityId.make(name), shardGroup),
         name
       })
 
@@ -365,7 +371,7 @@ const make = Effect.gen(function*() {
       yield* PubSub.publish(events, SingletonRegistered({ address }))
 
       // start if we are on the right shard
-      if (acquiredShards.has(address.shardId)) {
+      if (MutableHashSet.has(acquiredShards, address.shardId)) {
         yield* Effect.logDebug("Starting singleton", address)
         yield* FiberMap.run(singletonFibers, address, wrappedRun)
       }
@@ -377,7 +383,7 @@ const make = Effect.gen(function*() {
     for (const [shardId, map] of singletons) {
       for (const [address, run] of map) {
         const running = FiberMap.unsafeHas(singletonFibers, address)
-        const shouldBeRunning = acquiredShards.has(shardId)
+        const shouldBeRunning = MutableHashSet.has(acquiredShards, shardId)
         if (running && !shouldBeRunning) {
           yield* Effect.logDebug("Stopping singleton", address)
           internalInterruptors.add(yield* Effect.fiberId)
@@ -452,7 +458,7 @@ const make = Effect.gen(function*() {
               currentSentRequestIds.add(message.envelope.requestId)
             }
             const address = message.envelope.address
-            if (!acquiredShards.has(address.shardId)) {
+            if (!MutableHashSet.has(acquiredShards, address.shardId)) {
               return Effect.void
             }
             const state = entityManagers.get(address.entityType)
@@ -580,7 +586,7 @@ const make = Effect.gen(function*() {
 
         while (!done) {
           // if the shard is no longer assigned to this runner, we stop
-          if (!acquiredShards.has(address.shardId)) {
+          if (!MutableHashSet.has(acquiredShards, address.shardId)) {
             return
           }
 
@@ -606,7 +612,7 @@ const make = Effect.gen(function*() {
             EntityNotManagedByRunner | EntityNotAssignedToRunner
           > = Effect.catchTags(
             Effect.suspend(() => {
-              if (!acquiredShards.has(address.shardId)) {
+              if (!MutableHashSet.has(acquiredShards, address.shardId)) {
                 return Effect.fail(new EntityNotAssignedToRunner({ address }))
               }
 
@@ -805,7 +811,7 @@ const make = Effect.gen(function*() {
   yield* Effect.gen(function*() {
     yield* Effect.logDebug("Registering with shard manager")
     if (Option.isSome(config.runnerAddress)) {
-      const machineId = yield* shardManager.register(config.runnerAddress.value)
+      const machineId = yield* shardManager.register(config.runnerAddress.value, config.shardGroups)
       yield* snowflakeGen.setMachineId(machineId)
     }
 
@@ -832,8 +838,8 @@ const make = Effect.gen(function*() {
               }
               if (!MutableRef.get(isShutdown) && isLocalRunner(event.address)) {
                 for (const shardId of event.shards) {
-                  if (selfShards.has(shardId)) continue
-                  selfShards.add(shardId)
+                  if (MutableHashSet.has(selfShards, shardId)) continue
+                  MutableHashSet.add(selfShards, shardId)
                 }
                 yield* activeShardsLatch.open
               }
@@ -845,7 +851,7 @@ const make = Effect.gen(function*() {
               }
               if (isLocalRunner(event.address)) {
                 for (const shard of event.shards) {
-                  selfShards.delete(shard)
+                  MutableHashSet.remove(selfShards, shard)
                 }
                 yield* activeShardsLatch.open
               }
@@ -896,20 +902,20 @@ const make = Effect.gen(function*() {
     for (const [shardId, runner] of assignments) {
       if (Option.isNone(runner)) {
         MutableHashMap.remove(shardAssignments, shardId)
-        selfShards.delete(shardId)
+        MutableHashSet.remove(selfShards, shardId)
         continue
       }
 
       MutableHashMap.set(shardAssignments, shardId, runner.value)
 
       if (!isLocalRunner(runner.value)) {
-        selfShards.delete(shardId)
+        MutableHashSet.remove(selfShards, shardId)
         continue
       }
-      if (MutableRef.get(isShutdown) || selfShards.has(shardId)) {
+      if (MutableRef.get(isShutdown) || MutableHashSet.has(selfShards, shardId)) {
         continue
       }
-      selfShards.add(shardId)
+      MutableHashSet.add(selfShards, shardId)
     }
 
     yield* activeShardsLatch.open
@@ -1054,7 +1060,7 @@ const make = Effect.gen(function*() {
       return {
         ...wrappedClient,
         [currentClientAddress]: ClientAddressTag.context(EntityAddress.make({
-          shardId: getShardId(id),
+          shardId: getShardId(id, entity.getShardGroup(entityId as EntityId)),
           entityId: id,
           entityType: entity.type
         }))

package/src/ShardingConfig.ts

@@ -20,22 +20,35 @@ import { RunnerAddress } from "./RunnerAddress.js"
  */
 export class ShardingConfig extends Context.Tag("@effect/cluster/ShardingConfig")<ShardingConfig, {
   /**
-   * The address for the current runner.
+   * The address for the current runner that other runners can use to
+   * communicate with it.
    *
    * If `None`, the runner is not part of the cluster and will be in a client-only
    * mode.
    */
   readonly runnerAddress: Option.Option<RunnerAddress>
+  /**
+   * The listen address for the current runner.
+   *
+   * Defaults to the `runnerAddress`.
+   */
+  readonly runnerListenAddress: Option.Option<RunnerAddress>
   /**
    * The version of the current runner.
    */
   readonly serverVersion: number
   /**
-   * The number of shards to allocate to a runner.
+   * The shard groups that are assigned to this runner.
+   *
+   * Defaults to `["default"]`.
+   */
+  readonly shardGroups: ReadonlyArray<string>
+  /**
+   * The number of shards to allocate per shard group.
    *
    * **Note**: this value should be consistent across all runners.
    */
-  readonly numberOfShards: number
+  readonly shardsPerGroup: number
   /**
    * The address of the shard manager.
    */
@@ -89,10 +102,12 @@ const defaultRunnerAddress = RunnerAddress.make({ host: "localhost", port: 34431
  */
 export const defaults: ShardingConfig["Type"] = {
   runnerAddress: Option.some(defaultRunnerAddress),
+  runnerListenAddress: Option.none(),
   serverVersion: 1,
-  numberOfShards: 300,
+  shardsPerGroup: 300,
   shardManagerAddress: RunnerAddress.make({ host: "localhost", port: 8080 }),
   shardManagerUnavailableTimeout: Duration.minutes(10),
+  shardGroups: ["default"],
   entityMailboxCapacity: 4096,
   entityMaxIdleTime: Duration.minutes(1),
   entityTerminationTimeout: Duration.seconds(15),
@@ -131,13 +146,27 @@ export const config: Config.Config<ShardingConfig["Type"]> = Config.all({
       Config.withDescription("The port used for inter-runner communication.")
     )
   }).pipe(Config.map((options) => RunnerAddress.make(options)), Config.option),
+  runnerListenAddress: Config.all({
+    host: Config.string("listenHost").pipe(
+      Config.withDefault(defaultRunnerAddress.host),
+      Config.withDescription("The host to listen on.")
+    ),
+    port: Config.integer("listenPort").pipe(
+      Config.withDefault(defaultRunnerAddress.port),
+      Config.withDescription("The port to listen on.")
+    )
+  }).pipe(Config.map((options) => RunnerAddress.make(options)), Config.option),
   serverVersion: Config.integer("serverVersion").pipe(
     Config.withDefault(defaults.serverVersion),
     Config.withDescription("The version of the current runner.")
   ),
-  numberOfShards: Config.integer("numberOfShards").pipe(
-    Config.withDefault(defaults.numberOfShards),
-    Config.withDescription("The number of shards to allocate to a runner.")
+  shardGroups: Config.array(Config.string("shardGroups")).pipe(
+    Config.withDefault(["default"]),
+    Config.withDescription("The shard groups that are assigned to this runner.")
+  ),
+  shardsPerGroup: Config.integer("shardsPerGroup").pipe(
+    Config.withDefault(defaults.shardsPerGroup),
+    Config.withDescription("The number of shards to allocate per shard group.")
   ),
   shardManagerAddress: Config.all({
     host: Config.string("shardManagerHost").pipe(

package/src/Singleton.ts

@@ -12,9 +12,12 @@ import { Sharding } from "./Sharding.js"
  */
 export const make = <E, R>(
   name: string,
-  run: Effect.Effect<void, E, R>
+  run: Effect.Effect<void, E, R>,
+  options?: {
+    readonly shardGroup?: string | undefined
+  }
 ): Layer.Layer<never, never, Sharding | Exclude<R, Scope>> =>
   Layer.effectDiscard(Effect.gen(function*() {
     const sharding = yield* Sharding
-    yield* sharding.registerSingleton(name, run)
+    yield* sharding.registerSingleton(name, run, options)
   }))

package/src/SingletonAddress.ts

@@ -36,12 +36,12 @@ export class SingletonAddress extends Schema.Class<SingletonAddress>("@effect/cl
    * @since 1.0.0
    */
   [Hash.symbol]() {
-    return Hash.cached(this)(Hash.string(`${this.shardId}:${this.name}`))
+    return Hash.cached(this)(Hash.string(`${this.name}:${this.shardId.toString()}`))
   }
   /**
    * @since 1.0.0
    */
   [Equal.symbol](that: SingletonAddress): boolean {
-    return this.shardId === that.shardId && this.name === that.name
+    return this.name === that.name && this.shardId[Equal.symbol](that.shardId)
   }
 }

package/src/SqlMessageStorage.ts

@@ -15,6 +15,7 @@ import type * as Envelope from "./Envelope.js"
 import * as MessageStorage from "./MessageStorage.js"
 import { SaveResultEncoded } from "./MessageStorage.js"
 import type * as Reply from "./Reply.js"
+import { ShardId } from "./ShardId.js"
 import type { ShardingConfig } from "./ShardingConfig.js"
 import * as Snowflake from "./Snowflake.js"
 
@@ -48,15 +49,15 @@ export const make = Effect.fnUntraced(function*(options?: {
           id BIGINT PRIMARY KEY,
           rowid BIGINT IDENTITY(1,1),
           message_id VARCHAR(255),
-          shard_id INT NOT NULL,
-          entity_type VARCHAR(255) NOT NULL,
+          shard_id VARCHAR(50) NOT NULL,
+          entity_type VARCHAR(50) NOT NULL,
           entity_id VARCHAR(255) NOT NULL,
           kind INT NOT NULL,
-          tag VARCHAR(255),
+          tag VARCHAR(50),
           payload TEXT,
           headers TEXT,
-          trace_id VARCHAR(255),
-          span_id VARCHAR(255),
+          trace_id VARCHAR(32),
+          span_id VARCHAR(16),
           sampled BIT,
           processed BIT NOT NULL DEFAULT 0,
           request_id BIGINT NOT NULL,
@@ -74,15 +75,15 @@ export const make = Effect.fnUntraced(function*(options?: {
           id BIGINT NOT NULL,
           rowid BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
           message_id VARCHAR(255),
-          shard_id INT NOT NULL,
-          entity_type VARCHAR(255) NOT NULL,
+          shard_id VARCHAR(50) NOT NULL,
+          entity_type VARCHAR(50) NOT NULL,
           entity_id VARCHAR(255) NOT NULL,
           kind INT NOT NULL,
-          tag VARCHAR(255),
+          tag VARCHAR(50),
           payload TEXT,
           headers TEXT,
-          trace_id VARCHAR(255),
-          span_id VARCHAR(255),
+          trace_id VARCHAR(32),
+          span_id VARCHAR(16),
           sampled BOOLEAN,
           processed BOOLEAN NOT NULL DEFAULT FALSE,
           request_id BIGINT NOT NULL,
@@ -101,15 +102,15 @@ export const make = Effect.fnUntraced(function*(options?: {
           id BIGINT PRIMARY KEY,
           rowid BIGSERIAL,
           message_id VARCHAR(255),
-          shard_id INT NOT NULL,
-          entity_type VARCHAR(255) NOT NULL,
+          shard_id VARCHAR(50) NOT NULL,
+          entity_type VARCHAR(50) NOT NULL,
           entity_id VARCHAR(255) NOT NULL,
           kind INT NOT NULL,
-          tag VARCHAR(255),
+          tag VARCHAR(50),
           payload TEXT,
           headers TEXT,
-          trace_id VARCHAR(255),
-          span_id VARCHAR(255),
+          trace_id VARCHAR(32),
+          span_id VARCHAR(16),
           sampled BOOLEAN,
           processed BOOLEAN NOT NULL DEFAULT FALSE,
           request_id BIGINT NOT NULL,
@@ -127,7 +128,7 @@ export const make = Effect.fnUntraced(function*(options?: {
         CREATE TABLE IF NOT EXISTS ${messagesTableSql} (
           id INTEGER PRIMARY KEY,
           message_id TEXT,
-          shard_id INTEGER NOT NULL,
+          shard_id TEXT NOT NULL,
           entity_type TEXT NOT NULL,
           entity_id TEXT NOT NULL,
           kind INTEGER NOT NULL,
@@ -315,7 +316,7 @@ export const make = Effect.fnUntraced(function*(options?: {
         return {
           id: envelope.requestId,
           message_id,
-          shard_id: envelope.address.shardId,
+          shard_id: ShardId.toString(envelope.address.shardId),
           entity_type: envelope.address.entityType,
           entity_id: envelope.address.entityId,
           kind: messageKind.Request,
@@ -333,7 +334,7 @@ export const make = Effect.fnUntraced(function*(options?: {
         return {
           id: envelope.id,
           message_id,
-          shard_id: envelope.address.shardId,
+          shard_id: ShardId.toString(envelope.address.shardId),
           entity_type: envelope.address.entityType,
           entity_id: envelope.address.entityId,
           kind: messageKind.AckChunk,
@@ -351,7 +352,7 @@ export const make = Effect.fnUntraced(function*(options?: {
         return {
           id: envelope.id,
           message_id,
-          shard_id: envelope.address.shardId,
+          shard_id: ShardId.toString(envelope.address.shardId),
           entity_type: envelope.address.entityType,
           entity_id: envelope.address.entityId,
           kind: messageKind.Interrupt,
@@ -393,7 +394,7 @@ export const make = Effect.fnUntraced(function*(options?: {
             _tag: "Request",
             requestId: String(row.id),
             address: {
-              shardId: Number(row.shard_id),
+              shardId: ShardId.fromStringEncoded(row.shard_id),
               entityType: row.entity_type,
               entityId: row.entity_id
             },
@@ -422,7 +423,7 @@ export const make = Effect.fnUntraced(function*(options?: {
             requestId: String(row.request_id!),
             replyId: String(row.reply_id!),
             address: {
-              shardId: Number(row.shard_id),
+              shardId: ShardId.fromStringEncoded(row.shard_id),
               entityType: row.entity_type,
               entityId: row.entity_id
             }
@@ -436,7 +437,7 @@ export const make = Effect.fnUntraced(function*(options?: {
             id: String(row.id),
             requestId: String(row.request_id!),
             address: {
-              shardId: Number(row.shard_id),
+              shardId: ShardId.fromStringEncoded(row.shard_id),
               entityType: row.entity_type,
               entityId: row.entity_id
             }
@@ -549,15 +550,20 @@ export const make = Effect.fnUntraced(function*(options?: {
   })
   const sqlNow = sql.literal(sqlNowString)
 
+  const wrapString = sql.onDialectOrElse({
+    mssql: () => (s: string) => `N'${s}'`,
+    orElse: () => (s: string) => `'${s}'`
+  })
+
   const getUnprocessedMessages = sql.onDialectOrElse({
-    pg: () => (shardIds: ReadonlyArray<number>, now: number) =>
+    pg: () => (shardIds: ReadonlyArray<string>, now: number) =>
       sql<MessageJoinRow>`
         UPDATE ${messagesTableSql} m
         SET last_read = ${sqlNow}
         FROM (
           SELECT m.*
           FROM ${messagesTableSql} m
-          WHERE m.shard_id IN (${sql.literal(shardIds.map(String).join(","))})
+          WHERE m.shard_id IN (${sql.literal(shardIds.map(wrapString).join(","))})
           AND NOT EXISTS (
             SELECT 1 FROM ${repliesTableSql}
             WHERE request_id = m.request_id
@@ -573,12 +579,12 @@ export const make = Effect.fnUntraced(function*(options?: {
         WHERE m.id = ids.id
         RETURNING ids.*, r.id as reply_reply_id, r.kind as reply_kind, r.payload as reply_payload, r.sequence as reply_sequence
       `,
-    orElse: () => (shardIds: ReadonlyArray<number>, now: number) =>
+    orElse: () => (shardIds: ReadonlyArray<string>, now: number) =>
       sql<MessageJoinRow>`
         SELECT m.*, r.id as reply_reply_id, r.kind as reply_kind, r.payload as reply_payload, r.sequence as reply_sequence
         FROM ${messagesTableSql} m
         LEFT JOIN ${repliesTableSql} r ON r.id = m.last_reply_id
-        WHERE m.shard_id IN (${sql.literal(shardIds.map(String).join(","))})
+        WHERE m.shard_id IN (${sql.literal(shardIds.map(wrapString).join(","))})
         AND NOT EXISTS (
           SELECT 1 FROM ${repliesTableSql}
           WHERE request_id = m.request_id
@@ -653,7 +659,7 @@ export const make = Effect.fnUntraced(function*(options?: {
         const row = replyToRow(reply)
         const update = reply._tag === "Chunk" ?
           sql`UPDATE ${messagesTableSql} SET last_reply_id = ${reply.id} WHERE id = ${reply.requestId}` :
-          sql`UPDATE ${messagesTableSql} SET processed = ${sqlTrue}, last_reply_id = NULL WHERE request_id = ${reply.requestId}`
+          sql`UPDATE ${messagesTableSql} SET processed = ${sqlTrue}, last_reply_id = ${reply.id} WHERE request_id = ${reply.requestId}`
         return update.unprepared.pipe(
           Effect.andThen(sql`INSERT INTO ${repliesTableSql} ${sql.insert(row)}`),
           sql.withTransaction
@@ -772,7 +778,7 @@ export const make = Effect.fnUntraced(function*(options?: {
         UPDATE ${messagesTableSql}
         SET last_read = NULL
         WHERE processed = ${sqlFalse}
-        AND shard_id = ${address.shardId}
+        AND shard_id = ${address.shardId.toString()}
         AND entity_type = ${address.entityType}
         AND entity_id = ${address.entityId}
       `.pipe(
@@ -808,7 +814,7 @@ export const make = Effect.fnUntraced(function*(options?: {
         UPDATE ${messagesTableSql}
         SET last_read = NULL
         WHERE processed = ${sqlFalse}
-        AND shard_id IN (${sql.literal(shardIds.join(","))})
+        AND shard_id IN (${sql.literal(shardIds.map(wrapString).join(","))})
       `.pipe(
         Effect.asVoid,
         PersistenceError.refail,
@@ -875,7 +881,7 @@ const replyFromRow = (row: ReplyRow): Reply.ReplyEncoded<any> =>
 type MessageRow = {
   readonly id: string | bigint
   readonly message_id: string | null
-  readonly shard_id: number | bigint
+  readonly shard_id: string
   readonly entity_type: string
   readonly entity_id: string
   readonly kind: 0 | 1 | 2 | 0n | 1n | 2n