@effect-app/infra 4.0.0-beta.281 → 4.0.0-beta.282

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @effect-app/infra
 
+## 4.0.0-beta.282
+
+### Patch Changes
+
+- b2df3fa: Align `Schema.Void` with TypeScript `void` return-value semantics (effect-smol PR #2475 / `b7d46ab`).
+
+  `S.Void` now accepts **any present value** at runtime and discards it to `undefined`, while keeping the decoded/encoded type as `void` — matching a `void` return whose result callers never observe. This is implemented as an override of the AST node in a new `effect-app/SchemaAST` module (`export * from "effect/SchemaAST"` plus a `Void` subclass whose parser mirrors the PR's `fromAnyToConst(undefined)`), so there is a single canonical `Void` used everywhere, including RPC success schemas.
+
+  - New `effect-app/SchemaAST` module; internal `SchemaAST` imports across the libs now route through it.
+  - Removed `ForceVoid` from `effect-app/client/makeClient` — use `S.Void` directly, which now carries this behaviour.
+  - `S.Void_` remains available as effect's original (`undefined`-only) Void.
+
+- f150cf9: Remove obsolete queue machinery left unused after the move to cluster entities: the SB/SQLite/mem `QueueMaker` implementations (`QueueMaker/{SQLQueue,memQueue,sbqueue}.ts`), their `ServiceBus.ts`/`memQueue.ts` transports, and `RequestFiberSet.ts` (its `setRootParentSpan` helper is inlined into `MainFiberSet`). `effect-app/QueueMaker` keeps only `QueueMeta`; the `QueueBase` interface and empty `QueueMaker` ops object are dropped.
+- e8842aa: Update effect packages to `4.0.0-beta.88` (from `beta.86`): `effect`, `@effect/platform-node`, `@effect/platform-browser`, `@effect/atom-vue`, `@effect/sql-sqlite-node`, `@effect/vitest`. Also bump `@effect-app/cli` to `2.1.0-beta.35`. No source changes required — typecheck and tests pass unchanged.
+- Updated dependencies [b2df3fa]
+- Updated dependencies [f150cf9]
+- Updated dependencies [e8842aa]
+  - effect-app@4.0.0-beta.282
+
 ## 4.0.0-beta.281
 
 ### Patch Changes

package/dist/ClusterCosmos.d.ts

@@ -18,25 +18,25 @@ export interface ClusterCosmosConfig {
 export declare const makeMessageStorage: (options?: {
     readonly prefix?: string | undefined;
 } | undefined) => Effect.Effect<{
-    readonly saveRequest: <R extends import("effect/unstable/rpc/Rpc").Any>(envelope: import("effect/unstable/cluster/Message").OutgoingRequest<R>) => Effect.Effect<MessageStorage.SaveResult<R>, import("effect/unstable/cluster/ClusterError").MalformedMessage | PersistenceError, never>;
-    readonly saveEnvelope: (envelope: import("effect/unstable/cluster/Message").OutgoingEnvelope) => Effect.Effect<void, import("effect/unstable/cluster/ClusterError").MalformedMessage | PersistenceError, never>;
-    readonly saveReply: <R extends import("effect/unstable/rpc/Rpc").Any>(reply: Reply.ReplyWithContext<R>) => Effect.Effect<void, import("effect/unstable/cluster/ClusterError").MalformedMessage | PersistenceError, never>;
-    readonly clearReplies: (requestId: Snowflake.Snowflake) => Effect.Effect<void, PersistenceError, never>;
-    readonly repliesFor: <R extends import("effect/unstable/rpc/Rpc").Any>(requests: Iterable<import("effect/unstable/cluster/Message").OutgoingRequest<R>>) => Effect.Effect<Reply.Reply<R>[], import("effect/unstable/cluster/ClusterError").MalformedMessage | PersistenceError, never>;
-    readonly repliesForUnfiltered: (requestIds: Iterable<Snowflake.Snowflake>) => Effect.Effect<Reply.Encoded[], import("effect/unstable/cluster/ClusterError").MalformedMessage | PersistenceError, never>;
+    readonly saveRequest: <R extends import("effect/unstable/rpc/Rpc").Any>(envelope: import("effect/unstable/cluster/Message").OutgoingRequest<R>) => Effect.Effect<MessageStorage.SaveResult<R>, PersistenceError | import("effect/unstable/cluster/ClusterError").MalformedMessage>;
+    readonly saveEnvelope: (envelope: import("effect/unstable/cluster/Message").OutgoingEnvelope) => Effect.Effect<void, PersistenceError | import("effect/unstable/cluster/ClusterError").MalformedMessage>;
+    readonly saveReply: <R extends import("effect/unstable/rpc/Rpc").Any>(reply: Reply.ReplyWithContext<R>) => Effect.Effect<void, PersistenceError | import("effect/unstable/cluster/ClusterError").MalformedMessage>;
+    readonly clearReplies: (requestId: Snowflake.Snowflake) => Effect.Effect<void, PersistenceError>;
+    readonly repliesFor: <R extends import("effect/unstable/rpc/Rpc").Any>(requests: Iterable<import("effect/unstable/cluster/Message").OutgoingRequest<R>>) => Effect.Effect<Array<Reply.Reply<R>>, PersistenceError | import("effect/unstable/cluster/ClusterError").MalformedMessage>;
+    readonly repliesForUnfiltered: (requestIds: Iterable<Snowflake.Snowflake>) => Effect.Effect<Array<Reply.Encoded>, PersistenceError | import("effect/unstable/cluster/ClusterError").MalformedMessage>;
     readonly requestIdForPrimaryKey: (options: {
         readonly address: import("effect/unstable/cluster/EntityAddress").EntityAddress;
         readonly tag: string;
         readonly id: string;
-    }) => Effect.Effect<Option.Option<Snowflake.Snowflake>, PersistenceError, never>;
-    readonly registerReplyHandler: <R extends import("effect/unstable/rpc/Rpc").Any>(message: import("effect/unstable/cluster/Message").OutgoingRequest<R> | import("effect/unstable/cluster/Message").IncomingRequest<R>) => Effect.Effect<void, import("effect/unstable/cluster/ClusterError").EntityNotAssignedToRunner, never>;
-    readonly unregisterReplyHandler: (requestId: Snowflake.Snowflake) => Effect.Effect<void, never, never>;
-    readonly unregisterShardReplyHandlers: (shardId: ShardId.ShardId) => Effect.Effect<void, never, never>;
-    readonly unprocessedMessages: (shardIds: Iterable<ShardId.ShardId>) => Effect.Effect<import("effect/unstable/cluster/Message").Incoming<any>[], PersistenceError, never>;
-    readonly unprocessedMessagesById: <R extends import("effect/unstable/rpc/Rpc").Any>(messageIds: Iterable<Snowflake.Snowflake>) => Effect.Effect<import("effect/unstable/cluster/Message").Incoming<R>[], PersistenceError, never>;
-    readonly resetShards: (shardIds: Iterable<ShardId.ShardId>) => Effect.Effect<void, PersistenceError, never>;
-    readonly resetAddress: (address: import("effect/unstable/cluster/EntityAddress").EntityAddress) => Effect.Effect<void, PersistenceError, never>;
-    readonly clearAddress: (address: import("effect/unstable/cluster/EntityAddress").EntityAddress) => Effect.Effect<void, PersistenceError, never>;
+    }) => Effect.Effect<Option.Option<Snowflake.Snowflake>, PersistenceError>;
+    readonly registerReplyHandler: <R extends import("effect/unstable/rpc/Rpc").Any>(message: import("effect/unstable/cluster/Message").OutgoingRequest<R> | import("effect/unstable/cluster/Message").IncomingRequest<R>) => Effect.Effect<void, import("effect/unstable/cluster/ClusterError").EntityNotAssignedToRunner>;
+    readonly unregisterReplyHandler: (requestId: Snowflake.Snowflake) => Effect.Effect<void>;
+    readonly unregisterShardReplyHandlers: (shardId: ShardId.ShardId) => Effect.Effect<void>;
+    readonly unprocessedMessages: (shardIds: Iterable<ShardId.ShardId>) => Effect.Effect<Array<import("effect/unstable/cluster/Message").Incoming<any>>, PersistenceError>;
+    readonly unprocessedMessagesById: <R extends import("effect/unstable/rpc/Rpc").Any>(messageIds: Iterable<Snowflake.Snowflake>) => Effect.Effect<Array<import("effect/unstable/cluster/Message").Incoming<R>>, PersistenceError>;
+    readonly resetShards: (shardIds: Iterable<ShardId.ShardId>) => Effect.Effect<void, PersistenceError>;
+    readonly resetAddress: (address: import("effect/unstable/cluster/EntityAddress").EntityAddress) => Effect.Effect<void, PersistenceError>;
+    readonly clearAddress: (address: import("effect/unstable/cluster/EntityAddress").EntityAddress) => Effect.Effect<void, PersistenceError>;
     readonly withTransaction: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 }, never, CosmosClient | Snowflake.Generator>;
 export declare const makeRunnerStorage: (options?: {

package/dist/MainFiberSet.d.ts

@@ -2,6 +2,7 @@ import * as Context from "effect-app/Context";
 import * as Effect from "effect-app/Effect";
 import * as Layer from "effect-app/Layer";
 import * as Fiber from "effect/Fiber";
+export declare const setRootParentSpan: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 declare const MainFiberSet_base: Context.ServiceClass<MainFiberSet, "MainFiberSet", {
     interrupt: Effect.Effect<void, never, never>;
     join: Effect.Effect<void, never, never>;

package/dist/MainFiberSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MainFiberSet.d.ts","sourceRoot":"","sources":["../src/MainFiberSet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA;AAC7C,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAC3C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAA;AACzC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;;;;uBAwCT,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;;qBA/BvC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;qBACpB,SAAS,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;;;;;;;;;;;AAiDvD;;;;GAIG;AACH,qBAAa,YAAa,SAAQ,iBAAyD;IACzF,MAAM,CAAC,QAAQ,CAAC,IAAI,0CAAgC;IACpD,MAAM,CAAC,QAAQ,CAAC,QAAQ,mCAIvB;IACD,MAAM,CAAC,QAAQ,CAAC,GAAG,GAAI,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,mEAAkD;IAC/G,MAAM,CAAC,QAAQ,CAAC,gBAAgB,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,sEACb;CAC7D"}
+{"version":3,"file":"MainFiberSet.d.ts","sourceRoot":"","sources":["../src/MainFiberSet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA;AAC7C,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAC3C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAA;AAEzC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAoBrC,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,2BAC4B,CAAA;;;;uBAmCvE,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;;qBA/BvC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;qBACpB,SAAS,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;;;;;;;;;;;AAiDvD;;;;GAIG;AACH,qBAAa,YAAa,SAAQ,iBAAyD;IACzF,MAAM,CAAC,QAAQ,CAAC,IAAI,0CAAgC;IACpD,MAAM,CAAC,QAAQ,CAAC,QAAQ,mCAIvB;IACD,MAAM,CAAC,QAAQ,CAAC,GAAG,GAAI,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,mEAAkD;IAC/G,MAAM,CAAC,QAAQ,CAAC,gBAAgB,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,sEACb;CAC7D"}

package/dist/MainFiberSet.js

@@ -1,11 +1,23 @@
 import * as Context from "effect-app/Context";
 import * as Effect from "effect-app/Effect";
 import * as Layer from "effect-app/Layer";
+import * as Option from "effect-app/Option";
 import * as Fiber from "effect/Fiber";
 import * as FiberSet from "effect/FiberSet";
 import { InfraLogger } from "./logger.js";
 import { reportNonInterruptedFailureCause } from "./QueueMaker/errors.js";
-import { setRootParentSpan } from "./RequestFiberSet.js";
+// Walk to the root span so a daemon fiber's spans aren't parented to a span that
+// may already be closing (e.g. the originating request).
+const getRootParentSpan = Effect.gen(function* () {
+    let span = yield* Effect.currentSpan.pipe(Effect.catchTag("NoSuchElementError", () => Effect.succeed(null)));
+    if (!span)
+        return span;
+    while (span._tag === "Span" && Option.isSome(span.parent)) {
+        span = span.parent.value;
+    }
+    return span;
+});
+export const setRootParentSpan = (self) => getRootParentSpan.pipe(Effect.andThen((span) => span ? Effect.withParentSpan(self, span) : self));
 const make = Effect.gen(function* () {
     const set = yield* FiberSet.make();
     const add = (...fibers) => Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)));
@@ -55,4 +67,4 @@ export class MainFiberSet extends Context.Service()("MainFiberSet", { make }) {
     static run = (self) => this.pipe(Effect.andThen((_) => _.run(self)));
     static forkDaemonReport = (self) => this.pipe(Effect.andThen((_) => _.forkDaemonReport(self)));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/logger.d.ts

@@ -1,9 +1,9 @@
 export declare const InfraLogger: {
-    logWarning: (...message: ReadonlyArray<any>) => import("effect/Effect").Effect<void, never, never>;
-    logError: (...message: ReadonlyArray<any>) => import("effect/Effect").Effect<void, never, never>;
-    logFatal: (...message: ReadonlyArray<any>) => import("effect/Effect").Effect<void, never, never>;
+    logWarning: (...message: readonly any[]) => import("effect/Effect").Effect<void, never, never>;
+    logError: (...message: readonly any[]) => import("effect/Effect").Effect<void, never, never>;
+    logFatal: (...message: readonly any[]) => import("effect/Effect").Effect<void, never, never>;
     logInfo: (...message: ReadonlyArray<any>) => import("effect/Effect").Effect<void, never, never>;
     logDebug: (...message: ReadonlyArray<any>) => import("effect/Effect").Effect<void, never, never>;
-    logWithLevel: (level: import("effect/LogLevel").Severity, ...message: ReadonlyArray<any>) => import("effect/Effect").Effect<void, never, never>;
+    logWithLevel: (level: import("effect/LogLevel").Severity, ...message: readonly any[]) => import("effect/Effect").Effect<void, never, never>;
 };
 //# sourceMappingURL=logger.d.ts.map

package/dist/routing/utils.js

@@ -1,5 +1,5 @@
 import * as S from "effect-app/Schema";
-import * as SchemaAST from "effect/SchemaAST";
+import * as SchemaAST from "effect-app/SchemaAST";
 const get = ["Get", "Index", "List", "All", "Find", "Search"];
 const del = ["Delete", "Remove", "Destroy"];
 const patch = ["Patch", "Update", "Edit"];
@@ -42,4 +42,4 @@ export const determineMethod = (fullName, schema) => {
     return { _tag: "command", method: "POST" };
 };
 export const isCommand = (method) => method._tag === "command";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-app/infra",
-  "version": "4.0.0-beta.281",
+  "version": "4.0.0-beta.282",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -10,12 +10,12 @@
     "proper-lockfile": "^4.1.2",
     "pure-rand": "8.4.0",
     "query-string": "^9.4.0",
-    "effect-app": "4.0.0-beta.281"
+    "effect-app": "4.0.0-beta.282"
   },
   "devDependencies": {
     "@azure/cosmos": "^4.9.3",
     "@azure/service-bus": "^7.9.5",
-    "@effect/sql-sqlite-node": "4.0.0-beta.86",
+    "@effect/sql-sqlite-node": "4.0.0-beta.88",
     "@sentry/node": "10.55.0",
     "@sentry/opentelemetry": "10.55.0",
     "@types/better-sqlite3": "^7.6.13",
@@ -34,12 +34,12 @@
   "peerDependencies": {
     "@azure/cosmos": "^4.9.3",
     "@azure/service-bus": "^7.9.5",
-    "@effect/vitest": "^4.0.0-beta.86",
+    "@effect/vitest": "^4.0.0-beta.88",
     "@sendgrid/helpers": "^8.0.0",
     "@sendgrid/mail": "^8.1.6",
     "@sentry/node": "10.55.0",
     "@sentry/opentelemetry": "10.55.0",
-    "effect": "^4.0.0-beta.86",
+    "effect": "^4.0.0-beta.88",
     "jwt-decode": "^4.0.0",
     "redis": "^3.1.2",
     "redlock": "^4.2.0"

package/src/MainFiberSet.ts

@@ -1,12 +1,29 @@
 import * as Context from "effect-app/Context"
 import * as Effect from "effect-app/Effect"
 import * as Layer from "effect-app/Layer"
+import * as Option from "effect-app/Option"
 import * as Fiber from "effect/Fiber"
 import * as FiberSet from "effect/FiberSet"
+import type * as Tracer from "effect/Tracer"
 
 import { InfraLogger } from "./logger.ts"
 import { reportNonInterruptedFailureCause } from "./QueueMaker/errors.ts"
-import { setRootParentSpan } from "./RequestFiberSet.ts"
+
+// Walk to the root span so a daemon fiber's spans aren't parented to a span that
+// may already be closing (e.g. the originating request).
+const getRootParentSpan = Effect.gen(function*() {
+  let span: Tracer.AnySpan | null = yield* Effect.currentSpan.pipe(
+    Effect.catchTag("NoSuchElementError", () => Effect.succeed(null))
+  )
+  if (!span) return span
+  while (span._tag === "Span" && Option.isSome(span.parent)) {
+    span = span.parent.value
+  }
+  return span
+})
+
+export const setRootParentSpan = <A, E, R>(self: Effect.Effect<A, E, R>) =>
+  getRootParentSpan.pipe(Effect.andThen((span) => span ? Effect.withParentSpan(self, span) : self))
 
 const make = Effect.gen(function*() {
   const set = yield* FiberSet.make<unknown, never>()

package/src/routing/utils.ts

@@ -1,6 +1,6 @@
 import * as S from "effect-app/Schema"
 import type { AST } from "effect-app/Schema"
-import * as SchemaAST from "effect/SchemaAST"
+import * as SchemaAST from "effect-app/SchemaAST"
 
 const get = ["Get", "Index", "List", "All", "Find", "Search"]
 const del = ["Delete", "Remove", "Destroy"]

package/src/QueueMaker/SQLQueue.ts

@@ -1,186 +0,0 @@
-import { reportNonInterruptedFailure } from "@effect-app/infra/QueueMaker/errors"
-import { subMinutes } from "date-fns"
-import type { NonEmptyReadonlyArray } from "effect-app/Array"
-import * as Effect from "effect-app/Effect"
-import * as Option from "effect-app/Option"
-import { type QueueBase, QueueMeta } from "effect-app/QueueMaker"
-import * as S from "effect-app/Schema"
-import { type NonEmptyString255 } from "effect-app/Schema"
-import { getRequestContext, setupRequestContextWithCustomSpan } from "effect-app/setupRequest"
-import { pretty } from "effect-app/utils"
-import * as Fiber from "effect/Fiber"
-import * as Tracer from "effect/Tracer"
-import { SqlClient } from "effect/unstable/sql"
-import { InfraLogger } from "../logger.ts"
-import { messagingSpanArgs } from "../otel.ts"
-import { SQLModel } from "../SQL.ts"
-
-export const QueueId = S.Finite.pipe(S.brand("QueueId"))
-export type QueueId = typeof QueueId.Type
-
-// TODO: let the model track and Auto Generate versionColumn on every update instead
-export const makeSQLQueue = Effect.fnUntraced(function*<
-  Evt extends { id: S.StringId; _tag: string },
-  DrainEvt extends { id: S.StringId; _tag: string },
-  EvtE,
-  DrainEvtE
->(
-  queueName: NonEmptyString255,
-  queueDrainName: NonEmptyString255,
-  schema: S.Codec<Evt, EvtE>,
-  drainSchema: S.Codec<DrainEvt, DrainEvtE>
-) {
-  const base = {
-    id: SQLModel.Generated(QueueId),
-    meta: SQLModel.JsonFromString(QueueMeta),
-    name: S.NonEmptyString255,
-    createdAt: SQLModel.DateTimeInsert,
-    updatedAt: SQLModel.DateTimeUpdate,
-    // TODO: at+owner
-    processingAt: SQLModel.FieldOption(S.Date),
-    finishedAt: SQLModel.FieldOption(S.Date),
-    etag: S.String // TODO: use a SQLModel thing that auto updates it?
-    // TODO: record locking.. / optimistic locking
-    // rowVersion: SQLModel.DateTimeFromNumberWithNow
-  }
-  class Queue extends SQLModel.Class<Queue>("Queue")({
-    body: SQLModel.JsonFromString(schema),
-    ...base
-  }) {}
-  class Drain extends SQLModel.Class<Drain>("Drain")({
-    body: SQLModel.JsonFromString(drainSchema),
-    ...base
-  }) {}
-  const sql = yield* SqlClient.SqlClient
-
-  const queueRepo = yield* SQLModel.makeRepository(Queue, {
-    tableName: "queue",
-    spanPrefix: "QueueRepo",
-    idColumn: "id",
-    versionColumn: "etag"
-  })
-
-  const drainRepo = yield* SQLModel.makeRepository(Drain, {
-    tableName: "queue",
-    spanPrefix: "DrainRepo",
-    idColumn: "id",
-    versionColumn: "etag"
-  })
-
-  const decodeDrain = S.decodeEffectConcurrently(Drain)
-
-  const drain = Effect.gen(function*() {
-    const limit = subMinutes(new Date(), 15)
-    return yield* sql<typeof Drain.Encoded>`SELECT *
-    FROM queue
-    WHERE name = ${queueDrainName} AND finishedAt IS NULL AND (processingAt IS NULL OR processingAt < ${limit.getTime()})
-    LIMIT 1`
-  })
-
-  const q = {
-    offer: Effect.fnUntraced(function*(body: Evt, meta: typeof QueueMeta.Type) {
-      yield* queueRepo.insertVoid(Queue.insert.make({
-        body,
-        meta,
-        name: queueName,
-        processingAt: Option.none(),
-        finishedAt: Option.none(),
-        etag: crypto.randomUUID()
-      }))
-    }),
-    take: Effect.gen(function*() {
-      while (true) {
-        const [first] = yield* drain.pipe(Effect.withTracerEnabled(false)) // disable sql tracer otherwise we spam it..
-        if (first) {
-          const dec = yield* decodeDrain(first)
-          const { createdAt, updatedAt, ...rest } = dec
-          return yield* drainRepo.update(
-            Drain.update.make({ ...rest, processingAt: Option.some(new Date()) }) // auto in lib , etag: crypto.randomUUID()
-          )
-        }
-        if (first) return first
-        yield* Effect.sleep(250)
-      }
-    }),
-    finish: Effect.fn(function*({ createdAt, updatedAt, ...q }: Drain) {
-      return yield* drainRepo.updateVoid(Drain.update.make({ ...q, finishedAt: Option.some(new Date()) })) // auto in lib , etag: crypto.randomUUID()
-    })
-  }
-  const queue = {
-    publish: Effect.fn(`publish ${queueName}`, {
-      kind: "producer",
-      attributes: {
-        "messaging.system": "sql",
-        "messaging.operation.name": "publish",
-        "messaging.destination.name": queueName
-      }
-    })(function*(
-      ...messages: NonEmptyReadonlyArray<Evt>
-    ) {
-      yield* Effect.annotateCurrentSpan({
-        "messaging.batch.message_count": messages.length,
-        "messaging.message.types": messages.map((_) => _._tag)
-      })
-      const requestContext = yield* getRequestContext
-      yield* Effect.forEach(messages, (m) => q.offer(m, requestContext), { discard: true })
-    }),
-    drain: <DrainE, DrainR>(
-      handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-      sessionId?: string
-    ) => {
-      const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
-      const processMessage = Effect.fnUntraced(function*({ body, meta }: Drain) {
-        let effect = InfraLogger
-          .logDebug(`[${queueDrainName}] Processing incoming message`)
-          .pipe(
-            Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
-            Effect.andThen(handleEvent(body)),
-            silenceAndReportError,
-            (_) => {
-              const args = messagingSpanArgs({
-                operation: "process",
-                system: "sql",
-                destination: queueDrainName,
-                messageId: body.id,
-                conversationId: sessionId,
-                extra: { "messaging.message.type": body._tag, "messaging.message.body": body }
-              }, "consumer")
-              return setupRequestContextWithCustomSpan(
-                _,
-                meta,
-                args.name,
-                {
-                  captureStackTrace: false,
-                  kind: args.kind,
-                  attributes: args.attributes
-                }
-              )
-            }
-          )
-        if (meta.span) {
-          effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
-        }
-        return yield* effect
-      })
-
-      return Effect.fn(`receive ${queueDrainName}`, {
-        kind: "consumer",
-        attributes: {
-          "messaging.system": "sql",
-          "messaging.operation.name": "receive",
-          "messaging.destination.name": queueDrainName,
-          ...(sessionId !== undefined && { "messaging.message.conversation_id": sessionId })
-        }
-      })(function*() {
-        const x = yield* q.take
-        yield* processMessage(x).pipe(
-          Effect.uninterruptible,
-          Effect.forkChild,
-          Effect.flatMap(Fiber.join),
-          Effect.tap(q.finish(x))
-        )
-      }, (effect) => effect.pipe(silenceAndReportError, Effect.forever))()
-    }
-  }
-  return queue as QueueBase<Evt, DrainEvt>
-})

package/src/QueueMaker/memQueue.ts

@@ -1,136 +0,0 @@
-import type { NonEmptyReadonlyArray } from "effect-app/Array"
-import * as Effect from "effect-app/Effect"
-import { QueueMeta } from "effect-app/QueueMaker"
-import * as S from "effect-app/Schema"
-import { getRequestContext, setupRequestContextWithCustomSpan } from "effect-app/setupRequest"
-import { pretty } from "effect-app/utils"
-import * as Cause from "effect/Cause"
-import * as Fiber from "effect/Fiber"
-import { flow } from "effect/Function"
-import * as Q from "effect/Queue"
-import * as Tracer from "effect/Tracer"
-import { InfraLogger } from "../logger.ts"
-import { MemQueue } from "../memQueue.ts"
-import { messagingSpanArgs } from "../otel.ts"
-import { reportNonInterruptedFailure, reportNonInterruptedFailureCause } from "./errors.ts"
-
-export const makeMemQueue = Effect.fnUntraced(function*<
-  Evt extends { id: S.StringId; _tag: string },
-  DrainEvt extends { id: S.StringId; _tag: string },
-  EvtE,
-  DrainEvtE
->(
-  queueName: string,
-  queueDrainName: string,
-  schema: S.Codec<Evt, EvtE>,
-  drainSchema: S.Codec<DrainEvt, DrainEvtE>
-) {
-  const mem = yield* MemQueue
-  const q = yield* mem.getOrCreateQueue(queueName)
-  const qDrain = yield* mem.getOrCreateQueue(queueDrainName)
-
-  const wireSchema = S.Struct({ body: schema, meta: QueueMeta })
-  const wireSchemaJson = S.fromJsonString(S.toCodecJson(wireSchema))
-  const encodePublish = S.encodeEffect(wireSchemaJson)
-  const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-  const drainWJson = S.fromJsonString(S.toCodecJson(drainW))
-
-  const parseDrain = flow(S.decodeUnknownEffectConcurrently(drainWJson), Effect.orDie)
-
-  const queue = {
-    publish: Effect.fn(`publish ${queueName}`, {
-      kind: "producer",
-      attributes: {
-        "messaging.system": "memory",
-        "messaging.operation.name": "publish",
-        "messaging.destination.name": queueName
-      }
-    })(function*(
-      ...messages: NonEmptyReadonlyArray<Evt>
-    ) {
-      yield* Effect.annotateCurrentSpan({
-        "messaging.batch.message_count": messages.length,
-        "messaging.message.types": messages.map((_) => _._tag)
-      })
-      const requestContext = yield* getRequestContext
-      // we JSON encode, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-      yield* Effect.forEach(
-        messages,
-        (m) =>
-          encodePublish({ body: m, meta: requestContext }).pipe(
-            Effect.orDie,
-            Effect.flatMap((_) => Q.offer(q, _))
-          ),
-        { discard: true }
-      )
-    }),
-    drain: <DrainE, DrainR>(
-      handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-      sessionId?: string
-    ) => {
-      const silenceAndReportError = reportNonInterruptedFailure({ name: "MemQueue.drain." + queueDrainName })
-      const reportError = reportNonInterruptedFailureCause({ name: "MemQueue.drain." + queueDrainName })
-      const processMessage = Effect.fnUntraced(function*(msg: string) {
-        // we JSON parse, because that is what the wire also does, and it reveals holes in e.g unknown encoders (Date->String)
-        const { body, meta } = yield* parseDrain(msg).pipe(Effect.orDie)
-        let effect = InfraLogger
-          .logDebug(`[${queueDrainName}] Processing incoming message`)
-          .pipe(
-            Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
-            Effect.andThen(handleEvent(body)),
-            silenceAndReportError,
-            (_) => {
-              const args = messagingSpanArgs({
-                operation: "process",
-                system: "memory",
-                destination: queueDrainName,
-                messageId: body.id,
-                conversationId: sessionId,
-                extra: { "messaging.message.type": body._tag, "messaging.message.body": body }
-              }, "consumer")
-              return setupRequestContextWithCustomSpan(
-                _,
-                meta,
-                args.name,
-                {
-                  captureStackTrace: false,
-                  kind: args.kind,
-                  attributes: args.attributes
-                }
-              )
-            }
-          )
-        if (meta.span) {
-          effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
-        }
-        return yield* effect
-      })
-      return Effect.fn(`receive ${queueDrainName}`, {
-        kind: "consumer",
-        attributes: {
-          "messaging.system": "memory",
-          "messaging.operation.name": "receive",
-          "messaging.destination.name": queueDrainName,
-          ...(sessionId !== undefined && { "messaging.message.conversation_id": sessionId })
-        }
-      })(function*() {
-        const x = yield* Q.take(qDrain)
-        const exit = yield* processMessage(x).pipe(
-          Effect.uninterruptible,
-          Effect.forkChild,
-          Effect.flatMap(Fiber.join)
-        )
-        if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
-          // normally a failed item would be returned to the queue and retried up to X times.
-          yield* Q.offer(qDrain, x).pipe(
-            // TODO: retry count tracking and max retries.
-            Effect.delay("5 seconds"),
-            Effect.tapCause(reportError),
-            Effect.forkDetach
-          )
-        }
-      }, (effect) => effect.pipe(silenceAndReportError, Effect.forever))()
-    }
-  }
-  return queue
-})

package/src/QueueMaker/sbqueue.ts

@@ -1,125 +0,0 @@
-import type { NonEmptyReadonlyArray } from "effect-app/Array"
-import * as Effect from "effect-app/Effect"
-import { QueueMeta } from "effect-app/QueueMaker"
-import * as S from "effect-app/Schema"
-import type { StringId } from "effect-app/Schema"
-import { getRequestContext, setupRequestContextWithCustomSpan } from "effect-app/setupRequest"
-import { pretty } from "effect-app/utils"
-import * as Cause from "effect/Cause"
-import { flow } from "effect/Function"
-import * as Tracer from "effect/Tracer"
-import { InfraLogger } from "../logger.ts"
-import { messagingSpanArgs } from "../otel.ts"
-import { Receiver, Sender } from "../ServiceBus.ts"
-import { reportNonInterruptedFailure, reportNonInterruptedFailureCause, reportQueueError } from "./errors.ts"
-
-export function makeServiceBusQueue<
-  Evt extends { id: StringId; _tag: string },
-  DrainEvt extends { id: StringId; _tag: string },
-  EvtE,
-  DrainEvtE
->(
-  schema: S.Codec<Evt, EvtE>,
-  drainSchema: S.Codec<DrainEvt, DrainEvtE>
-) {
-  const wireSchema = S.Struct({
-    body: schema,
-    meta: QueueMeta
-  })
-  const wireSchemaJson = S.fromJsonString(S.toCodecJson(wireSchema))
-  const encodePublish = S.encodeEffect(wireSchemaJson)
-  const drainW = S.Struct({ body: drainSchema, meta: QueueMeta })
-  const drainWJson = S.fromJsonString(S.toCodecJson(drainW))
-  const parseDrain = flow(S.decodeUnknownEffectConcurrently(drainWJson), Effect.orDie)
-
-  return Effect.gen(function*() {
-    const sender = yield* Sender
-    const receiver = yield* Receiver
-    const silenceAndReportError = reportNonInterruptedFailure({ name: receiver.name })
-    const reportError = reportNonInterruptedFailureCause({ name: receiver.name })
-
-    // TODO: or do async?
-    // This will make sure that the host receives the error (MainFiberSet.join), who will then interrupt everything and commence a shutdown and restart of app
-    // const deferred = yield* Deferred.make<never, ServiceBusError | Error>()
-
-    const queue = {
-      drain: <DrainE, DrainR>(
-        handleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-        sessionId?: string
-      ) => {
-        const processMessage = Effect.fnUntraced(function*(messageBody: unknown) {
-          const { body, meta } = yield* parseDrain(messageBody).pipe(Effect.orDie)
-          let effect = InfraLogger
-            .logDebug(`[${receiver.name}] Processing incoming message`)
-            .pipe(
-              Effect.annotateLogs({ body: pretty(body), meta: pretty(meta) }),
-              Effect.andThen(handleEvent(body)),
-              Effect.orDie,
-              // we silenceAndReportError here, so that the error is reported, and moves into the Exit.
-              silenceAndReportError,
-              (_) => {
-                const args = messagingSpanArgs({
-                  operation: "process",
-                  system: "servicebus",
-                  destination: receiver.name,
-                  messageId: body.id,
-                  conversationId: sessionId,
-                  extra: { "messaging.message.type": body._tag, "messaging.message.body": body }
-                }, "consumer")
-                return setupRequestContextWithCustomSpan(
-                  _,
-                  meta,
-                  args.name,
-                  {
-                    captureStackTrace: false,
-                    kind: args.kind,
-                    attributes: args.attributes
-                  }
-                )
-              }
-            )
-          if (meta.span) {
-            effect = Effect.withParentSpan(effect, Tracer.externalSpan(meta.span))
-          }
-          // we reportError here, so that we report the error only, and keep flowing
-          const exit = yield* Effect.tapCause(effect, reportError)
-          return yield* exit
-        })
-
-        return receiver
-          .subscribe({
-            processMessage: (x) => processMessage(x.body).pipe(Effect.uninterruptible),
-            processError: (err) => reportQueueError(Cause.fail(err.error))
-          }, sessionId)
-          .pipe(Effect.andThen(Effect.never))
-      },
-
-      publish: Effect.fn(`publish ${sender.name}`, {
-        kind: "producer",
-        attributes: {
-          "messaging.system": "servicebus",
-          "messaging.operation.name": "publish",
-          "messaging.destination.name": sender.name
-        }
-      })(function*(...messages: NonEmptyReadonlyArray<Evt>) {
-        yield* Effect.annotateCurrentSpan({
-          "messaging.batch.message_count": messages.length,
-          "messaging.message.types": messages.map((_) => _._tag)
-        })
-        const requestContext = yield* getRequestContext
-        const msgs = yield* Effect.forEach(messages, (m) =>
-          encodePublish({ body: m, meta: requestContext }).pipe(
-            Effect.orDie,
-            Effect.map((body) => ({
-              body,
-              messageId: m.id, /* correllationid: requestId */
-              contentType: "application/json",
-              sessionId: "sessionId" in m ? m.sessionId as string : undefined as unknown as string // TODO: optional
-            }))
-          ))
-        yield* sender.sendMessages(msgs)
-      })
-    }
-    return queue
-  })
-}

package/src/RequestFiberSet.ts

@@ -1,110 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import * as Context from "effect-app/Context"
-import * as Effect from "effect-app/Effect"
-import * as Layer from "effect-app/Layer"
-import * as Option from "effect-app/Option"
-import * as Fiber from "effect/Fiber"
-import * as FiberSet from "effect/FiberSet"
-import type * as Tracer from "effect/Tracer"
-import { InfraLogger } from "./logger.ts"
-import { reportRequestError, reportUnknownRequestError } from "./reportError.ts"
-
-const getRootParentSpan = Effect.gen(function*() {
-  let span: Tracer.AnySpan | null = yield* Effect.currentSpan.pipe(
-    Effect.catchTag("NoSuchElementError", () => Effect.succeed(null))
-  )
-  if (!span) return span
-  while (span._tag === "Span" && Option.isSome(span.parent)) {
-    span = span.parent.value
-  }
-  return span
-})
-
-export const setRootParentSpan = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-  getRootParentSpan.pipe(Effect.andThen((span) => span ? Effect.withParentSpan(self, span) : self))
-
-const make = Effect.gen(function*() {
-  const set = yield* FiberSet.make<any, any>()
-  const add = (...fibers: Fiber.Fiber<any, any>[]) =>
-    Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)))
-  const addAll = (fibers: readonly Fiber.Fiber<any, any>[]) =>
-    Effect.sync(() => fibers.forEach((_) => FiberSet.addUnsafe(set, _)))
-  const join = FiberSet.size(set).pipe(
-    Effect.andThen((count) => InfraLogger.logInfo(`Joining ${count} current fibers on the RequestFiberSet`)),
-    Effect.andThen(FiberSet.join(set))
-  )
-  const run = FiberSet.run(set)
-  const register = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    self.pipe(Effect.forkChild, Effect.tap(add), Effect.andThen(Fiber.join))
-
-  // const waitUntilEmpty = Effect.gen(function*() {
-  //   const currentSize = yield* FiberSet.size(set)
-  //   if (currentSize === 0) {
-  //     return
-  //   }
-  //   yield* Effect.logInfo("Waiting RequestFiberSet to be empty: " + currentSize)
-  //   while ((yield* FiberSet.size(set)) > 0) yield* Effect.sleep("250 millis")
-  //   yield* Effect.logDebug("RequestFiberSet is empty")
-  // })
-  // TODO: loop and interrupt all fibers in the set continuously?
-  const interrupt = Fiber.interruptAll(set)
-
-  /**
-   * Forks the effect into a new fiber attached to the RequestFiberSet scope. Because the
-   * new fiber isn't attached to the parent, when the fiber executing the
-   * returned effect terminates, the forked fiber will continue running.
-   * The fiber will be interrupted when the RequestFiberSet scope is closed.
-   *
-   * Reports errors.
-   */
-  function forkDaemonReport<R, E, A>(self: Effect.Effect<A, E, R>) {
-    return self.pipe(
-      reportRequestError,
-      Effect.uninterruptible,
-      run
-    )
-  }
-
-  /**
-   * Forks the effect into a new fiber attached to the RequestFiberSet scope. Because the
-   * new fiber isn't attached to the parent, when the fiber executing the
-   * returned effect terminates, the forked fiber will continue running.
-   * The fiber will be interrupted when the RequestFiberSet scope is closed.
-   *
-   * Reports unexpected errors.
-   */
-  function forkDaemonReportUnexpected<R, E, A>(self: Effect.Effect<A, E, R>) {
-    return self
-      .pipe(
-        reportUnknownRequestError,
-        Effect.uninterruptible,
-        run
-      )
-  }
-
-  return {
-    interrupt,
-    join,
-    run,
-    add,
-    addAll,
-    register,
-    forkDaemonReport,
-    forkDaemonReportUnexpected
-  }
-})
-
-/**
- * Whenever you fork a fiber for a Request, and you want to prevent dependent services to close prematurely on interruption,
- * like the ServiceBus Sender, you should register these fibers in this FiberSet.
- */
-export class RequestFiberSet extends Context.Service<RequestFiberSet>()("RequestFiberSet", { make }) {
-  static readonly Live = Layer.effect(this, this.make)
-  static readonly register = <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    this.pipe(Effect.andThen((_) => _.register(self)))
-  static readonly run = <A, E, R>(self: Effect.Effect<A, E, R>) => this.pipe(Effect.andThen((_) => _.run(self)))
-  static readonly forkDaemonReport = <R, E, A>(self: Effect.Effect<A, E, R>) =>
-    this.pipe(Effect.andThen((_) => _.forkDaemonReport(self)))
-  static readonly forkDaemonReportUnexpected = <R, E, A>(self: Effect.Effect<A, E, R>) =>
-    this.pipe(Effect.andThen((_) => _.forkDaemonReportUnexpected(self)))
-}

package/src/ServiceBus.ts

@@ -1,219 +0,0 @@
-/* eslint-disable @typescript-eslint/prefer-promise-reject-errors */
-import { type OperationOptionsBase, type ProcessErrorArgs, ServiceBusClient, type ServiceBusMessage, type ServiceBusMessageBatch, type ServiceBusReceivedMessage, type ServiceBusReceiver } from "@azure/service-bus"
-import * as Context from "effect-app/Context"
-import * as Effect from "effect-app/Effect"
-import * as Layer from "effect-app/Layer"
-import * as Cause from "effect/Cause"
-import * as Exit from "effect/Exit"
-import * as FiberSet from "effect/FiberSet"
-import type * as Scope from "effect/Scope"
-import { InfraLogger } from "./logger.ts"
-
-const logged = (name: string) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
-  Effect.logInfo(name).pipe(
-    Effect.andThen(self),
-    Effect.tap(Effect.logInfo(name + " done")),
-    Effect.withLogSpan(name)
-  )
-
-function makeClient(url: string) {
-  return Effect.acquireRelease(
-    Effect.sync(() => new ServiceBusClient(url)).pipe(logged("ServiceBus.client.create")),
-    (client) => Effect.promise(() => client.close()).pipe(logged("ServiceBus.client.close"))
-  )
-}
-
-export class ServiceBusClientTag
-  extends Context.Opaque<ServiceBusClientTag, ServiceBusClient>()("@services/Client", { make: makeClient })
-{
-  static readonly layer = (url: string) => this.toLayer(this.make(url))
-}
-
-const makeSender_ = Effect.fnUntraced(function*(queueName: string) {
-  const serviceBusClient = yield* ServiceBusClientTag
-
-  return yield* Effect.acquireRelease(
-    Effect.sync(() => serviceBusClient.createSender(queueName)).pipe(
-      logged(`ServiceBus.sender.create ${queueName}`)
-    ),
-    (sender) => Effect.promise(() => sender.close()).pipe(logged(`ServiceBus.sender.close ${queueName}`))
-  )
-})
-
-const makeSender = Effect.fnUntraced(function*(name: string) {
-  const sender = yield* makeSender_(name)
-  const sendMessages = Effect.fnUntraced(function*(
-    messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
-    options?: Omit<OperationOptionsBase, "abortSignal">
-  ) {
-    return yield* Effect.promise((abortSignal) => sender.sendMessages(messages, { ...options, abortSignal }))
-  })
-
-  return { name, sendMessages }
-})
-
-export class Sender extends Context.Opaque<Sender, {
-  name: string
-  sendMessages: (
-    messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
-    options?: Omit<OperationOptionsBase, "abortSignal">
-  ) => Effect.Effect<void>
-}>()("Sender", { make: makeSender }) {
-  static readonly layer = (name: string) => this.toLayer(this.make(name))
-}
-
-export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = Context.Service<Id, Sender>(`ServiceBus.Sender.${queueName}`)
-
-  return Object.assign(tag, {
-    layer: Layer.effect(
-      tag,
-      Sender.make(queueName).pipe(Effect.map(Sender.of))
-    )
-  })
-}
-
-const makeReceiver = Effect.fnUntraced(function*(name: string) {
-  const serviceBusClient = yield* ServiceBusClientTag
-
-  const makeReceiver = Effect.fnUntraced(
-    function*(queueName: string, waitTillEmpty: Effect.Effect<void>, sessionId?: string) {
-      const annotate = sessionId !== undefined
-        ? Effect.annotateLogs({ "messaging.session.id": sessionId })
-        : <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => self
-      return yield* Effect.acquireRelease(
-        (sessionId
-          ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
-          : Effect.sync(() => serviceBusClient.createReceiver(queueName)))
-          .pipe(logged(`ServiceBus.receiver.create ${queueName}`), annotate),
-        (r) =>
-          waitTillEmpty.pipe(
-            logged(`ServiceBus.receiver.waitTillEmpty ${queueName}`),
-            Effect.andThen(
-              Effect.promise(() => r.close()).pipe(
-                logged(`ServiceBus.receiver.close ${queueName}`)
-              )
-            ),
-            logged(`ServiceBus.receiver.release ${queueName}`),
-            annotate
-          )
-      )
-    }
-  )
-
-  const make = (waitTillEmpty: Effect.Effect<void>) => makeReceiver(name, waitTillEmpty)
-
-  const makeSession = (sessionId: string, waitTillEmpty: Effect.Effect<void>) =>
-    makeReceiver(name, waitTillEmpty, sessionId)
-
-  return {
-    name,
-    make,
-    makeSession,
-    subscribe: Effect.fnUntraced(function*<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string) {
-      const fs = yield* FiberSet.make()
-      const fr = yield* FiberSet.runtime(fs)<RMsg | RErr>()
-      const wait = Effect
-        .gen(function*() {
-          if ((yield* FiberSet.size(fs)) > 0) {
-            yield* InfraLogger.logDebug("Waiting ServiceBusFiberSet to be empty: " + (yield* FiberSet.size(fs)))
-          }
-          while ((yield* FiberSet.size(fs)) > 0) yield* Effect.sleep("250 millis")
-        })
-      const r = yield* sessionId
-        ? makeSession(
-          sessionId,
-          wait
-        )
-        : make(wait)
-
-      const runEffect = <E>(effect: Effect.Effect<void, E, RMsg | RErr>) =>
-        new Promise<void>((resolve, reject) =>
-          fr(effect)
-            .addObserver((exit) => {
-              if (Exit.isSuccess(exit)) {
-                resolve(exit.value)
-              } else {
-                // disable @typescript-eslint/prefer-promise-reject-errors
-                reject(Cause.pretty(exit.cause))
-              }
-            })
-        )
-
-      const annotate = sessionId !== undefined
-        ? Effect.annotateLogs({ "messaging.session.id": sessionId })
-        : <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => self
-      yield* Effect.acquireRelease(
-        Effect
-          .sync(() => {
-            const s = r
-              .subscribe({
-                processError: (err) =>
-                  runEffect(
-                    hndlr
-                      .processError(err)
-                      .pipe(
-                        Effect.catchCause((cause) => Effect.logError("ServiceBus Error", cause)),
-                        annotate
-                      )
-                  ),
-                processMessage: (msg) => runEffect(hndlr.processMessage(msg).pipe(annotate))
-                // DO NOT CATCH ERRORS here as they should return to the queue!
-              })
-            return { close: Effect.promise(() => s.close()) }
-          })
-          .pipe(logged("ServiceBus.subscription.create"), annotate),
-        (subscription) =>
-          subscription.close.pipe(
-            logged("ServiceBus.subscription.close"),
-            annotate
-          )
-      ) as Effect.Effect<void, never, Scope.Scope> // wth is going on here
-    })
-  }
-})
-
-export class Receiver extends Context.Opaque<Receiver, {
-  name: string
-  make: (waitTillEmpty: Effect.Effect<void>) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
-  makeSession: (
-    sessionId: string,
-    waitTillEmpty: Effect.Effect<void>
-  ) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
-  subscribe<RMsg, RErr>(
-    hndlr: MessageHandlers<RMsg, RErr>,
-    sessionId?: string
-  ): Effect.Effect<void, never, Scope.Scope | RMsg | RErr>
-}>()("Receiver") {
-  static readonly make = makeReceiver
-  static readonly layer = (name: string) => this.toLayer(makeReceiver(name))
-}
-
-export const ReceiverTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = Context.Service<Id, Receiver>(`ServiceBus.Receiver.${queueName}`)
-
-  return Object.assign(tag, {
-    layer: Layer.effect(
-      tag,
-      makeReceiver(queueName).pipe(Effect.map(Receiver.of))
-    )
-  })
-}
-
-export const SenderReceiver = (queue: string, queueDrain?: string) =>
-  Layer.mergeAll(Sender.layer(queue), Receiver.layer(queueDrain ?? queue))
-
-export interface MessageHandlers<RMsg, RErr> {
-  /**
-   * Handler that processes messages from service bus.
-   *
-   * @param message - A message received from Service Bus.
-   */
-  processMessage(message: ServiceBusReceivedMessage): Effect.Effect<void, never, RMsg>
-  /**
-   * Handler that processes errors that occur during receiving.
-   * @param args - The error and additional context to indicate where
-   * the error originated.
-   */
-  processError(args: ProcessErrorArgs): Effect.Effect<void, never, RErr>
-}

package/src/memQueue.ts

@@ -1,22 +0,0 @@
-import * as Context from "effect-app/Context"
-import * as Effect from "effect-app/Effect"
-import * as Queue from "effect/Queue"
-
-const make = Effect
-  .gen(function*() {
-    const store = yield* Effect.sync(() => new Map<string, Queue.Queue<string>>())
-
-    return {
-      getOrCreateQueue: Effect.fnUntraced(function*(k: string) {
-        const q = store.get(k)
-        if (q) return q
-        const newQ = yield* Queue.unbounded<string>()
-        store.set(k, newQ)
-        return newQ
-      })
-    }
-  })
-
-export class MemQueue extends Context.Opaque<MemQueue>()("effect-app/MemQueue", { make }) {
-  static readonly Live = this.toLayer(this.make)
-}