@getstrata/core 2.1.0 → 2.2.0

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;
 }

package/dist/entries/auth/basicAuthGuard.js

@@ -300,7 +300,87 @@ var init_dialect = __esm(() => {
   dialectContext = createAsyncContextStore("@getstrata/sqlDialect");
 });
 
+// ../../src/core/contracts/container.ts
+function createServiceToken(key) {
+  if (!key.trim())
+    throw new Error("Service token key must not be empty.");
+  return key;
+}
+
+class ServiceContainer {
+  services = new Map;
+  singletonFactories = new Map;
+  bindings = new Map;
+  set(key, value) {
+    this.singletonFactories.delete(key);
+    this.bindings.delete(key);
+    this.services.set(key, value);
+    return value;
+  }
+  singleton(key, factory) {
+    this.bindings.delete(key);
+    this.services.delete(key);
+    this.singletonFactories.set(key, factory);
+  }
+  bind(key, factory) {
+    this.singletonFactories.delete(key);
+    this.services.delete(key);
+    this.bindings.set(key, factory);
+  }
+  get(key) {
+    if (this.services.has(key)) {
+      return this.services.get(key);
+    }
+    const singletonFactory = this.singletonFactories.get(key);
+    if (singletonFactory) {
+      const value = singletonFactory(this);
+      this.services.set(key, value);
+      return value;
+    }
+    const binding = this.bindings.get(key);
+    if (binding) {
+      return binding(this);
+    }
+    throw new Error(`Service "${key}" is not registered.`);
+  }
+  resolve(key) {
+    return this.get(key);
+  }
+  make(key) {
+    return this.resolve(key);
+  }
+  instance(key, value) {
+    return this.set(key, value);
+  }
+  has(key) {
+    return this.services.has(key) || this.singletonFactories.has(key) || this.bindings.has(key);
+  }
+}
+
+class ConfigStore {
+  values = new Map;
+  set(key, value) {
+    this.values.set(key, value);
+    return value;
+  }
+  get(key) {
+    return this.values.get(key);
+  }
+  require(key) {
+    if (!this.values.has(key)) {
+      throw new Error(`Config key "${key}" is not defined.`);
+    }
+    return this.values.get(key);
+  }
+  has(key) {
+    return this.values.has(key);
+  }
+}
+
 // ../../src/core/contracts/serviceTokens.ts
+var CORE_THROTTLE_QUOTA_POLICY_TOKEN = createServiceToken("core.throttleQuotaPolicy");
+var CORE_TENANT_RESOLVER_TOKEN = createServiceToken("core.tenantResolver");
+var CORE_HTTP_CLEANUP_TOKEN = createServiceToken("core.httpCleanup");
 var CORE_CONFIG_TOKEN = "core.config";
 var CORE_CACHE_TOKEN = "core.cache";
 var CORE_QUEUE_TOKEN = "core.queue";

package/dist/entries/auth/jwtGuard.js

@@ -1,5 +1,85 @@
 // @bun
+// ../../src/core/contracts/container.ts
+function createServiceToken(key) {
+  if (!key.trim())
+    throw new Error("Service token key must not be empty.");
+  return key;
+}
+
+class ServiceContainer {
+  services = new Map;
+  singletonFactories = new Map;
+  bindings = new Map;
+  set(key, value) {
+    this.singletonFactories.delete(key);
+    this.bindings.delete(key);
+    this.services.set(key, value);
+    return value;
+  }
+  singleton(key, factory) {
+    this.bindings.delete(key);
+    this.services.delete(key);
+    this.singletonFactories.set(key, factory);
+  }
+  bind(key, factory) {
+    this.singletonFactories.delete(key);
+    this.services.delete(key);
+    this.bindings.set(key, factory);
+  }
+  get(key) {
+    if (this.services.has(key)) {
+      return this.services.get(key);
+    }
+    const singletonFactory = this.singletonFactories.get(key);
+    if (singletonFactory) {
+      const value = singletonFactory(this);
+      this.services.set(key, value);
+      return value;
+    }
+    const binding = this.bindings.get(key);
+    if (binding) {
+      return binding(this);
+    }
+    throw new Error(`Service "${key}" is not registered.`);
+  }
+  resolve(key) {
+    return this.get(key);
+  }
+  make(key) {
+    return this.resolve(key);
+  }
+  instance(key, value) {
+    return this.set(key, value);
+  }
+  has(key) {
+    return this.services.has(key) || this.singletonFactories.has(key) || this.bindings.has(key);
+  }
+}
+
+class ConfigStore {
+  values = new Map;
+  set(key, value) {
+    this.values.set(key, value);
+    return value;
+  }
+  get(key) {
+    return this.values.get(key);
+  }
+  require(key) {
+    if (!this.values.has(key)) {
+      throw new Error(`Config key "${key}" is not defined.`);
+    }
+    return this.values.get(key);
+  }
+  has(key) {
+    return this.values.has(key);
+  }
+}
+
 // ../../src/core/contracts/serviceTokens.ts
+var CORE_THROTTLE_QUOTA_POLICY_TOKEN = createServiceToken("core.throttleQuotaPolicy");
+var CORE_TENANT_RESOLVER_TOKEN = createServiceToken("core.tenantResolver");
+var CORE_HTTP_CLEANUP_TOKEN = createServiceToken("core.httpCleanup");
 var CORE_CONFIG_TOKEN = "core.config";
 var CORE_CACHE_TOKEN = "core.cache";
 var CORE_QUEUE_TOKEN = "core.queue";

package/dist/entries/auth/scimAuthMiddleware.js

@@ -262,9 +262,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);
@@ -272,11 +275,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;
 }
@@ -849,19 +861,17 @@ async function resolveTenant(tenantId) {
   if (!isTenancyEnabled()) {
     return {
       id: tenantId,
-      slug: "default",
-      plan: "free",
-      region: "eu"
+      slug: "default"
     };
   }
   const rows = await db`
-    SELECT id, slug, plan, region
+    SELECT id, slug
     FROM tenant
     WHERE id = ${tenantId}
     LIMIT 1
   `;
   const row = rows[0];
-  return row ? { id: row.id, slug: row.slug, plan: row.plan, region: row.region ?? "eu" } : null;
+  return row ? { id: row.id, slug: row.slug } : null;
 }
 
 // ../../src/core/auth/scimAuthMiddleware.ts

package/dist/entries/auth/sessionGuard.js

@@ -1,5 +1,85 @@
 // @bun
+// ../../src/core/contracts/container.ts
+function createServiceToken(key) {
+  if (!key.trim())
+    throw new Error("Service token key must not be empty.");
+  return key;
+}
+
+class ServiceContainer {
+  services = new Map;
+  singletonFactories = new Map;
+  bindings = new Map;
+  set(key, value) {
+    this.singletonFactories.delete(key);
+    this.bindings.delete(key);
+    this.services.set(key, value);
+    return value;
+  }
+  singleton(key, factory) {
+    this.bindings.delete(key);
+    this.services.delete(key);
+    this.singletonFactories.set(key, factory);
+  }
+  bind(key, factory) {
+    this.singletonFactories.delete(key);
+    this.services.delete(key);
+    this.bindings.set(key, factory);
+  }
+  get(key) {
+    if (this.services.has(key)) {
+      return this.services.get(key);
+    }
+    const singletonFactory = this.singletonFactories.get(key);
+    if (singletonFactory) {
+      const value = singletonFactory(this);
+      this.services.set(key, value);
+      return value;
+    }
+    const binding = this.bindings.get(key);
+    if (binding) {
+      return binding(this);
+    }
+    throw new Error(`Service "${key}" is not registered.`);
+  }
+  resolve(key) {
+    return this.get(key);
+  }
+  make(key) {
+    return this.resolve(key);
+  }
+  instance(key, value) {
+    return this.set(key, value);
+  }
+  has(key) {
+    return this.services.has(key) || this.singletonFactories.has(key) || this.bindings.has(key);
+  }
+}
+
+class ConfigStore {
+  values = new Map;
+  set(key, value) {
+    this.values.set(key, value);
+    return value;
+  }
+  get(key) {
+    return this.values.get(key);
+  }
+  require(key) {
+    if (!this.values.has(key)) {
+      throw new Error(`Config key "${key}" is not defined.`);
+    }
+    return this.values.get(key);
+  }
+  has(key) {
+    return this.values.has(key);
+  }
+}
+
 // ../../src/core/contracts/serviceTokens.ts
+var CORE_THROTTLE_QUOTA_POLICY_TOKEN = createServiceToken("core.throttleQuotaPolicy");
+var CORE_TENANT_RESOLVER_TOKEN = createServiceToken("core.tenantResolver");
+var CORE_HTTP_CLEANUP_TOKEN = createServiceToken("core.httpCleanup");
 var CORE_CONFIG_TOKEN = "core.config";
 var CORE_CACHE_TOKEN = "core.cache";
 var CORE_QUEUE_TOKEN = "core.queue";