@getstrata/core 2.0.9 → 2.2.0

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

@@ -1,3 +1,4 @@
+import type { WhereNode } from "./whereBuilder.ts";
 type DatabaseComparable = string | number | Date;
 type DatabaseScalar = DatabaseComparable | boolean | null;
 type QueryOperator = {
@@ -15,6 +16,27 @@ type QueryOperator = {
 };
 type QueryFilterValue = DatabaseScalar | readonly DatabaseScalar[] | QueryOperator;
 type QueryWhere<TEntity> = Partial<Record<keyof TEntity & string, QueryFilterValue>> & Partial<Record<string, QueryFilterValue>>;
+/** Ordinary model filters constrain keys and operators to their declared scalar values. */
+type ModelFilterScalar<T> = unknown extends T ? DatabaseScalar : Extract<T, DatabaseScalar>;
+type ModelFilterOperator<T> = {
+    eq?: ModelFilterScalar<T>;
+    ne?: ModelFilterScalar<T>;
+    in?: readonly ModelFilterScalar<T>[];
+    notIn?: readonly ModelFilterScalar<T>[];
+    gt?: Extract<ModelFilterScalar<T>, DatabaseComparable>;
+    gte?: Extract<ModelFilterScalar<T>, DatabaseComparable>;
+    lt?: Extract<ModelFilterScalar<T>, DatabaseComparable>;
+    lte?: Extract<ModelFilterScalar<T>, DatabaseComparable>;
+    isNull?: boolean;
+} & (Extract<T, string> extends never ? unknown : {
+    ilike?: string;
+    tsMatch?: string;
+});
+type ModelWhere<TEntity> = string extends keyof TEntity ? QueryWhere<TEntity> : {
+    [K in keyof TEntity & string]?: ModelFilterScalar<TEntity[K]> | readonly ModelFilterScalar<TEntity[K]>[] | ModelFilterOperator<TEntity[K]>;
+};
+/** Omission stays legal: DB defaults, generated columns and fillable/timestamp policy are runtime concerns. */
+type ModelWriteValues<TEntity> = Partial<TEntity>;
 type QueryOrder<TEntity> = {
     column: keyof TEntity & string;
     direction?: "ASC" | "DESC" | "asc" | "desc";
@@ -56,7 +78,8 @@ type QuerySelectItem = {
     query: string;
     as: string;
 };
-interface QueryOptions<TEntity> {
+interface QueryOptions<TEntity extends object> {
+    whereNodes?: WhereNode<TEntity>[];
     where?: QueryWhere<TEntity>;
     orderBy?: QueryOrder<TEntity> | QueryOrder<TEntity>[] | QueryOrderShorthand<TEntity>;
     limit?: number;
@@ -70,4 +93,4 @@ interface QueryOptions<TEntity> {
 }
 type MutationValues<TEntity> = Partial<TEntity>;
 type UpdateValues<TEntity, PrimaryKey extends keyof TEntity & string = keyof TEntity & string> = Partial<Omit<TEntity, PrimaryKey>>;
-export type { DatabaseComparable, DatabaseScalar, MutationValues, QueryFilterValue, QueryJoin, QueryJoinOn, QueryOperator, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, UpdateValues, };
+export type { DatabaseComparable, DatabaseScalar, ModelWhere, ModelWriteValues, MutationValues, QueryFilterValue, QueryJoin, QueryJoinOn, QueryOperator, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, UpdateValues, };

package/dist/core/database/whereBuilder.d.ts

@@ -14,12 +14,12 @@ type WhereNode<TEntity extends object> = {
     kind: "and" | "or";
     exists: ExistsClause;
 };
-declare class WhereBuilder<TEntity extends object> {
+declare class WhereBuilder<TEntity extends object, TWhere extends object = QueryWhere<TEntity>> {
     readonly nodes: WhereNode<TEntity>[];
-    where(where: QueryWhere<TEntity>): this;
-    orWhere(where: QueryWhere<TEntity>): this;
-    whereGroup(fn: (builder: WhereBuilder<TEntity>) => void): this;
-    orWhereGroup(fn: (builder: WhereBuilder<TEntity>) => void): this;
+    where(where: TWhere): this;
+    orWhere(where: TWhere): this;
+    whereGroup(fn: (builder: WhereBuilder<TEntity, TWhere>) => void): this;
+    orWhereGroup(fn: (builder: WhereBuilder<TEntity, TWhere>) => void): this;
 }
 export type { ExistsClause, WhereNode };
 export { WhereBuilder };

package/dist/core/events/deferredModelEvents.d.ts

@@ -1,3 +1,4 @@
 declare function dispatchModelEvent(event: string, payload: unknown): Promise<void>;
 declare function runWithDeferredModelEvents<T>(callback: () => T | Promise<T>): Promise<T>;
-export { dispatchModelEvent, runWithDeferredModelEvents };
+declare function onDeferredModelRollback(callback: () => void): void;
+export { dispatchModelEvent, onDeferredModelRollback, runWithDeferredModelEvents };

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

@@ -1,6 +1,7 @@
-import type { Middleware } from "./middleware";
-import { type RedisThrottleClient } from "./throttleMiddleware";
-interface LoginThrottleOptions {
+import { type MemoryThrottleStorageOptions } from "../runtime/boundedThrottleStore";
+import type { DisposableMemoryThrottle } from "./memoryThrottleMiddleware";
+import { type DisposableThrottle, type RedisThrottleClient } from "./throttleMiddleware";
+interface LoginThrottleOptions extends MemoryThrottleStorageOptions {
     redisUrl?: string;
     maxAttempts: number;
     decaySeconds: number;
@@ -10,8 +11,8 @@ interface LoginThrottleOptions {
 }
 declare function resolveLoginIdentity(request: Request): string;
 declare function resolveLoginEmail(request: Request): Promise<string>;
-declare function createMemoryLoginThrottleMiddleware(options: LoginThrottleOptions): Middleware;
-declare function createLoginThrottleMiddleware(options: LoginThrottleOptions): Middleware;
+declare function createMemoryLoginThrottleMiddleware(options: LoginThrottleOptions): DisposableMemoryThrottle;
+declare function createLoginThrottleMiddleware(options: LoginThrottleOptions): DisposableThrottle;
 declare function resetMemoryLoginThrottleForTests(): void;
 export type { LoginThrottleOptions };
 export { createLoginThrottleMiddleware, createMemoryLoginThrottleMiddleware, resetMemoryLoginThrottleForTests, resolveLoginEmail, resolveLoginIdentity, };

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

@@ -1,10 +1,18 @@
+import { type MemoryThrottleStats, type MemoryThrottleStorageOptions } from "../runtime/boundedThrottleStore";
 import type { Middleware } from "./middleware";
-interface MemoryThrottleOptions {
+import { type ThrottleQuotaPolicy } from "./throttleMiddleware";
+interface MemoryThrottleOptions extends MemoryThrottleStorageOptions {
     maxAttempts: number;
     decaySeconds: number;
     keyPrefix?: string;
+    quotaPolicy?: ThrottleQuotaPolicy;
 }
-declare function createMemoryThrottleMiddleware(options: MemoryThrottleOptions): Middleware;
+type DisposableMemoryThrottle = Middleware & {
+    dispose(): void;
+    stats(): MemoryThrottleStats;
+};
+declare function createMemoryThrottleMiddleware(options: MemoryThrottleOptions): DisposableMemoryThrottle;
+/** Lazy generation reset avoids retaining middleware instances in a global test registry. */
 declare function resetMemoryThrottleForTests(): void;
-export type { MemoryThrottleOptions };
+export type { DisposableMemoryThrottle, MemoryThrottleOptions, MemoryThrottleStats, MemoryThrottleStorageOptions, };
 export { createMemoryThrottleMiddleware, resetMemoryThrottleForTests };

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

@@ -1,6 +1,6 @@
 type Middleware = (request: Request, next: () => Promise<Response>) => Promise<Response>;
-type RouteHandler = (request: Request) => Response | Promise<Response>;
-declare function composeMiddleware(...middleware: Middleware[]): (handler: RouteHandler) => RouteHandler;
+type RouteHandler<TRequest extends Request = Request> = (request: TRequest) => Response | Promise<Response>;
+declare function composeMiddleware(...middleware: Middleware[]): <TRequest extends Request = Request>(handler: RouteHandler<TRequest>) => RouteHandler<TRequest>;
 declare function requestIdMiddleware(request: Request, next: () => Promise<Response>): Promise<Response>;
 declare function wrapRouteHandler<T>(handler: T, middleware: Middleware[]): T;
 declare function applyMiddlewareToRoutes<T extends Record<string, unknown>>(routes: T, middleware: Middleware[]): T;

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

@@ -3,7 +3,9 @@ declare function jsonResponse(data: unknown, init?: ResponseInit): Response;
 declare function createdResponse(data: unknown, init?: ResponseInit): Response;
 declare function noContentResponse(): Response;
 declare function errorResponse(error: unknown): Response;
+declare function withErrorHandling<THandler extends (request: Request) => Response | Promise<Response>>(handler: THandler): (...args: Parameters<THandler>) => Promise<Response>;
 declare function withErrorHandling<TArgs extends unknown[]>(handler: (...args: TArgs) => Response | Promise<Response>): (...args: TArgs) => Promise<Response>;
+declare function withJsonErrorHandling<THandler extends (request: Request) => Response | Promise<Response>>(handler: THandler): (...args: Parameters<THandler>) => Promise<Response>;
 declare function withJsonErrorHandling<TArgs extends unknown[]>(handler: (...args: TArgs) => Response | Promise<Response>): (...args: TArgs) => Promise<Response>;
 declare function createJsonErrorMiddleware(): Middleware;
 declare function createWebErrorMiddleware(): Middleware;

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

@@ -1,3 +1,4 @@
-import { type Middleware, type RouteHandler } from "./middleware";
-declare function withMiddleware(...middleware: Middleware[]): (handler: RouteHandler) => RouteHandler;
+import { type Middleware } from "./middleware";
+/** Middleware consumes native Request; composition preserves the handler's request subtype. */
+declare function withMiddleware(...middleware: Middleware[]): <TRequest extends Request = Request>(handler: import("./middleware").RouteHandler<TRequest>) => import("./middleware").RouteHandler<TRequest>;
 export { withMiddleware };

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

@@ -1,9 +1,18 @@
+import { type MemoryThrottleStorageOptions } from "../runtime/boundedThrottleStore";
 import type { Middleware } from "./middleware";
-interface ScimThrottleOptions {
+import { type RedisThrottleClient } from "./throttleMiddleware";
+interface ScimThrottleOptions extends MemoryThrottleStorageOptions {
     redisUrl?: string;
     maxAttempts: number;
     decaySeconds: number;
+    commandTimeoutMs?: number;
+    redisClient?: RedisThrottleClient;
+    keyPrefix?: string;
 }
-declare function createScimThrottleMiddleware(options: ScimThrottleOptions): Middleware;
+declare function resolveScimIdentity(request: Request): string;
+declare function createScimThrottleMiddleware(options: ScimThrottleOptions): Middleware & {
+    dispose: () => void;
+    stats: () => import("./memoryThrottleMiddleware").MemoryThrottleStats | undefined;
+};
 export type { ScimThrottleOptions };
-export { createScimThrottleMiddleware };
+export { createScimThrottleMiddleware, resolveScimIdentity };

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/index.d.ts

@@ -8,13 +8,20 @@ declare abstract class Job<TPayload extends object = object> {
     abstract handle(payload: TPayload): Promise<void>;
 }
 interface Queue {
+    close?(): void | 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 };

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

@@ -23,6 +23,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 {

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/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/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

@@ -2,5 +2,11 @@ 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;
+}
+declare function createTenantMiddleware(options?: TenantMiddlewareOptions): (request: Request, next: () => Promise<Response>) => Promise<Response>;
+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;
 }