@getstrata/core 2.1.0 → 2.2.1

package/dist/core/http/throttleMiddleware.d.ts

@@ -1,5 +1,15 @@
+import { type TenantContext } from "@getstrata/core/tenant/tenantContext";
 import { RedisClient } from "bun";
 import type { Middleware } from "./middleware";
+interface ThrottleQuotaContext {
+    readonly request: Request;
+    readonly tenant: TenantContext | null;
+    readonly identity: string;
+    readonly routeTemplate: string;
+    readonly maxAttempts: number;
+}
+/** A synchronous application-owned attempt limit; the window remains fixed. */
+type ThrottleQuotaPolicy = (context: ThrottleQuotaContext) => number;
 interface ThrottleOptions {
     redisUrl: string;
     maxAttempts: number;
@@ -7,14 +17,22 @@ interface ThrottleOptions {
     keyPrefix?: string;
     commandTimeoutMs?: number;
     redisClient?: RedisThrottleClient;
+    quotaPolicy?: ThrottleQuotaPolicy;
 }
 declare function resolveThrottleIdentity(request: Request): string;
 type RedisThrottleClient = Pick<RedisClient, "send">;
-declare function redisThrottleKey(request: Request, prefix: string, identity: string): string;
-declare function consumeRedisThrottle(client: RedisThrottleClient, key: string, decaySeconds: number, timeoutMs?: number): Promise<number>;
+declare function redisThrottleKey(request: Request, prefix: string, identity: string, tenantId?: number | null): string;
+declare function consumeRedisThrottle(client: RedisThrottleClient, key: string, decaySeconds: number, timeoutMs?: number, signal?: AbortSignal): Promise<number>;
 /** Reuse a healthy connection; failed owned connections are recreated on the next request. */
-declare function createRedisThrottleConsumer(options: Pick<ThrottleOptions, "redisUrl" | "redisClient" | "commandTimeoutMs">): (key: string, decaySeconds: number) => Promise<number>;
+declare function createRedisThrottleConsumer(options: Pick<ThrottleOptions, "redisUrl" | "redisClient" | "commandTimeoutMs">): ((key: string, decaySeconds: number) => Promise<number>) & {
+    isDisposed: () => boolean;
+    dispose(): void;
+};
+type DisposableThrottle = Middleware & {
+    dispose(): void;
+};
 declare function throttleUnavailableResponse(): Response;
-declare function createThrottleMiddleware(options: ThrottleOptions): Middleware;
-export type { RedisThrottleClient, ThrottleOptions };
-export { consumeRedisThrottle, createRedisThrottleConsumer, createThrottleMiddleware, redisThrottleKey, resolveThrottleIdentity, throttleUnavailableResponse, };
+declare function resolveThrottleQuota(request: Request, options: Pick<ThrottleOptions, "maxAttempts" | "quotaPolicy">, identity?: string): number;
+declare function createThrottleMiddleware(options: ThrottleOptions): DisposableThrottle;
+export type { DisposableThrottle, RedisThrottleClient, ThrottleOptions, ThrottleQuotaContext, ThrottleQuotaPolicy, };
+export { consumeRedisThrottle, createRedisThrottleConsumer, createThrottleMiddleware, redisThrottleKey, resolveThrottleIdentity, resolveThrottleQuota, throttleUnavailableResponse, };

package/dist/core/lifecycle/gracefulShutdown.d.ts

@@ -1,6 +1,34 @@
-type ShutdownHandler = () => void | Promise<void>;
-declare function registerShutdownHandler(name: string, handler: ShutdownHandler): () => void;
-declare function runGracefulShutdown(signal: string): Promise<void>;
-declare function installGracefulShutdownSignals(signals?: NodeJS.Signals[]): void;
+type ShutdownPhase = "stop" | "drain" | "flush" | "close" | "force";
+type ShutdownContext = {
+    signal: AbortSignal;
+    reason: string;
+};
+type ShutdownHandler = (context: ShutdownContext) => void | Promise<void>;
+type ShutdownFailure = {
+    name: string;
+    phase: ShutdownPhase;
+    error: unknown;
+};
+type ShutdownResult = {
+    successful: boolean;
+    timedOut: boolean;
+    errors: ShutdownFailure[];
+};
+declare class LifecycleCoordinator {
+    private readonly handlers;
+    private running?;
+    private readonly timeoutMs;
+    constructor(options?: {
+        timeoutMs?: number;
+    });
+    get isShuttingDown(): boolean;
+    register(name: string, handler: ShutdownHandler, phase?: ShutdownPhase): () => void;
+    shutdown(reason?: string): Promise<ShutdownResult>;
+    private execute;
+}
+declare function registerShutdownHandler(name: string, handler: ShutdownHandler, phase?: ShutdownPhase): () => void;
+declare function runGracefulShutdown(signal: string): Promise<ShutdownResult>;
+declare function installGracefulShutdownSignals(signals?: NodeJS.Signals[], lifecycle?: LifecycleCoordinator): () => void;
 declare function resetGracefulShutdownForTests(): void;
-export { installGracefulShutdownSignals, registerShutdownHandler, resetGracefulShutdownForTests, runGracefulShutdown, };
+export type { ShutdownContext, ShutdownFailure, ShutdownHandler, ShutdownPhase, ShutdownResult };
+export { installGracefulShutdownSignals, LifecycleCoordinator, registerShutdownHandler, resetGracefulShutdownForTests, runGracefulShutdown, };

package/dist/core/queue/createAppQueue.d.ts

@@ -1,5 +1,6 @@
 import type { Queue } from "./index";
 import { createFailedJobService, createQueueWorker, createTrackedJob, type FailedJobService } from "./publicQueue";
+import { resolveQueueConfig } from "./queueConfig";
 declare const FAILED_JOB_SERVICE_TOKEN = "core.failedJobs";
 declare function createAppQueue(driver: "sync" | "async" | "redis", redisUrl?: string, failedJobs?: FailedJobService, registerJobs?: () => void): Queue;
-export { createAppQueue, createFailedJobService, createQueueWorker, createTrackedJob, FAILED_JOB_SERVICE_TOKEN, };
+export { createAppQueue, createFailedJobService, createQueueWorker, createTrackedJob, FAILED_JOB_SERVICE_TOKEN, resolveQueueConfig, };

package/dist/core/queue/failedJobService.d.ts

@@ -5,11 +5,13 @@ declare class FailedJobService {
     constructor(repository: FailedJobRepository);
     recordFailure(input: {
         jobName: string;
+        jobId?: string;
         payload: Record<string, unknown>;
         exception: string;
     }): Promise<FailedJobRecord>;
     listRecent(limit?: number): Promise<FailedJobRecord[]>;
-    retry(id: number): Promise<FailedJobRecord>;
+    /** Admit the replay before deleting its recovery record. Delivery remains at least once. */
+    retry(id: number, enqueue: (record: FailedJobRecord) => Promise<void>): Promise<FailedJobRecord>;
     delete(id: number): Promise<void>;
     flush(): Promise<number>;
 }

package/dist/core/queue/index.d.ts

@@ -1,21 +1,36 @@
 type QueuePriority = "high" | "default" | "low";
+/** Logical identity is stable across automatic recovery and supported manual replay. */
+interface JobContext {
+    readonly jobId: string;
+    readonly signal: AbortSignal;
+    readonly deadlineAtMs?: number;
+}
 declare abstract class Job<TPayload extends object = object> {
     static readonly jobName?: string;
     readonly maxAttempts?: number;
     readonly backoffMs?: number;
     readonly priority?: QueuePriority;
     constructor();
-    abstract handle(payload: TPayload): Promise<void>;
+    abstract handle(payload: TPayload, context?: JobContext): Promise<void>;
 }
 interface Queue {
+    close?(): void | Promise<void>;
+    /** Preserve a stored logical identity on deliberate replay; reset execution controls. */
+    replay?<TPayload extends object>(job: Job<TPayload>, payload: TPayload, jobId: string): Promise<void>;
     dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
 }
 declare class SyncQueue implements Queue {
     dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
 }
 declare class AsyncQueue implements Queue {
+    private readonly active;
+    private closing?;
+    private closed;
+    protected assertOpen(): void;
+    protected enqueue(task: () => Promise<void>, onError: (error: unknown) => void): void;
     dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+    close(): Promise<void>;
 }
 declare function createQueue(driver: "sync" | "async"): Queue;
-export type { Queue, QueuePriority };
+export type { JobContext, Queue, QueuePriority };
 export { AsyncQueue, createQueue, Job, SyncQueue };

package/dist/core/queue/jobRunner.d.ts

@@ -3,9 +3,15 @@ interface QueueJobEnvelope {
     name: string;
     payload: Record<string, unknown>;
     attempts?: number;
+    jobId?: string;
+    deadlineAtMs?: number;
+    cancellable?: boolean;
 }
+declare function parseQueueJobEnvelope(rawPayload: string): QueueJobEnvelope | null;
 declare function runQueueJob(envelope: QueueJobEnvelope, failedJobs: FailedJobService, options?: {
     onFailureRecorded?: () => void;
+    context?: import("./index").JobContext;
+    deferRetry?: (envelope: QueueJobEnvelope, delayMs: number) => Promise<void>;
 }): Promise<void>;
 export type { QueueJobEnvelope };
-export { runQueueJob };
+export { parseQueueJobEnvelope, runQueueJob };

package/dist/core/queue/publicQueue.d.ts

@@ -4,6 +4,7 @@ import type { Job, Queue } from "./index.ts";
 import { jobRegistry } from "./jobRegistry.ts";
 import { runQueueJob } from "./jobRunner.ts";
 import { QueueWorker, RedisQueue } from "./redisQueue.ts";
+import { RedisStreamsWorker } from "./redisStreams";
 import { ResilientQueue } from "./resilientQueue.ts";
 declare function createFailedJobService(): FailedJobService;
 declare function createTrackedJob<TPayload extends object>(name: string, job: Job<TPayload>): Job<TPayload>;
@@ -12,5 +13,5 @@ declare function createProductionQueue(driver: "sync" | "async" | "redis", optio
     failedJobs?: FailedJobService;
     registerJobs?: () => void;
 }): Queue;
-declare function createQueueWorker(redisUrl: string, failedJobs?: FailedJobService): QueueWorker;
+declare function createQueueWorker(redisUrl: string, failedJobs?: FailedJobService): QueueWorker | RedisStreamsWorker;
 export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, runQueueJob, };

package/dist/core/queue/queueConfig.d.ts

@@ -7,3 +7,6 @@ declare function resolveQueueConfig(): QueueConfig;
 declare const queueConfig: QueueConfig;
 export type { QueueConfig };
 export { queueConfig, resolveQueueConfig };
+declare function resolveRedisQueueTransport(): "lists" | "streams";
+declare function readQueueVisibilityMs(): number;
+export { readQueueVisibilityMs, resolveRedisQueueTransport };

package/dist/core/queue/redisQueue.d.ts

@@ -1,15 +1,11 @@
 import { RedisClient } from "bun";
 import type FailedJobService from "./failedJobService";
-import type { Job, Queue, QueuePriority } from "./index";
-import { type QueueJobEnvelope } from "./jobRunner";
-declare const QUEUE_LIST_KEY: string;
-declare const QUEUE_HIGH_KEY: string;
-declare const QUEUE_LOW_KEY: string;
+import type { Job, Queue } from "./index";
+import { parseQueueJobEnvelope, type QueueJobEnvelope } from "./jobRunner";
+import { QUEUE_HIGH_KEY, QUEUE_LIST_KEY, QUEUE_LOW_KEY, queueKeyForPriority } from "./redisQueueKeys";
 declare function queueProcessingKey(queueKey: string): string;
 declare function queueProcessingLeaseKey(queueKey: string): string;
 declare function reservationExpired(lease: string | null, now: number, visibilityMs: number): boolean;
-declare function queueKeyForPriority(priority?: QueuePriority): string;
-declare function parseQueueJobEnvelope(rawPayload: string): QueueJobEnvelope | null;
 type QueueReservation = {
     id: string;
     owner: string;
@@ -23,6 +19,7 @@ declare function reclaimExpiredQueueReservations(client: RedisClient, queueKeys?
 declare class RedisQueue implements Queue {
     private readonly client;
     constructor(redisUrl: string);
+    close(): void;
     dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
 }
 declare class QueueWorker {
@@ -42,5 +39,7 @@ declare class QueueWorker {
     close(): void;
 }
 declare function countPendingQueueJobs(redisUrl: string): Promise<number>;
+export type { StreamReservation, StreamsEnqueueOptions } from "./redisStreams";
+export { migrateLegacyQueueToStreams, RedisStreamsQueue, RedisStreamsWorker, STREAM_GROUP, streamDeadLetterKey, streamQueueKey, updateStreamReservation, } from "./redisStreams";
 export type { QueueJobEnvelope, QueueReservation };
 export { countPendingQueueJobs, parseQueueJobEnvelope, QUEUE_HIGH_KEY, QUEUE_LIST_KEY, QUEUE_LOW_KEY, QueueWorker, queueInvalidKey, queueKeyForPriority, queueProcessingKey, queueProcessingLeaseKey, RedisQueue, reclaimExpiredQueueReservations, reservationExpired, reserveQueueJob, updateQueueReservation, };

package/dist/core/queue/redisQueueKeys.d.ts

@@ -0,0 +1,8 @@
+import type { QueuePriority } from "./index";
+declare const QUEUE_LIST_KEY: string;
+declare const QUEUE_HIGH_KEY: string;
+declare const QUEUE_LOW_KEY: string;
+declare function defaultQueueKeys(): readonly [string, string, string];
+declare const QUEUE_KEYS: readonly [string, string, string];
+declare function queueKeyForPriority(priority?: QueuePriority): string;
+export { defaultQueueKeys, QUEUE_HIGH_KEY, QUEUE_KEYS, QUEUE_LIST_KEY, QUEUE_LOW_KEY, queueKeyForPriority, };

package/dist/core/queue/redisStreams.d.ts

@@ -0,0 +1,73 @@
+import { RedisClient } from "bun";
+import type FailedJobService from "./failedJobService";
+import type { Job, Queue } from "./index";
+import { type QueueJobEnvelope } from "./jobRunner";
+declare const STREAM_GROUP = "strata-workers-v1";
+declare function streamQueueKey(queueKey: string): string;
+declare function streamDeadLetterKey(queueKey: string): string;
+declare function streamRetryKey(queueKey: string): string;
+interface StreamsEnqueueOptions {
+    /** Total lifetime including time waiting and retries, measured from Redis server time. */
+    timeoutMs?: number;
+    cancellable?: boolean;
+}
+declare function streamControlKey(key: string, jobId: string): string;
+declare function cancelStreamJob(client: RedisClient, key: string, jobId: string): Promise<boolean>;
+declare function readStreamCancellation(client: RedisClient, controlKey: string): Promise<boolean>;
+declare function readStreamTime(client: RedisClient): Promise<number>;
+declare function watchStreamDeadline(client: RedisClient, deadlineAtMs: number, remainingMs: number, expire: () => void, fail: (error: unknown) => void): () => void;
+declare function scheduleStreamRetry(client: RedisClient, key: string, reservation: StreamReservation, envelope: QueueJobEnvelope, delayMs: number): Promise<void>;
+declare function promoteStreamRetries(client: RedisClient, key: string): Promise<number>;
+declare function readStreamQueueDepth(client: RedisClient, key: string): Promise<number>;
+type StreamReservation = {
+    id: string;
+    owner: string;
+    payload: string;
+};
+declare function ensureStreamGroup(client: RedisClient, key: string): Promise<void>;
+declare function readStreamEntry(value: unknown, owner: string): StreamReservation | null;
+declare function updateStreamReservation(client: RedisClient, key: string, reservation: StreamReservation, action: "renew" | "ack" | "quarantine", controlKey?: string): Promise<boolean>;
+declare function reserveStreamJob(client: RedisClient, key: string, owner: string, cursor?: string): Promise<{
+    reservation: StreamReservation | null;
+    cursor: string;
+}>;
+declare class RedisStreamsQueue implements Queue {
+    private readonly client;
+    constructor(redisUrl: string);
+    close(): void;
+    dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+    enqueue<TPayload extends object>(job: Job<TPayload>, payload: TPayload, options?: StreamsEnqueueOptions): Promise<string>;
+    replay<TPayload extends object>(job: Job<TPayload>, payload: TPayload, jobId: string): Promise<void>;
+    private admit;
+    cancel(jobId: string): Promise<boolean>;
+}
+declare class RedisStreamsWorker {
+    private readonly failedJobs;
+    private readonly timeoutSeconds;
+    private readonly queueKeys;
+    private readonly client;
+    private readonly owner;
+    private readonly cursors;
+    private processing;
+    private initialized;
+    private running;
+    private stopping;
+    private active?;
+    constructor(redisUrl: string, failedJobs: FailedJobService, timeoutSeconds?: number, queueKeys?: readonly string[]);
+    requestStop(): void;
+    isRunning(): boolean;
+    close(): void;
+    private initialize;
+    private reserve;
+    processNext(): Promise<boolean>;
+    private processOne;
+    private handle;
+    run(): Promise<void>;
+}
+declare function migrateLegacyQueueToStreams(client: RedisClient, options: {
+    maintenance: true;
+    batchSize?: number;
+    queueKeys?: readonly string[];
+}): Promise<number>;
+export type { StreamReservation, StreamsEnqueueOptions };
+export { cancelStreamJob, ensureStreamGroup, migrateLegacyQueueToStreams, promoteStreamRetries, RedisStreamsQueue, RedisStreamsWorker, readStreamCancellation, readStreamEntry, readStreamQueueDepth, readStreamTime, reserveStreamJob, STREAM_GROUP, scheduleStreamRetry, streamControlKey, streamDeadLetterKey, streamQueueKey, streamRetryKey, updateStreamReservation, watchStreamDeadline, };

package/dist/core/queue/resilientQueue.d.ts

@@ -1,6 +1,6 @@
 import type FailedJobService from "./failedJobService";
-import type { Job, Queue } from "./index";
-declare class ResilientQueue implements Queue {
+import { AsyncQueue, type Job } from "./index";
+declare class ResilientQueue extends AsyncQueue {
     private readonly failedJobs;
     private readonly asyncDispatch;
     constructor(failedJobs: FailedJobService, asyncDispatch?: boolean);

package/dist/core/queue/types.d.ts

@@ -1,6 +1,7 @@
 interface FailedJobRecord {
     id: number;
     job_name: string;
+    job_id?: string | null;
     payload: Record<string, unknown>;
     exception: string;
     failed_at: Date;

package/dist/core/runtime/applicationRegistry.d.ts

@@ -6,6 +6,7 @@ import type { AppContext } from "../contracts/di";
 import { type Logger } from "../logging/logger";
 import type { Queue } from "../queue";
 declare function setActiveApplicationContext(context: AppContext): void;
+declare function clearActiveApplicationContext(context: AppContext): void;
 declare function resolveApplicationCache(): CacheLike;
 declare function resolveApplicationQueue(): Queue;
 declare function resolveApplicationEventBus(): EventBus;
@@ -14,4 +15,4 @@ declare function resolveApplicationPolicyGate(): PolicyGate;
 declare function resolveApplicationConfig(): import("../contracts/container").ConfigStoreLike;
 declare function resolveApplicationLogger(): Logger;
 declare function resolveApplicationDependencies(): import("../contracts/di").AppDependencies;
-export { resolveApplicationAuth, resolveApplicationCache, resolveApplicationConfig, resolveApplicationDependencies, resolveApplicationEventBus, resolveApplicationLogger, resolveApplicationPolicyGate, resolveApplicationQueue, setActiveApplicationContext, };
+export { clearActiveApplicationContext, resolveApplicationAuth, resolveApplicationCache, resolveApplicationConfig, resolveApplicationDependencies, resolveApplicationEventBus, resolveApplicationLogger, resolveApplicationPolicyGate, resolveApplicationQueue, setActiveApplicationContext, };

package/dist/core/runtime/boundedThrottleStore.d.ts

@@ -0,0 +1,29 @@
+interface MemoryThrottleStorageOptions {
+    /** Maximum live identities retained per middleware instance. */
+    maxBuckets?: number;
+    /** Maximum expired entries removed on each attempt. */
+    pruneBatchSize?: number;
+}
+interface MemoryThrottleStats {
+    readonly retainedBuckets: number;
+    readonly prunedOnLastConsume: number;
+    readonly disposed: boolean;
+}
+/** Fixed-window insertion order also orders expiry; hits never refresh a window. */
+declare class BoundedThrottleStore {
+    private readonly decayMs;
+    private readonly now;
+    private readonly buckets;
+    private readonly maxBuckets;
+    private readonly pruneBatchSize;
+    private disposed;
+    private pruned;
+    constructor(decayMs: number, options?: MemoryThrottleStorageOptions, now?: () => number);
+    /** null means closed or saturated: callers must fail closed, never evict live buckets. */
+    consume(key: string): number | null;
+    clear(): void;
+    dispose(): void;
+    stats(): MemoryThrottleStats;
+}
+export type { MemoryThrottleStats, MemoryThrottleStorageOptions };
+export { BoundedThrottleStore };

package/dist/core/scheduler/leases.d.ts

@@ -0,0 +1,40 @@
+import { RedisClient } from "bun";
+type SchedulerLease = {
+    taskId: string;
+    occurrenceId: string;
+    token: string;
+};
+interface SchedulerLeaseStore {
+    acquire(lease: SchedulerLease, leaseMs: number): Promise<boolean>;
+    renew(lease: SchedulerLease, leaseMs: number): Promise<boolean>;
+    complete(lease: SchedulerLease, retentionMs: number): Promise<boolean>;
+    release(lease: SchedulerLease): Promise<void>;
+}
+declare class RedisSchedulerLeaseStore implements SchedulerLeaseStore {
+    private readonly client;
+    private readonly owned?;
+    private readonly namespace;
+    private readonly timeoutMs;
+    constructor(options: {
+        redisUrl: string;
+        namespace: string;
+        commandTimeoutMs?: number;
+        client?: Pick<RedisClient, "send">;
+    });
+    private keys;
+    private execute;
+    acquire(lease: SchedulerLease, leaseMs: number): Promise<boolean>;
+    renew(lease: SchedulerLease, leaseMs: number): Promise<boolean>;
+    complete(lease: SchedulerLease, retentionMs: number): Promise<boolean>;
+    release(lease: SchedulerLease): Promise<void>;
+    close(): void;
+}
+declare class SingleRunnerLeaseStore implements SchedulerLeaseStore {
+    private readonly tasks;
+    acquire(lease: SchedulerLease, leaseMs: number): Promise<boolean>;
+    renew(lease: SchedulerLease, leaseMs: number): Promise<boolean>;
+    complete(lease: SchedulerLease): Promise<boolean>;
+    release(lease: SchedulerLease): Promise<void>;
+}
+export type { SchedulerLease, SchedulerLeaseStore };
+export { RedisSchedulerLeaseStore, SingleRunnerLeaseStore };

package/dist/core/scheduler/schedule.d.ts

@@ -1,15 +1,39 @@
+import { RedisSchedulerLeaseStore, type SchedulerLeaseStore } from "./leases";
+type ScheduledTaskContext = {
+    taskName: string;
+    occurrenceId: string;
+    scheduledAt: Date;
+    /** Aborted on loss/uncertainty of lease ownership, not normal admission shutdown. */
+    signal: AbortSignal;
+    assertOwnership(): Promise<void>;
+};
 type ScheduledTask = {
     expression: string;
     name: string;
-    run: () => void | Promise<void>;
+    run: (context: ScheduledTaskContext) => void | Promise<void>;
+};
+type SchedulerRunOptions = {
+    signal?: AbortSignal;
+    coordination?: "redis" | "single-runner";
+    redisUrl?: string;
+    namespace?: string;
+    leaseStore?: SchedulerLeaseStore;
+    leaseMs?: number;
+    renewalMs?: number;
+    commandTimeoutMs?: number;
+    completedRetentionMs?: number;
 };
+declare class SchedulerLeaseLostError extends Error {
+    constructor(taskName: string, options?: ErrorOptions);
+}
 declare class Schedule {
     private readonly tasks;
-    command(expression: string, name: string, run: () => void | Promise<void>): this;
+    command(expression: string, name: string, run: ScheduledTask["run"]): this;
     dueTasks(now?: Date): ScheduledTask[];
     tasksList(): ScheduledTask[];
 }
 declare const appSchedule: Schedule;
-declare function runDueScheduledTasks(schedule?: Schedule, now?: Date): Promise<number>;
-export type { ScheduledTask };
-export { appSchedule, runDueScheduledTasks, Schedule };
+declare function runDueScheduledTasks(schedule?: Schedule, now?: Date, options?: SchedulerRunOptions): Promise<number>;
+export type { SchedulerLease, SchedulerLeaseStore } from "./leases";
+export type { ScheduledTask, ScheduledTaskContext, SchedulerRunOptions };
+export { appSchedule, RedisSchedulerLeaseStore, runDueScheduledTasks, Schedule, SchedulerLeaseLostError, };

package/dist/core/tenant/publicTenantHost.d.ts

@@ -0,0 +1,11 @@
+interface PublicTenancyOptions {
+    /** Application-owned lookup of approved normalized hostnames; unknown hosts return null. */
+    resolveTenantId(hostname: string): Promise<number | null>;
+    /** Exact immediate socket-peer IP addresses. The proxy must overwrite X-Forwarded-Host. */
+    trustedProxyAddresses?: readonly string[];
+}
+/** Normalize an HTTP authority for approved-domain storage and lookup, without its port. */
+declare function normalizeTenantHostname(authority: string): string;
+declare function createPublicTenantSelector(options: PublicTenancyOptions): (request: Request) => Promise<number>;
+export type { PublicTenancyOptions };
+export { createPublicTenantSelector, normalizeTenantHostname };

package/dist/core/tenant/tenantContext.d.ts

@@ -1,13 +1,14 @@
 type TenantContext = {
     id: number;
     slug: string;
-    plan: "free" | "pro" | "enterprise";
-    region: "eu" | "us" | "apac";
+    /** Trusted application data; never inferred from request headers. */
+    metadata?: Readonly<Record<string, unknown>>;
+    /** Existing application extensions remain opaque to core. */
+    [key: string]: unknown;
 };
 declare const tenantContext: import("node:async_hooks").AsyncLocalStorage<TenantContext>;
 declare function runWithTenant<T>(tenant: TenantContext, callback: () => T | Promise<T>): T | Promise<T>;
 declare function currentTenant(): TenantContext | null;
 declare function currentTenantId(): number;
-declare function rateLimitMultiplierForPlan(plan: TenantContext["plan"]): number;
 export type { TenantContext };
-export { currentTenant, currentTenantId, rateLimitMultiplierForPlan, runWithTenant, tenantContext };
+export { currentTenant, currentTenantId, runWithTenant, tenantContext };

package/dist/core/tenant/tenantMiddleware.d.ts

@@ -1,6 +1,16 @@
+import { type PublicTenancyOptions } from "./publicTenantHost";
 import { type TenantContext } from "./tenantContext";
 declare const DEFAULT_TENANT: TenantContext;
 declare function resolveUserTenantId(userId: number): Promise<number>;
 declare function auditChecksum(payload: Record<string, unknown>): string;
-declare function createTenantMiddleware(): (request: Request, next: () => Promise<Response>) => Promise<Response>;
+type TenantResolver = (id: number) => Promise<TenantContext | null>;
+interface TenantMiddlewareOptions {
+    /** Load trusted application metadata after the framework selects the tenant ID. */
+    resolveTenant?: TenantResolver;
+    publicTenancy?: PublicTenancyOptions;
+}
+declare function createTenantMiddleware(options?: TenantMiddlewareOptions): (request: Request, next: () => Promise<Response>) => Promise<Response>;
+export type { PublicTenancyOptions } from "./publicTenantHost";
+export { normalizeTenantHostname } from "./publicTenantHost";
+export type { TenantMiddlewareOptions, TenantResolver };
 export { auditChecksum, createTenantMiddleware, DEFAULT_TENANT, resolveUserTenantId };

package/dist/core/tracing/otel.d.ts

@@ -1,26 +1,28 @@
-interface OtelSpan {
-    traceId: string;
-    spanId: string;
-    name: string;
-    startTimeUnixNano: string;
-    endTimeUnixNano: string;
-    attributes: Array<{
-        key: string;
-        value: {
-            stringValue: string;
-        };
-    }>;
-    status: {
-        code: number;
-    };
-}
-declare function createSpan(input: {
-    traceId: string;
-    name: string;
-    startedAt: number;
-    endedAt: number;
-    attributes?: Record<string, string>;
-}): OtelSpan;
-declare function exportOtelSpan(span: OtelSpan): Promise<void>;
-export type { OtelSpan };
-export { createSpan, exportOtelSpan };
+import { type Context, type Tracer } from "@opentelemetry/api";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { type SpanExporter } from "@opentelemetry/sdk-trace-base";
+type TracingOptions = {
+    exporter?: SpanExporter;
+    endpoint?: string;
+    serviceName?: string;
+    sampleRatio?: number;
+    maxQueueSize?: number;
+    maxExportBatchSize?: number;
+    scheduledDelayMillis?: number;
+    exportTimeoutMillis?: number;
+};
+type TracingRuntime = {
+    tracer: Tracer;
+    propagator: W3CTraceContextPropagator;
+    run<T>(parent: Context, callback: () => T): T;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+};
+declare function createTracingRuntime(options?: TracingOptions): TracingRuntime;
+declare function getTracingRuntime(): TracingRuntime;
+declare function acquireTracingRuntime(): {
+    flush(): Promise<void>;
+    release(): Promise<void>;
+};
+export type { TracingOptions, TracingRuntime };
+export { acquireTracingRuntime, createTracingRuntime, getTracingRuntime };

package/dist/core/tracing/tracingMiddleware.d.ts

@@ -1,3 +1,6 @@
 import type { Middleware } from "@getstrata/core/http/middleware";
-declare function createTracingMiddleware(): Middleware;
+import { type TracingRuntime } from "./otel";
+declare function createTracingMiddleware(runtime?: TracingRuntime): Middleware;
+export type { TracingOptions, TracingRuntime } from "./otel";
+export { acquireTracingRuntime, createTracingRuntime, getTracingRuntime } from "./otel";
 export { createTracingMiddleware };

package/dist/entries/audit/exportAuditLogs.js

@@ -306,9 +306,12 @@ async function runWithDeferredModelEvents(callback) {
   const existing = deferredModelEvents.getStore();
   if (existing) {
     existing.frames.push([]);
+    existing.rollbackFrames.push([]);
     try {
       const result = await callback();
       const nested = existing.frames.pop() ?? [];
+      const rollback = existing.rollbackFrames.pop() ?? [];
+      existing.rollbackFrames.at(-1)?.push(...rollback);
       const parent = existing.frames[existing.frames.length - 1];
       if (parent) {
         parent.push(...nested);
@@ -316,11 +319,20 @@ async function runWithDeferredModelEvents(callback) {
       return result;
     } catch (error) {
       existing.frames.pop();
+      for (const rollback of (existing.rollbackFrames.pop() ?? []).reverse())
+        rollback();
       throw error;
     }
   }
-  const state = { frames: [[]] };
-  const result = await deferredModelEvents.run(state, callback);
+  const state = { frames: [[]], rollbackFrames: [[]] };
+  let result;
+  try {
+    result = await deferredModelEvents.run(state, callback);
+  } catch (error) {
+    for (const rollback of (state.rollbackFrames[0] ?? []).reverse())
+      rollback();
+    throw error;
+  }
   await dispatchQueuedModelEvents(state.frames[0] ?? []);
   return result;
 }