@shivaedev/jobs 0.30.0 → 0.32.0

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # Changelog
 
+## 0.32.0 - 2026-11-03
+
+### Added
+
+- Expose `PgBossInspection` for stored jobs, deferrals, expiry, queue diagnostics and scoped PostgreSQL queue-change signals. Jobs runtimes also expose the service through `inspection()`.
+- Refresh cached queue statistics through `testing.refreshQueueStats(queue?)` before reading health.
+- Read and await jobs with null payloads through `testing.jobs({ name, schema: Schema.Null })` and `testing.untilJob`.
+- Queues accept `id: ["field", ...]` to derive deterministic UUIDs from the queue name and typed scalar payload parts. Repeated parts deduplicate while pg-boss retains the job. Enqueueing rejects conflicting IDs owned by a queue definition.
+
+### Changed
+
+- The testing controller reads through inspection and waits on committed queue changes, including work done by another client, without production testing hooks or private settlement spies.
+
+### Fixed
+
+- Apply testing expiry controls to triggered schedule runs.
+
+### Breaking
+
+- Import `SnapshotQueue` and `UnfinishedJob` from `@shivaedev/jobs/server/inspection.ts` instead of `server/testing.ts`.
+- Remove `__test__enableSpies` from client options. Replace `EngineClient.getSpy` waits with inspection `changes()`. Replace `getJobById(name, id)` with `storedJobs({ name }, { id })`, taking the first result; missing jobs return an empty array.
+- `testing.trigger(schedule)` returns the run ID, or null when pg-boss suppresses the send, instead of void. Consumers that require an `Effect<void>` should apply `Effect.asVoid` to the result.
+- Replace singleton `key: (payload) => string` callbacks with `key: ["field", ...]`, naming required string, number, boolean or null fields in the decoded payload schema. Use `key: []` for a queue-wide singleton key. To preserve application-specific normalization, put the normalized value in a payload field and name it as a part. Derived singleton key strings use typed tuples; drain existing singleton work before switching producers and workers together so old and new keys do not run concurrently.
+
+## 0.31.0 - 2026-11-03
+
+### Added
+
+- Expose `readJobFailure` to read direct or wrapped pg-boss failures as sanitized `JobFailure | null` values, failing with `PgBossPayloadError` for invalid stored output.
+- `linkedWorkerSpans(sender, spans)` in jobs testing returns recorded pg-boss worker spans linked to the sender's trace and span IDs, including retry attempts.
+- Add `unschedule`, `deleteQueue` and `refreshQueueStats` to the jobs service so applications can administer queues through their owned client. Missing queues and schedule registrations fail with `PgBossNotFoundError`; engine failures retain the operation in `PgBossError`.
+- Queues and schedules accept display labels, and queues declare subject columns whose fields come from the decoded payload schema.
+- `jobModule` derives a module's queue declarations and worker Layer from its registrations.
+
+### Fixed
+
+- Share the failure readout across job details, failed listings and dead-letter source failures, preserving native timeout messages and tags while redacting secrets and removing diagnostic fields.
+- Keep testing expiry failures in the Effect error channel as `PgBossTestingError`, with the original failure and queue retained.
+- The pg-boss schema readiness check reports missing deferral tables, cleanup indexes, functions and triggers even when the pg-boss version is current. Its pending detail names the missing artifacts.
+- Release the jobs engine client when acquisition is interrupted, including pending shared-client acquisitions. Keep the client alive until its final owning Scope closes.
+- Log a tagged shutdown error when cleanup after a failed startup also fails, while preserving the startup error for callers.
+- Preserve job module queue payload schemas and their Effect service requirements when composing queue inventories.
+
+### Breaking
+
+- Public declarations use jobs-owned types, including adapter and testing signatures. Replace pg-boss `WorkOptions`, `SendOptions`, `ScheduleOptions`, `ConstructorOptions`, `StopOptions`, `FindJobsOptions` and `JobWithMetadata` annotations with `WorkerOptions` from `@shivaedev/jobs/server/workerOptions.ts`, `EnqueueOptions` and `ScheduleOptions` from `@shivaedev/jobs/server/enqueueOptions.ts`, `ClientOptions` and `StopOptions` from `@shivaedev/jobs/server/clientOptions.ts`, `JobReadOptions` from `@shivaedev/jobs/server/client.ts`, and `Job` from `@shivaedev/jobs/server/job.ts`. `JobState` is declared in `@shivaedev/jobs/server/job.ts`; job reads explicitly allow null `startedOn` and `output` values, which callers must handle before dereferencing. Database adapters use `ClientDatabase` from `@shivaedev/jobs/server/ClientDatabase.ts`; decode their unknown row values before use.
+- Move `QueueOptions` and `QueuePolicy` imports from `@shivaedev/jobs/server/definition.ts` to `@shivaedev/jobs/server/queueOptions.ts`. The previous module no longer exports those names. Move `batchHandler` imports from `@shivaedev/jobs/server/internal/batchHandler.ts` to its engine adapter at `@shivaedev/jobs/server/adapters/batchHandler.ts`.
+- `defaultClientFactory` returns the jobs-owned `EngineClient` contract from `@shivaedev/jobs/server/engineClient.ts`. Code needing additional engine methods must own a pg-boss client in its custom factory. Constructor OpenTelemetry options support `enabled` and `propagateContext`; configure custom OpenTelemetry providers on the client inside that factory.
+- Import `defaultClientFactory` from `@shivaedev/jobs/server/adapters/defaultClientFactory.ts` instead of `@shivaedev/jobs/server/defaultClientFactory.ts`. Its signature and the public jobs types are unchanged.
+
 ## 0.30.0 - 2026-11-02
 
 ### Fixed

package/README.md

@@ -77,6 +77,21 @@ With the second argument, every `Jobs.layer({ jobs })` checks its registrations
 
 Declare names per jobs service, so producer and worker Layers share a declaration when they register the same queues. Keep worker-only schedules in their own service when producers do not register them. Import only the browser-safe declaration module from client code; `defineQueue`, `defineSchedule` and `makePgBoss` stay on the server.
 
+### Label queues and identify jobs
+
+Queue and schedule definitions accept an optional `label`. A queue's `subject` declares display columns by naming fields in its decoded payload Schema:
+
+```ts
+const SendEmail = defineQueue({
+	name: "send-email",
+	label: "Email delivery",
+	schema: Schema.Struct({ userId: Schema.NumberFromString }),
+	subject: [{ field: "userId", label: "Recipient" }],
+});
+```
+
+`subject` fields are checked against the Schema's decoded keys. Keep labels and columns beside the name and Schema in the browser-safe declaration when using the admin Jobs view, then spread that declaration into `defineQueue`. The browser-safe types `QueueDisplay` and `SubjectColumn<PayloadSchema>` come from `@shivaedev/jobs/display.ts`. Pass the declarations to the admin page and view to show their labels and subjects. Subject columns read the masked inspection payload, so native `Redacted` values and sensitive keys stay masked in failed and dead-letter lists. Dead-letter copies stay with the source queue and use its columns. Definitions without labels display their internal names.
+
 ### Once per database: install the schema
 
 For an application on the app host of `@shivaedev/server`, register `pgBossSchema` beside the migration loader. The host's `migrate` mode installs or upgrades it after committing the application ledger. Its `check` and `wait` modes include pg-boss readiness in the same check as the numbered migrations.
@@ -207,7 +222,7 @@ const Compare = defineQueue({
 });
 ```
 
-This worker runs up to five handlers at once. `worker` accepts pg-boss 12's `WorkOptions`, including `batchSize`, `localConcurrency`, `pollingIntervalSeconds`, `notifyPollingIntervalSeconds` and the burst options. Explicit options override the adapter defaults. pg-boss ignores `burstWhenBatchFull` at `batchSize: 1`; keep a batch size of at least two for immediate backlog draining. Each job is settled separately through pg-boss: success completes that job, and a typed failure, payload decoding failure or defect fails only that job with its own error. A failed job does not spend the retries of other jobs in its batch or rerun their successful handlers. Interruption stops the batch and leaves the interrupted and remaining jobs to pg-boss expiry; handlers must still tolerate repeated side effects across retries and interrupted attempts.
+This worker runs up to five handlers at once. `worker` accepts jobs' `WorkerOptions`, including `batchSize`, `localConcurrency`, `pollingIntervalSeconds`, `notifyPollingIntervalSeconds` and the burst options. Explicit options override the adapter defaults. pg-boss ignores `burstWhenBatchFull` at `batchSize: 1`; keep a batch size of at least two for immediate backlog draining. Each job is settled separately through pg-boss: success completes that job, and a typed failure, payload decoding failure or defect fails only that job with its own error. A failed job does not spend the retries of other jobs in its batch or rerun their successful handlers. Interruption stops the batch and leaves the interrupted and remaining jobs to pg-boss expiry; handlers must still tolerate repeated side effects across retries and interrupted attempts.
 
 Apps do not need to shorten the polling backstop to drain a backlog. With `notify: true` and an active LISTEN/NOTIFY listener, pg-boss wakes workers on notifications and defaults to a 30-second backstop (`notifyPollingIntervalSeconds`). Without active notifications its base poll defaults to two seconds (`pollingIntervalSeconds`). Bursting takes precedence over both intervals. After an adapter worker fails or defers a job, it reads pg-boss's stored retry time and schedules a wake for every native worker in its registration at that time, so an idle sibling can retry while another worker is busy. The wake accounts for differences between the runtime and PostgreSQL clocks. The wake, including its retry-time read, belongs to the worker Layer's scope and is canceled when that scope closes. Wake failures are logged with redacted diagnostics and do not fail the batch. Override the backstop when the application needs a different bound for other work that becomes runnable without a notification, such as delayed jobs or retries initiated outside the adapter worker.
 
@@ -245,19 +260,37 @@ const PullRequestJobs = defineQueue({
 		Schema.TaggedStruct("Reconcile", { pullRequestId: Schema.NumberFromString }),
 	]),
 	queue: { policy: "singleton" },
-	key: ({ pullRequestId }) => `pr:${pullRequestId.toFixed(0)}`,
+	key: ["pullRequestId"],
 	worker: { batchSize: 1, localConcurrency: 3 },
 });
 
 const refresh = Effect.flatMap(Jobs, (jobs) => jobs.enqueue(PullRequestJobs, { _tag: "Refresh", pullRequestId: 42 }));
 ```
 
-`queue.policy` accepts pg-boss's policy literals and rejects typos. The `singleton` policy requires `key: (payload) => string`. The callback sees the decoded payload, so `pullRequestId` is a number. `enqueue` supplies pg-boss's `singletonKey` automatically; callers cannot supply a conflicting key in send options.
+`queue.policy` accepts pg-boss's policy literals and rejects typos. The `singleton` policy requires `key: ["field", ...]`. Each part names a required scalar field in the decoded payload schema, so `pullRequestId` contributes its numeric value. `enqueue` supplies pg-boss's `singletonKey` automatically; callers cannot supply a conflicting key in send options.
 
 PostgreSQL guarantees one active job per key across workers, including different job kinds in this queue. Different keys can run in parallel when workers have capacity. A job waiting to retry frees its key for another job; exhausting retries sends it to the dead-letter queue and leaves the key available.
 
 Singleton guarantees one active job per key, not order. Ordering stays the application's job. Keep handlers idempotent and write state only when the source is newer than what is stored, so an older event or retry cannot overwrite newer state.
 
+### Deterministic job IDs
+
+Declare the payload fields that identify a job:
+
+```ts
+const Revisions = defineQueue({
+	name: "revisions",
+	schema: Schema.Struct({ tenant: Schema.String, revision: Schema.NumberFromString, note: Schema.String }),
+	id: ["tenant", "revision"],
+	key: ["tenant"],
+	queue: { policy: "singleton" },
+});
+```
+
+`id` derives a deterministic UUID from the queue name and its ordered payload parts. Enqueuing the same parts again returns `None` while pg-boss retains that job, even if other fields change. Different queue names have separate identities. Here, different revisions create separate jobs while sharing the tenant's singleton key. Callers cannot pass an `id` or `singletonKey` that the queue owns.
+
+Both declarations accept fields whose decoded values are strings, numbers, booleans or null. Parts preserve value types and field boundaries, including separators in strings. An empty list gives every payload the same identity within the queue. Omit `id` to keep pg-boss's generated IDs or caller-supplied IDs. Identity is separate from tracing metadata.
+
 ### Size batches against expiry
 
 pg-boss marks every job in a fetched batch active together. Each job's expiry window starts at its stored `startedOn`, including time waiting for earlier handlers. Size each queue's batch so its sequential work fits within that window; use a small batch for long-running work and keep the default for short work:
@@ -387,6 +420,24 @@ export const readJobCounts = Effect.gen(function* () {
 
 `health([{ name: "cleanup-mail" }])` reads only the supplied queues, in order, even when another runtime registered them. Omitting the argument keeps the Layer's registered names. Admin pages use this to include worker-only schedules without registering those schedules in the request runtime.
 
+### Inspect stored work
+
+`PgBossInspection` from `@shivaedev/jobs/server/inspection.ts` exposes the shared read service used by admin pages and the testing controller. Provide `PgBossInspection.layer` with your `pgBossLayer`, or obtain the same reads from a configured jobs runtime with `yield* jobs.inspection()`.
+
+`storedJobs(queue, options?)` reads native stored metadata and encoded payloads. `jobs(queue, options?)` decodes stored payloads through the supplied queue Schema and includes native state, `startAfter`, `expireInSeconds`, `startedOn` and `keepUntil`. These reads include unredacted payloads; keep them inside trusted server code. The admin-facing `getJob`, `failedJobs` and `deadLetteredJobs` reads retain their payload redaction. `deferred(queue)` reads stored RetryAt reasons and requested times, while `snapshot(queues)` lists unfinished work with future RetryAt attempts marked `deferred`. `counts`, `health`, `queue`, `schedules`, `schemaVersion` and `busy` serve queue diagnostics and controller readouts.
+
+`changes(queue?)` acquires a scoped PostgreSQL listener and returns `revision` and `waitForChange(after)`. Capture its revision before reading, then wait against that revision to avoid missing a change between the read and the wait. The signal wakes for committed job changes from any client, optionally filtered to one queue. It is a hint to read again, not a durable event log. The caller owns the listener's scope.
+
+Automatic migration and `installPgBossSchema` install the queue-change trigger. Applications using `migrate: false` run `installPgBossSchema` before using change signals. Custom clients need `getDb().listen` to subscribe.
+
+### Administer queues and schedules
+
+`unschedule(schedule)` removes the registration named by the schedule definition and its `scheduleOptions.key` (the empty key by default). Other keys for that queue stay registered. A missing registration fails with `PgBossNotFoundError`, carrying `operation: "unschedule"`, `queue` and `key`.
+
+`deleteQueue(queue)` stops local workers for that name and deletes the queue through the owned client. Other queues stay in place. A missing queue fails with `PgBossNotFoundError` with `operation: "deleteQueue"` and `queue`; a native refusal, such as deleting a dead-letter queue still in use, fails with `PgBossError`.
+
+`refreshQueueStats(queue?)` requests a native pg-boss supervisor pass for one queue, or all queues when omitted, so `health` can read refreshed counts. The pass also performs native queue maintenance and respects pg-boss's monitor intervals and backoff; it does not promise a fresh snapshot on every call. Use `counts` for an immediate live read.
+
 ### Read live counts and retry a job
 
 ```ts
@@ -408,7 +459,7 @@ export const inspectEmail = (id: string) =>
 
 `counts(queue)` reads the job table directly on each call. `queuedCount` includes created and retry-waiting jobs, including future jobs; `activeCount` counts running jobs, `failedCount` counts retained failures, and `totalCount` includes retained terminal jobs. A queue has drained when queued and active counts are both zero. These counts are a snapshot, so a producer can enqueue more work after the query returns.
 
-`getJob(queue, id)` returns `None` when the ID is absent, or `Some` pg-boss job metadata with masked inspection `data: unknown`. The queue's Schema decodes the stored payload before the errors package's redactor masks native `Redacted` values and sensitive keys, including nested objects and arrays. Invalid stored data fails with `PgBossPayloadError`, and the Effect requires the Schema's decoding services. `retry(queue, id)` reuses the original ID: it makes a failed job eligible for another attempt and pulls a retry-waiting job forward to run now. Missing IDs and jobs in other states are left unchanged. Its dead-letter copies stay listed while the retry is pending or fails again; a successful completion removes those copies in the same database transaction.
+`getJob(queue, id)` returns `None` when the ID is absent, or `Some` jobs-owned `Job<unknown>` metadata with masked inspection `data: unknown`. The queue's Schema decodes the stored payload before the errors package's redactor masks native `Redacted` values and sensitive keys, including nested objects and arrays. Invalid stored data fails with `PgBossPayloadError`, and the Effect requires the Schema's decoding services. `retry(queue, id)` reuses the original ID: it makes a failed job eligible for another attempt and pulls a retry-waiting job forward to run now. Missing IDs and jobs in other states are left unchanged. Its dead-letter copies stay listed while the retry is pending or fails again; a successful completion removes those copies in the same database transaction.
 
 ### List failed and dead-lettered jobs
 
@@ -434,7 +485,9 @@ export const failedEmails = (cursor?: string) =>
 
 Each page holds at most `limit` jobs, newest first by creation time; a dead-letter copy is created when its original fails for good. `limit` must be a positive integer. When more jobs remain, `next` is `Some` opaque cursor; pass it back as `cursor` for the following page, and stop when `next` is `None`. Paging continues from the last job it returned, so jobs that fail while you page appear in a fresh listing instead of shifting later pages, and no job appears twice. A malformed cursor or limit fails with `SchemaError` before pg-boss is called.
 
-An entry carries the job's `id`, `queue`, native `state`, `retryCount`, `retryLimit` and `attempt`, the one-based number of its last started attempt (zero for a job that never started). `createdOn` is a UTC `DateTime`; `startedOn` and `completedOn` are `Option`s of UTC `DateTime`s. `output` is `JobFailure | null`, decoded through `JobFailure` from `@shivaedev/jobs/JobFailure.ts`. Handler failures store only `{ _tag: string, message: string }`, with the message redacted through `@shivaedev/errors`; stack traces, cause chains and other error fields are omitted. `null` means pg-boss stored no output. Native pg-boss failures without a tag decode with `_tag: "Error"`; decoding also redacts messages from older stored failures. Stored output that does not match the Schema fails the listing with `PgBossPayloadError`. `data: unknown` is decoded by the queue's JSON codec and masked through the errors package's redactor, including traced payloads; invalid stored data fails the listing with `PgBossPayloadError`, as `getJob` does, and the Effect requires the Schema's decoding services. A dead-letter entry adds `sourceQueue`, the source queue name without the dead-letter suffix, `sourceId`, the original job's ID as an `Option`, and `sourceOutput`, the original's decoded `JobFailure | null`. The copy has not run, so its own `output` stays `null` and its `attempt` is zero.
+An entry carries the job's `id`, `queue`, native `state`, `retryCount`, `retryLimit` and `attempt`, the one-based number of its last started attempt (zero for a job that never started). `createdOn` is a UTC `DateTime`; `startedOn` and `completedOn` are `Option`s of UTC `DateTime`s. `output` is `JobFailure | null`, decoded through `JobFailure` from `@shivaedev/jobs/JobFailure.ts`. Handler failures store only `{ _tag: string, message: string }`, with the message redacted through `@shivaedev/errors`; stack traces, cause chains and other error fields are omitted. `null` means pg-boss stored no output. Direct failures and native pg-boss failures wrapped in `{ value: failure }` share the same sanitized readout in details and listings. Failures without a tag decode with `_tag: "Error"`; decoding also redacts messages from older stored failures. Stored output that does not match the Schema fails the listing with `PgBossPayloadError`. `data: unknown` is decoded by the queue's JSON codec and masked through the errors package's redactor, including traced payloads; invalid stored data fails the listing with `PgBossPayloadError`, as `getJob` does, and the Effect requires the Schema's decoding services. A dead-letter entry adds `sourceQueue`, the source queue name without the dead-letter suffix, `sourceId`, the original job's ID as an `Option`, and `sourceOutput`, the original's decoded `JobFailure | null`. The copy has not run, so its own `output` stays `null` and its `attempt` is zero.
+
+`readJobFailure(queue, output)` from `@shivaedev/jobs/server/readJobFailure.ts` exposes this readout for adapters. It returns an Effect with `JobFailure | null` and fails with `PgBossPayloadError` when stored output cannot be decoded.
 
 Pass a failed entry's `id` to `retry(queue, id)` to run that job again under its original ID; once it completes it leaves the failed listing and its copies leave the dead-letter listing. Dead-letter IDs belong to the `-dlq` queue, so `retry(queue, id)` does not find them and leaves them unchanged.
 
@@ -502,7 +555,7 @@ Include every target queue in `jobs`, as either a worker or a producer-only defi
 
 `linkedWorkerSpans(sender, spans)` from `@shivaedev/jobs/server/testing.ts` reads native recorded Effect spans and returns the pg-boss consumer spans whose links match both the sender's `traceId` and `spanId`. It returns every matching attempt, including retries, and no matches before a worker runs. An untraced job has no sender link. Settle the workers before reading their completed attempts; this readout does not wait or read queue storage.
 
-`testing.ts` gives story kits a controller for one real pg-boss client. Create a fresh controller per runtime, pass its `clientFactory` to `pgBossLayer`, and keep that Layer scoped as usual. `jobs(queue, options?)` returns native job metadata with `data` decoded through the queue's Schema, including traced payloads. Invalid durable data fails with `PgBossPayloadError`; decoding services remain in the Effect's requirements.
+`testing.ts` gives story kits a controller for one real pg-boss client. Create a fresh controller per runtime, pass its `clientFactory` to `pgBossLayer`, and keep that Layer scoped as usual. `jobs(queue, options?)` returns jobs-owned `Job` metadata with `data` decoded through the queue's Schema, including traced payloads. For a scheduled run with no payload, pass `{ name: Cleanup.name, schema: Schema.Null }` to read `data: null`. Invalid durable data fails with `PgBossPayloadError`; decoding services remain in the Effect's requirements.
 
 This producer story uses the `SendEmail` definition and `Jobs` service from above. `databaseUrl` points to the story's PostgreSQL database:
 
@@ -538,13 +591,15 @@ emailStories.it("decodes the queued email", [], function* ({ enqueue, testing })
 
 Set `retryPolicy: testRetryPolicy` through the controller to override queue and send settings with `retryDelay: 0` and `retryBackoff: false`. A failing worker can then exhaust its native retries without production backoff. The policy applies to subsequently sent jobs; it does not rewrite jobs already stored.
 
-`schedules()` lists registered schedules as `{ name, cron, timezone }` entries from PostgreSQL. `trigger(schedule)` takes a schedule definition, such as `Cleanup`, and enqueues one run now using its stored schedule data and options. Register `Cleanup.run(effect)` in the testing Layer first, then yield `testing.trigger(Cleanup)` and `testing.waitForIdle` before observing the Effect's result. An unregistered schedule fails with `PgBossTestingError` (`operation: "trigger"`).
+`schedules()` lists registered schedules as `{ name, cron, timezone }` entries from PostgreSQL. `trigger(schedule)` takes a schedule definition, such as `Cleanup`, and enqueues one run now using its stored schedule data and options. It returns the run ID, or null when pg-boss suppresses the send. Register `Cleanup.run(effect)` in the testing Layer first, then yield `testing.trigger(Cleanup)` and `testing.waitForIdle` before observing the Effect's result. An unregistered schedule fails with `PgBossTestingError` (`operation: "trigger"`).
+
+`refreshQueueStats(queue?)` requests a native pg-boss supervisor pass for one queue, or all queues when omitted, before reading cached counts through the jobs service's `health`. Like the service method, it performs native queue maintenance and respects pg-boss monitor intervals and backoff.
 
 `failNextSend(queue)` arms one send failure for that queue. The next valid `enqueue` fails with the usual typed `PgBossError` (`operation: "enqueue"`); the following send proceeds normally.
 
 `expireAfter(queue, n)` takes a positive attempt count: configure it before enqueueing to limit subsequent jobs to `n` attempts. Each successful send keeps its own expiry rule; later changes and duplicate-ID sends do not alter pending jobs. Earlier attempts run the handler normally; on attempt `n`, the controller expires the claimed job instead of invoking its handler. PostgreSQL supervision performs the terminal failure and dead lettering. A job that succeeds earlier completes normally.
 
-`expireIn(queue, duration)` takes an Effect `Duration.Input`, such as `"1 second"`, and sets the expiry of subsequent sends, rounded up to whole seconds. Durations below one second or nonfinite durations fail with `PgBossTestingError` (`operation: "expireIn"`). Earlier sends retain their expiry, and later calls and duplicate-ID sends do not change stored jobs. It can be combined with `expireAfter`: one sets each attempt's time budget, the other limits attempts. A stuck handler is interrupted at its deadline, and the same worker can fetch its retry after pg-boss fails the attempt. The testing expiry hooks support pg-boss schema version 46.
+`expireIn(queue, duration)` takes an Effect `Duration.Input`, such as `"1 second"`, and sets the expiry of subsequent sends, rounded up to whole seconds. Durations below one second or nonfinite durations fail with `PgBossTestingError` (`operation: "expireIn"`). Earlier sends retain their expiry, and later calls and duplicate-ID sends do not change stored jobs. Both expiry controls also apply to runs sent by `trigger(schedule)`. It can be combined with `expireAfter`: one sets each attempt's time budget, the other limits attempts. A stuck handler is interrupted at its deadline, and the same worker can fetch its retry after pg-boss fails the attempt. The testing expiry hooks support pg-boss schema version 46.
 
 `runDueNow(queue)` makes future jobs in the queue's `created` or `retry` state due at the database's current time and wakes local workers. It includes delayed sends (`startAfter`), native retries and `RetryAt` deferrals. Yield `waitForIdle` afterwards before observing handler results; future jobs do not hold that wait open. It leaves active and terminal jobs and other queues unchanged.
 
@@ -558,7 +613,7 @@ Set `retryPolicy: testRetryPolicy` through the controller to override queue and
 
 A kit can also capture `revision` before reading jobs and yield `waitForChange(revision)` when its condition is unmet. The wait resumes after a local send, settlement or worker fetch, and when a local worker returns to idle as `waitForIdle` defines it, including terminal native worker timeouts. It also resumes immediately if a change occurred between the read and the wait. This signal observes the controller's client; external clients, future scheduled work and external database writes need their own wake source. Stories should retain a bounded test timeout.
 
-`untilJob(queue, id, state)` waits that way for one job: it reads the job, waits for the next change when the job is in another state, and returns the job with `data` decoded through the queue's Schema once it reaches `state`. `fetchesPass(queue, n)` completes once `n` worker fetches on the queue that began after the wait started have finished, whether or not they claimed anything, so a story can show that a job stayed untaken by fetches that could have claimed it. Each fetch also counts as a change for `waitForChange`. Both waits give up after `within` (default 20 seconds) of wall time, which a story's `TestClock` does not move, and fail with `PgBossWaitError`, whose message names what the wait expected and what it last saw:
+`untilJob(queue, id, state)` waits that way for one job: it reads the job, waits for the next change when the job is in another state, and returns the job with `data` decoded through the queue's Schema once it reaches `state`. It also accepts `{ name, schema: Schema.Null }` for a triggered schedule's run. `fetchesPass(queue, n)` completes once `n` worker fetches on the queue that began after the wait started have finished, whether or not they claimed anything, so a story can show that a job stayed untaken by fetches that could have claimed it. Each fetch also counts as a change for `waitForChange`. Both waits give up after `within` (default 20 seconds) of wall time, which a story's `TestClock` does not move, and fail with `PgBossWaitError`, whose message names what the wait expected and what it last saw:
 
 ```ts
 yield* testing.untilJob(SendEmail, id, "completed", { within: "5 seconds" });
@@ -569,24 +624,33 @@ yield* testing.untilJob(SendEmail, id, "completed", { within: "5 seconds" });
 
 Import the module that defines the name; the package has no root entry.
 
-| Module                                           | Public names                                                                                                                                                                                                                                                                     |
-| ------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `@shivaedev/jobs/server/definition.ts`           | `defineQueue`, `jobContext`, `RetryAt`; `DefineQueueOptions`, `DefineScheduleOptions`, `JobContext`, `JobPayloadSchema`, `JobRegistration`, `QueueDefinition`, `QueueOptions`, `QueuePolicy`, `QueueWorker`, `RegistrationRequirements`, `ScheduleDefinition`, `ScheduledWorker` |
-| `@shivaedev/jobs/server/service.ts`              | `makePgBoss`, `pgBossLayer`; `PgBossDefinition`, `PgBossLayerOptions`, `PgBossOptions`, `PgBossService`                                                                                                                                                                          |
-| `@shivaedev/jobs/server/PgBoss.ts`               | `PgBoss`: the shared client Context service.                                                                                                                                                                                                                                     |
-| `@shivaedev/jobs/server/schema.ts`               | `installPgBossSchema`, `pgBossSchema`; `PgBossSchemaOptions`                                                                                                                                                                                                                     |
-| `@shivaedev/jobs/server/health.ts`               | `deadLetterQueueName`; `DeadLetteredJob`, `JobPage`, `JobPageOptions`, `JobsHealth`, `ListedJob`, `QueueCounts`, `QueueHealth`                                                                                                                                                   |
-| `@shivaedev/jobs/server/error.ts`                | `PgBossError`, `PgBossPayloadError`, `PgBossQueueNamesError`, `PgBossQueueOptionsError`, `PgBossClientOptionsError`, `PgBossTestingError`, `PgBossWaitError`, `toPgBossError`; `PgBossOperation`                                                                                 |
-| `@shivaedev/jobs/server/client.ts`               | `PgBossClient`, `PgBossClientFactory`                                                                                                                                                                                                                                            |
-| `@shivaedev/jobs/server/testing.ts`              | `makePgBossTesting`, `testRetryPolicy`; `PgBossTesting`, `PgBossTestingOptions`, `PgBossTestingWaitOptions`, `SnapshotQueue`, `UnfinishedJob`                                                                                                                                    |
-| `@shivaedev/jobs/server/defineSchedule.ts`       | `defineSchedule`                                                                                                                                                                                                                                                                 |
-| `@shivaedev/jobs/server/defaultClientFactory.ts` | `defaultClientFactory`                                                                                                                                                                                                                                                           |
-
-The definition options keep the pg-boss names: `queue` uses `QueueOptions` (`Queue` except `name` and `deadLetter`, with literal `QueuePolicy` values and `maxDeferrals`), `worker` uses `WorkOptions`, and a schedule's `schedule` uses `ScheduleOptions`. A queue also requires `name` and `schema`; a schedule requires `name` and `cron`.
+| Module                                                    | Public names                                                                                                                                                                                                                                                      |
+| --------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@shivaedev/jobs/display.ts`                              | `QueueDisplay`, `SubjectColumn`                                                                                                                                                                                                                                   |
+| `@shivaedev/jobs/server/definition.ts`                    | `defineQueue`, `jobContext`, `RetryAt`; `DefineQueueOptions`, `DefineScheduleOptions`, `JobContext`, `JobPayloadSchema`, `JobRegistration`, `PayloadParts`, `QueueDefinition`, `QueueWorker`, `RegistrationRequirements`, `ScheduleDefinition`, `ScheduledWorker` |
+| `@shivaedev/jobs/server/service.ts`                       | `makePgBoss`, `pgBossLayer`; `PgBossDefinition`, `PgBossLayerOptions`, `PgBossOptions`, `PgBossService`                                                                                                                                                           |
+| `@shivaedev/jobs/server/PgBoss.ts`                        | `PgBoss`: the shared client Context service.                                                                                                                                                                                                                      |
+| `@shivaedev/jobs/server/schema.ts`                        | `installPgBossSchema`, `pgBossSchema`; `PgBossSchemaOptions`                                                                                                                                                                                                      |
+| `@shivaedev/jobs/server/health.ts`                        | `deadLetterQueueName`; `DeadLetteredJob`, `JobPage`, `JobPageOptions`, `JobsHealth`, `ListedJob`, `QueueCounts`, `QueueHealth`                                                                                                                                    |
+| `@shivaedev/jobs/server/error.ts`                         | `PgBossError`, `PgBossNotFoundError`, `PgBossPayloadError`, `PgBossQueueNamesError`, `PgBossQueueOptionsError`, `PgBossClientOptionsError`, `PgBossTestingError`, `PgBossWaitError`, `toPgBossError`; `PgBossOperation`                                           |
+| `@shivaedev/jobs/server/queueOptions.ts`                  | `QueueOptions`, `QueuePolicy`, `RetryOptions`                                                                                                                                                                                                                     |
+| `@shivaedev/jobs/server/workerOptions.ts`                 | `WorkerOptions`, `GroupConcurrencyConfig`                                                                                                                                                                                                                         |
+| `@shivaedev/jobs/server/enqueueOptions.ts`                | `EnqueueOptions`, `QueueEnqueueOptions`, `ScheduleOptions`                                                                                                                                                                                                        |
+| `@shivaedev/jobs/server/job.ts`                           | `Job`, `JobState`, `WorkerJob`                                                                                                                                                                                                                                    |
+| `@shivaedev/jobs/server/clientOptions.ts`                 | `ClientOptions`, `StopOptions`, `Clock`, `ReindexOptions`, `IndexBloatOptions`                                                                                                                                                                                    |
+| `@shivaedev/jobs/server/ClientDatabase.ts`                | `ClientDatabase`                                                                                                                                                                                                                                                  |
+| `@shivaedev/jobs/server/engineClient.ts`                  | `EngineClient`, `EngineSchedule`                                                                                                                                                                                                                                  |
+| `@shivaedev/jobs/server/client.ts`                        | `PgBossClient`, `PgBossClientFactory`                                                                                                                                                                                                                             |
+| `@shivaedev/jobs/server/inspection.ts`                    | `PgBossInspection`; `PgBossInspectionService`                                                                                                                                                                                                                     |
+| `@shivaedev/jobs/server/testing.ts`                       | `makePgBossTesting`, `testRetryPolicy`; `PgBossTesting`, `PgBossTestingOptions`, `PgBossTestingWaitOptions`                                                                                                                                                       |
+| `@shivaedev/jobs/server/defineSchedule.ts`                | `defineSchedule`                                                                                                                                                                                                                                                  |
+| `@shivaedev/jobs/server/adapters/defaultClientFactory.ts` | `defaultClientFactory`                                                                                                                                                                                                                                            |
+
+Jobs declares its public types independently of pg-boss. The option fields keep their familiar names: `queue` uses `QueueOptions`, including literal `QueuePolicy` values and `maxDeferrals`; `worker` uses `WorkerOptions`; a schedule's `schedule` uses `ScheduleOptions`; enqueueing uses `EnqueueOptions`. A queue also requires `name` and `schema`; a schedule requires `name` and `cron`.
 
 Queue and scheduled workers reject `perJobResults: true` and `transactional: true` during Layer acquisition with a registration `PgBossError`; its redacted `original` names the unsupported options. Omit these options or set them to `false`. The adapter settles each job itself and does not expose pg-boss's transaction client to handlers.
 
-`Jobs.layer(options)` accepts pg-boss `ConstructorOptions` plus the adapter's own options. Custom clients must supply native `complete` and `fail` capabilities to register queue or schedule workers; missing settlement capabilities fail Layer acquisition with a registration `PgBossError`. Workers also require `getDb()` to read the PostgreSQL clock when a batch arrives. Producer-only clients do not need these capabilities. Custom clients can also supply the optional native capabilities `findJobs`, `retry`, `update`, `getDb` and `updateQueue` for lookup, retry, live counts and listings, deferral and reconciliation; a requested operation fails with `PgBossError` if its required capability is absent.
+`pgBossLayer(options)` accepts `PgBossOptions`, built from jobs-owned `ClientOptions` with a redacted connection string and lifecycle settings. `Jobs.layer(options)` accepts registrations, retired names and `onError`. Custom clients must supply native `complete` and `fail` capabilities to register queue or schedule workers; missing settlement capabilities fail Layer acquisition with a registration `PgBossError`. Workers also require `getDb()` to read the PostgreSQL clock when a batch arrives. Producer-only clients do not need these capabilities. Custom clients can also supply the optional native capabilities `findJobs`, `retry`, `update`, `getDb` and `updateQueue` for lookup, retry, live counts and listings, deferral and reconciliation; administration uses optional `deleteQueue`, `getSchedule`, `unschedule` and `supervise` capabilities. A requested operation fails with `PgBossError` if its required capability is absent.
 
 `onError` handles pg-boss client `error` events using the services captured by the Layer. The Layer interrupts pending callbacks and waits for them to end before release completes. Only the owning jobs service is supplied automatically; a handler using another jobs definition still requires that definition's Layer.
 

package/dist/display.d.ts

@@ -0,0 +1,14 @@
+import type { Schema } from "effect";
+export interface SubjectColumn<TPayload extends Schema.Top> {
+    readonly field: Extract<keyof TPayload["Type"], string>;
+    readonly label: string;
+}
+export interface QueueDisplay {
+    readonly label?: string;
+    readonly name: string;
+    readonly subject?: readonly {
+        readonly field: string;
+        readonly label: string;
+    }[];
+}
+//# sourceMappingURL=display.d.ts.map

package/dist/display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../src/display.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,MAAM,WAAW,aAAa,CAAC,QAAQ,SAAS,MAAM,CAAC,GAAG;IACzD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,MAAM,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;IACxD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACjF"}

package/dist/display.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=display.js.map

package/dist/display.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"display.js","sourceRoot":"","sources":["../src/display.ts"],"names":[],"mappings":""}

package/dist/server/ClientDatabase.d.ts

@@ -0,0 +1,21 @@
+export interface ClientDatabase {
+    beginTransaction?: () => Promise<{
+        db: ClientDatabase;
+        commit: () => Promise<void>;
+        rollback: () => Promise<void>;
+    }>;
+    executeSql: (text: string, values?: unknown[]) => Promise<{
+        rows: Record<string, unknown>[];
+    }>;
+    listen?: (channel: string, onNotification: (payload: string) => void, onReconnect: () => void) => Promise<{
+        close: () => Promise<void>;
+    }>;
+    poolCounts?: () => {
+        max: number;
+        total: number;
+        idle: number;
+        waiting: number;
+    } | null;
+    setSessionStatements?: (statements: string[]) => Promise<void>;
+}
+//# sourceMappingURL=ClientDatabase.d.ts.map

package/dist/server/ClientDatabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientDatabase.d.ts","sourceRoot":"","sources":["../../src/server/ClientDatabase.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC9B,gBAAgB,CAAC,EAAE,MAAM,OAAO,CAAC;QAAE,EAAE,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC,CAAC;IACrH,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;KAAE,CAAC,CAAC;IAC/F,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EAAE,WAAW,EAAE,MAAM,IAAI,KAAK,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC,CAAC;IAC1I,UAAU,CAAC,EAAE,MAAM;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACxF,oBAAoB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/D"}

package/dist/server/ClientDatabase.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ClientDatabase.js.map

package/dist/server/ClientDatabase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientDatabase.js","sourceRoot":"","sources":["../../src/server/ClientDatabase.ts"],"names":[],"mappings":""}

package/dist/server/PgBoss.d.ts

@@ -1,6 +1,6 @@
 import { Context } from "effect";
-import type { StopOptions } from "pg-boss";
-import type { AcquiredClient } from "#internal/lifecycle.ts";
+import type { StopOptions } from "#server/clientOptions.ts";
+import type { AcquiredClient } from "#server/internal/lifecycle.ts";
 declare const PgBoss_base: Context.ServiceClass<PgBoss, "@shivaedev/jobs/PgBoss", AcquiredClient & {
     readonly schema: string | undefined;
     readonly stop: StopOptions | undefined;

package/dist/server/PgBoss.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PgBoss.d.ts","sourceRoot":"","sources":["../../src/server/PgBoss.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;;qBAIxB,MAAM,GAAG,SAAS;mBAAiB,WAAW,GAAG,SAAS;;AAF/F,qBAAa,MAAO,SAAQ,WAGC;CAAG"}
+{"version":3,"file":"PgBoss.d.ts","sourceRoot":"","sources":["../../src/server/PgBoss.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AACjC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;;qBAI/B,MAAM,GAAG,SAAS;mBAAiB,WAAW,GAAG,SAAS;;AAF/F,qBAAa,MAAO,SAAQ,WAGC;CAAG"}

package/dist/server/adapters/batchClockOffset.d.ts

@@ -1,4 +1,4 @@
 import { Effect } from "effect";
-import type { PgBossClient } from "#client.ts";
-export declare const batchClockOffset: (client: PgBossClient, schema: string, name: string) => Effect.Effect<number, import("#error.ts").PgBossError, never>;
+import type { PgBossClient } from "#server/client.ts";
+export declare const batchClockOffset: (client: PgBossClient, schema: string, name: string) => Effect.Effect<number, import("#server/error.ts").PgBossError, never>;
 //# sourceMappingURL=batchClockOffset.d.ts.map

package/dist/server/adapters/batchClockOffset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batchClockOffset.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/batchClockOffset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,eAAO,MAAM,gBAAgB,uHAW3B,CAAC"}
+{"version":3,"file":"batchClockOffset.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/batchClockOffset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAU,MAAM,QAAQ,CAAC;AAC/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAItD,eAAO,MAAM,gBAAgB,8HAc3B,CAAC"}

package/dist/server/adapters/batchClockOffset.js

@@ -1,6 +1,6 @@
-import { Clock, Effect } from "effect";
-import { toPgBossError } from "#error.ts";
-import { quotedSchema } from "#internal/storedRows.ts";
+import { Clock, Effect, Schema } from "effect";
+import { toPgBossError } from "#server/error.ts";
+import { quotedSchema } from "#server/internal/storedRows.ts";
 export const batchClockOffset = Effect.fnUntraced(function* (client, schema, name) {
     const { rows } = yield* Effect.tryPromise({
         catch: (error) => toPgBossError("settle", error, name),
@@ -11,6 +11,7 @@ export const batchClockOffset = Effect.fnUntraced(function* (client, schema, nam
             return client.getDb().executeSql(`SELECT EXTRACT(EPOCH FROM ${quotedSchema(schema)}.job_now()) * 1000 AS now`);
         },
     });
-    return (yield* Clock.currentTimeMillis) - Number(rows[0].now);
+    const row = yield* Schema.decodeUnknownEffect(Schema.Struct({ now: Schema.Union([Schema.String, Schema.Number]) }))(rows[0]).pipe(Effect.mapError((error) => toPgBossError("settle", error, name)));
+    return (yield* Clock.currentTimeMillis) - Number(row.now);
 });
 //# sourceMappingURL=batchClockOffset.js.map

package/dist/server/adapters/batchClockOffset.js.map

@@ -1 +1 @@
-{"version":3,"file":"batchClockOffset.js","sourceRoot":"","sources":["../../../src/server/adapters/batchClockOffset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEvC,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAoB,EAAE,MAAc,EAAE,IAAY;IAC9G,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC;QACzC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,CAAC;QACtD,GAAG,EAAE,GAAG,EAAE;YACT,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBAChC,MAAM,IAAI,SAAS,CAAC,wDAAwD,CAAC,CAAC;YAC/E,CAAC;YACD,OAAO,MAAM,CAAC,KAAK,EAAE,CAAC,UAAU,CAAC,6BAA6B,YAAY,CAAC,MAAM,CAAC,2BAA2B,CAAC,CAAC;QAChH,CAAC;KACD,CAAC,CAAC;IACH,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAC/D,CAAC,CAAC,CAAC"}
+{"version":3,"file":"batchClockOffset.js","sourceRoot":"","sources":["../../../src/server/adapters/batchClockOffset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAE9D,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAoB,EAAE,MAAc,EAAE,IAAY;IAC9G,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC;QACzC,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,CAAC;QACtD,GAAG,EAAE,GAAG,EAAE;YACT,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBAChC,MAAM,IAAI,SAAS,CAAC,wDAAwD,CAAC,CAAC;YAC/E,CAAC;YACD,OAAO,MAAM,CAAC,KAAK,EAAE,CAAC,UAAU,CAAC,6BAA6B,YAAY,CAAC,MAAM,CAAC,2BAA2B,CAAC,CAAC;QAChH,CAAC;KACD,CAAC,CAAC;IACH,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAChI,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAChE,CAAC;IACF,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAC3D,CAAC,CAAC,CAAC"}

package/dist/server/adapters/batchHandler.d.ts

@@ -0,0 +1,5 @@
+import { Effect } from "effect";
+import type { PgBossClient } from "#server/client.ts";
+import type { WorkerJob } from "#server/job.ts";
+export declare function batchHandler<R>(client: PgBossClient, name: string, schema: string, run: (job: WorkerJob<unknown>, deadline: number) => Effect.Effect<unknown, unknown, R>, afterRetry?: (job: WorkerJob<unknown>) => Effect.Effect<void, unknown>): (jobs: readonly WorkerJob<unknown>[]) => Effect.Effect<void, unknown, R>;
+//# sourceMappingURL=batchHandler.d.ts.map

package/dist/server/adapters/batchHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batchHandler.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/batchHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAQ,MAAM,QAAQ,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAMtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAyChD,wBAAgB,YAAY,CAAC,CAAC,EAC7B,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,CAAC,GAAG,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC,EACtF,UAAU,GAAE,CAAC,GAAG,EAAE,SAAS,CAAC,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAqB,UA0B3E,SAAS,SAAS,CAAC,OAAO,CAAC,EAAE,qCAiB3C"}

package/dist/server/{internal → adapters}/batchHandler.js

@@ -1,10 +1,10 @@
 import { Cause, Clock, Effect, Exit } from "effect";
-import { batchClockOffset } from "#adapters/batchClockOffset.ts";
-import { toPgBossError } from "#error.ts";
-import { deadlineOf } from "#internal/deadlineOf.ts";
-import { deferredAttempt } from "#internal/deferral.ts";
-import { failureOutput } from "#internal/failureOutput.ts";
-import { waitForBatchExpiry } from "#internal/waitForBatchExpiry.ts";
+import { batchClockOffset } from "#server/adapters/batchClockOffset.ts";
+import { toPgBossError } from "#server/error.ts";
+import { deadlineOf } from "#server/internal/deadlineOf.ts";
+import { deferredAttempt } from "#server/internal/deferral.ts";
+import { failureOutput } from "#server/internal/failureOutput.ts";
+import { waitForBatchExpiry } from "#server/internal/waitForBatchExpiry.ts";
 function settleAttempt(complete, fail, name, job, exit) {
     if (Exit.isSuccess(exit) && exit.value === deferredAttempt) {
         return Effect.void;

package/dist/server/adapters/batchHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batchHandler.js","sourceRoot":"","sources":["../../../src/server/adapters/batchHandler.ts"],"names":[],"mappings":"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"}

package/dist/server/adapters/clientCache.d.ts

@@ -0,0 +1,10 @@
+import type { ClientOptions } from "#server/clientOptions.ts";
+import type { StartingClient } from "./lifecycle.ts";
+export declare function acquireCachedClient(key: string | symbol, constructorOptions: ClientOptions, start: () => StartingClient): {
+    reused: boolean;
+    client: import("../client.ts").PgBossClient;
+    ready: Promise<void>;
+    stop: (options?: import("#server/clientOptions.ts").StopOptions) => Promise<void>;
+};
+export declare function releaseCachedClient(key: string | symbol): StartingClient | undefined;
+//# sourceMappingURL=clientCache.d.ts.map

package/dist/server/adapters/clientCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientCache.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/clientCache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AA4BrD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,kBAAkB,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,cAAc;;;;;EAgBvH;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,GAAG,SAAS,CAWpF"}

package/dist/server/{internal → adapters}/clientCache.js

@@ -1,5 +1,5 @@
 import { isDeepStrictEqual } from "node:util";
-import { PgBossClientOptionsError } from "#error.ts";
+import { PgBossClientOptionsError } from "#server/error.ts";
 const cacheSymbol = Symbol.for("@shivaedev/jobs/server/client-cache");
 const shared = Reflect.get(globalThis, cacheSymbol);
 const clients = shared instanceof Map ? shared : new Map();
@@ -11,11 +11,11 @@ function entryFor(key) {
 function isCachedClient(value) {
     return (typeof value === "object"
         && value !== null
-        && Reflect.get(value, "client") instanceof Promise
+        && typeof Reflect.get(value, "client") === "object"
         && typeof Reflect.get(value, "constructorOptions") === "object"
         && typeof Reflect.get(value, "references") === "number");
 }
-export async function acquireCachedClient(key, constructorOptions, start) {
+export function acquireCachedClient(key, constructorOptions, start) {
     const existing = entryFor(key);
     if (existing !== undefined) {
         const options = [...new Set([...Object.keys(existing.constructorOptions), ...Object.keys(constructorOptions)])]
@@ -25,26 +25,12 @@ export async function acquireCachedClient(key, constructorOptions, start) {
             throw new PgBossClientOptionsError({ key, options });
         }
         existing.references += 1;
-        try {
-            return { client: await existing.client, reused: true };
-        }
-        catch (error) {
-            existing.references -= 1;
-            throw error;
-        }
+        return { ...existing.client, reused: true };
     }
     const settings = { ...constructorOptions };
     const entry = { client: start(), constructorOptions: settings, references: 1 };
     clients.set(key, entry);
-    try {
-        return { client: await entry.client, reused: false };
-    }
-    catch (error) {
-        if (clients.get(key) === entry) {
-            clients.delete(key);
-        }
-        throw error;
-    }
+    return { ...entry.client, reused: false };
 }
 export function releaseCachedClient(key) {
     const entry = entryFor(key);

package/dist/server/adapters/clientCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientCache.js","sourceRoot":"","sources":["../../../src/server/adapters/clientCache.ts"],"names":[],"mappings":"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"}

package/dist/server/adapters/clientErrorLogger.js

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import { logClientError } from "#internal/clientErrors.ts";
+import { logClientError } from "#server/internal/clientErrors.ts";
 export const clientErrorLogger = Effect.fnUntraced(function* () {
     const run = Effect.runForkWith(yield* Effect.context());
     return (error) => {

package/dist/server/adapters/clientErrorLogger.js.map

@@ -1 +1 @@
-{"version":3,"file":"clientErrorLogger.js","sourceRoot":"","sources":["../../../src/server/adapters/clientErrorLogger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC;IAC3D,MAAM,GAAG,GAAG,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,EAAS,CAAC,CAAC;IAC/D,OAAO,CAAC,KAAY,EAAQ,EAAE;QAC7B,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC,CAAC;AACH,CAAC,CAAC,CAAC"}
+{"version":3,"file":"clientErrorLogger.js","sourceRoot":"","sources":["../../../src/server/adapters/clientErrorLogger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAElE,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC;IAC3D,MAAM,GAAG,GAAG,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,EAAS,CAAC,CAAC;IAC/D,OAAO,CAAC,KAAY,EAAQ,EAAE;QAC7B,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACzC,CAAC,CAAC;AACH,CAAC,CAAC,CAAC"}

package/dist/server/adapters/defaultClientFactory.d.ts

@@ -0,0 +1,4 @@
+import type { ClientOptions } from "#server/clientOptions.ts";
+import type { EngineClient } from "#server/engineClient.ts";
+export declare function defaultClientFactory(options: ClientOptions): EngineClient;
+//# sourceMappingURL=defaultClientFactory.d.ts.map

package/dist/server/adapters/defaultClientFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultClientFactory.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/defaultClientFactory.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE5D,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,aAAa,GAAG,YAAY,CA0BzE"}

package/dist/server/adapters/defaultClientFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultClientFactory.js","sourceRoot":"","sources":["../../../src/server/adapters/defaultClientFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAIjC,MAAM,UAAU,oBAAoB,CAAC,OAAsB;IAC1D,MAAM,YAAY,GAAG,IAAI,GAAG,EAAiB,CAAC;IAC9C,MAAM,MAAM,GAAG;QACd,GAAG,OAAO;QACV,MAAM,EAAE,GAAG,EAAE;YACZ,MAAM,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YAC5B,MAAM,MAAM,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE,CAC5C,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE;gBACzB,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBAC5B,OAAO,EAAE,CAAC;YACX,CAAC,CAAC,CACF,CAAC;YACF,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACzB,OAAO,MAAM,CAAC;QACf,CAAC;KACD,CAAC;IACF,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACtC,MAAM,CAAC,IAAI,GAAG,KAAK,EAAE,WAAW,EAAE,EAAE;QACnC,MAAM,IAAI,CAAC,WAAW,CAAC,CAAC;QACxB,0EAA0E;QAC1E,IAAI,WAAW,EAAE,KAAK,KAAK,KAAK,EAAE,CAAC;YAClC,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;QACtC,CAAC;IACF,CAAC,CAAC;IACF,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/server/adapters/deferralCount.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import type { Job } from "pg-boss";
-import type { PgBossClient } from "#client.ts";
-export declare const deferralCount: (client: PgBossClient, schema: string, job: Job<unknown>) => Effect.Effect<number, import("#error.ts").PgBossError, never>;
+import type { PgBossClient } from "#server/client.ts";
+import type { WorkerJob } from "#server/job.ts";
+export declare const deferralCount: (client: PgBossClient, schema: string, job: WorkerJob<unknown>) => Effect.Effect<number, import("#server/error.ts").PgBossError, never>;
 //# sourceMappingURL=deferralCount.d.ts.map

package/dist/server/adapters/deferralCount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deferralCount.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/deferralCount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAM/C,eAAO,MAAM,aAAa,4HAmBxB,CAAC"}
+{"version":3,"file":"deferralCount.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/deferralCount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAIhD,eAAO,MAAM,aAAa,yIAmBxB,CAAC"}