@luckystack/core 0.10.1 → 0.11.0

package/dist/index.d.ts

@@ -1,1886 +1,110 @@
-import { _ as ErrorParam, $ as ErrorResponseInput, a0 as NormalizedErrorResponse } from './pageRouteValidation-B4Cmtfjv.js';
-export { A as ApiMethodMap, D as DEFAULT_PAGE_ROUTE_RULES, H as HttpMethodLiteral, a1 as INVALID_ERROR_RESPONSE_CODE, L as Logger, a as LoggerContext, N as Notifier, b as NotifyInput, c as NotifyParam, P as PagePathValidationResult, d as PageRouteRules, a2 as QueueDropReason, R as ROUTED_DATA_QUERY_KEY, S as SOCKETSTATUS, a3 as ServiceRouteParseError, a4 as ServiceRouteParseResult, a5 as ServiceRouteParseSuccess, a6 as TransportRouteParseError, a7 as TransportRouteParseResult, a8 as TransportRouteParseSuccess, e as buildApiResponseEventName, f as buildApiStreamEventName, g as buildGetJoinedRoomsResponseEventName, h as buildJoinRoomResponseEventName, i as buildLeaveRoomResponseEventName, j as buildRoutedGetUrl, k as buildSyncProgressEventName, l as buildSyncResponseEventName, m as clearCsrfToken, a9 as createDevLogger, aa as defaultHttpStatusForResponse, n as enqueueApiRequest, o as enqueueSyncRequest, p as flushApiQueue, q as flushSyncQueue, r as getApiQueueSize, s as getCsrfToken, t as getLogger, u as getNotifier, v as getRegisteredApiMethod, w as getSyncQueueSize, x as httpFetch, y as incrementResponseIndex, z as isApiMethodMapRegistered, ab as isErrorParamArray, ac as isLoggerRegistered, B as isOnline, C as normalizeErrorResponseCore, E as notify, F as parseServiceRouteName, ad as parseTransportRouteName, G as registerApiMethodMap, I as registerLogger, J as registerNotifier, K as removeApiQueueItem, M as removeApiQueueItemsByKey, O as removeSyncQueueItem, ae as resetLoggerForTests, Q as setSocket, T as sleep, U as socket, V as socketEventNames, W as statusContent, X as tryCatchSync, Y as validatePagePath, Z as waitForSocket } from './pageRouteValidation-B4Cmtfjv.js';
-import { H as HealthHashConfig, D as DeepPartial, B as BaseSessionLayout, a as AuthProps } from './sessionTypes-DanjuPaE.js';
-export { c as ApiConfig, A as AppConfig, d as AuthConfig, e as AuthRateLimitConfig, C as CorsConfig, f as DEFAULT_PROJECT_CONFIG, h as DevConfig, j as HttpConfig, k as HttpStreamConfig, J as Jsonify, L as LoggingConfig, O as OfflineQueueConfig, l as PasswordPolicyConfig, m as PathsConfig, P as ProjectConfig, n as ProjectConfigInput, o as RateLimitIdentity, p as RateLimitIdentityParams, R as RateLimitingConfig, q as SecurityHeadersConfig, S as SessionConfig, b as SessionLocation, s as SocketConfig, t as SyncConfig, u as SyncFlushPressureConfig, v as SyncStreamThrottleConfig, V as ValidationConfig, w as deepMerge, g as getProjectConfig, x as getProjectName, y as isPlainObject, i as isProjectConfigRegistered, r as registerProjectConfig } from './sessionTypes-DanjuPaE.js';
-export { ApiTypeMap, StreamPayload, SyncTypeMap } from './apiTypeStubs.js';
-import { Server, Socket } from 'socket.io';
-export { D as DeployConfigShape, a as DeployDevelopmentShape, b as DeployEnvironmentShape, c as DeployResourceShape, d as DeployRoutingShape, P as PresetDefinition, S as SecretsResolvedListener, e as ServiceDefinition, f as ServicesConfigShape, g as getDeployConfig, h as getPortOverride, i as getServicesConfig, j as isDeployConfigRegistered, k as isServicesConfigRegistered, n as notifySecretsResolved, r as registerDeployConfig, l as registerPortOverride, m as registerSecretsResolvedListener, o as registerServicesConfig, p as resetPortOverrideForTests } from './config-CwW3KY9r.js';
-import { z } from 'zod';
-import * as _prisma_client_runtime_library from '@prisma/client/runtime/library';
-import * as _prisma_client from '@prisma/client';
-import { PrismaClient } from '@prisma/client';
-import Redis$1, { Redis } from 'ioredis';
-import { RedisAdapterOptions } from '@socket.io/redis-adapter';
-import { ServerResponse, IncomingMessage, IncomingHttpHeaders } from 'node:http';
-import 'socket.io-client';
-
-declare function tryCatch<T, P = void>(func: (values: P) => Promise<T> | T, params?: P, context?: Record<string, unknown>): Promise<[Error | null, T | null]>;
-
-type RequireTransform<TInput, TStored> = [TInput] extends [TStored] ? {
-    transform?: (input: TInput, current: TStored) => TStored;
-} : {
-    transform: (input: TInput, current: TStored) => TStored;
-};
-interface RegistryOptionsBase<TStored> {
-    /**
-     * Called once per `register` with the freshly-stored value — used for the
-     * rate-limiter's `[RateLimiter] active strategy → …` debug line. Runs after
-     * the slot is updated so a logger registry can log through itself.
-     */
-    onRegister?: (stored: TStored) => void;
-    /**
-     * Resolve the value `get` returns when nothing has been registered yet.
-     * Defaults to returning `defaultValue`. `servicesConfig` throws here.
-     */
-    resolveDefault?: () => TStored;
-}
-type RegistryOptions<TInput, TStored> = RegistryOptionsBase<TStored> & RequireTransform<TInput, TStored>;
-interface Registry<TInput, TStored> {
-    /** Store a value (after the optional `transform`) and mark the slot registered. */
-    register: (input: TInput) => TStored;
-    /** Read the active value at call time (registered value, else the default). */
-    get: () => TStored;
-    /** True once `register` has been called at least once. */
-    isRegistered: () => boolean;
-    /** Restore the unregistered state (test-only). */
-    reset: () => void;
-}
-/**
- * Create a single-slot registry. `defaultValue` is returned by `get` until
- * `register` is called (unless `resolveDefault` overrides that). When
- * `TInput` differs from `TStored`, the `transform` option is mandatory (the
- * `RequireTransform` constraint enforces it); when they match it is optional
- * and defaults to identity. The second positional argument is likewise
- * optional only in the identity case.
- */
-declare function createRegistry<TStored, TInput = TStored>(defaultValue: TStored, ...optionsArg: [TInput] extends [TStored] ? [options?: RegistryOptions<TInput, TStored>] : [options: RegistryOptions<TInput, TStored>]): Registry<TInput, TStored>;
-
-/**
- * Escape `&`, `<`, `>`, `"`, `'` for safe interpolation into HTML text nodes
- * and quoted attribute values. Does NOT protect against CSS/JS/URL-context
- * injection — use a dedicated sanitizer for those contexts.
- */
-declare const escapeHtml: (str: string) => string;
-
-/** Minimal shape of a Node `require` with the `.resolve` member these guards use. */
-interface PeerRequire {
-    (id: string): unknown;
-    resolve: (id: string) => string;
-}
-/**
- * Assert that an optional peer package is installed, throwing a consistent,
- * actionable error when it is not. Does NOT load the module — use `loadPeer`
- * for that. Pass `requireFn` (a `createRequire(import.meta.url)` from the
- * calling adapter) so resolution happens from the consumer's perspective.
- *
- * `hint` is appended to the standard "package X is not installed" sentence —
- * e.g. `'Run `npm install resend`, or pick a different EmailSender adapter.'`.
- */
-declare const ensurePeerDepInstalled: (packageName: string, hint: string, requireFn?: PeerRequire) => void;
-/**
- * Synchronously load an optional peer package, asserting it is installed
- * first (so a missing dependency fails with the actionable `hint` rather than
- * a raw `MODULE_NOT_FOUND`). Returns the module typed as `T`. Pass `requireFn`
- * (built with `createRequire(import.meta.url)` at the call site) so resolution
- * + load happen relative to the calling module.
- */
-declare const loadPeer: <T>(packageName: string, hint: string, requireFn?: PeerRequire) => T;
-
-/** Matches `<name>.test|tests|spec.<ts|tsx|js|jsx|mts|cts|mjs|cjs>`. */
-declare const TEST_FILE_PATTERN: RegExp;
-/** Directory names that conventionally hold tests and never runtime modules. */
-declare const TEST_DIRECTORY_NAMES: Set<string>;
-/**
- * True when the given file name (or path — only the last segment is examined)
- * is a test file by the conventions above.
- */
-declare const isTestFile: (fileNameOrPath: string) => boolean;
-/** True when a directory name conventionally holds tests rather than runtime modules. */
-declare const isTestDirectory: (directoryName: string) => boolean;
-
-interface RoomNameFormatterContext {
-    /**
-     * Which room FAMILY the name is being formatted for — a formatter may branch on
-     * this to isolate genuinely-separate families, but MUST NOT use it to give the
-     * same raw room code different physical names across a single family's
-     * operations. A content room is joined, left, membership-checked, broadcast to,
-     * and streamed to under the SINGLE canonical `'broadcast'` purpose (M5); the
-     * framework never varies a content room's physical name by operation, because a
-     * socket physically IN `f(R,'join')` could never receive a fanout targeting
-     * `f(R,'broadcast')`. `'presence'` is the one genuinely-separate family (its own
-     * rooms). `'join'`/`'leave'` remain in the union for backward-compat but the
-     * framework no longer emits them for room-NAME formatting — treat them, if ever
-     * seen, identically to `'broadcast'`.
-     */
-    purpose: 'join' | 'leave' | 'broadcast' | 'presence';
-    /**
-     * Session user id of whoever is performing THIS operation, when known, else
-     * null — CONTEXT ONLY. For a shared content room under `'broadcast'` the
-     * framework passes the joiner on join/rejoin, the SENDER on fan-out and the
-     * originator on `broadcastStream`, so the value differs per call for the SAME
-     * room. A formatter must therefore never fold `userId` into a content room's
-     * physical name: join and fan-out would resolve to different rooms and every
-     * broadcast would reach nobody, silently. Per-user isolation belongs in the
-     * raw room code the consumer chooses, or in the separate `'presence'` family.
-     */
-    userId?: string | null;
-}
-type RoomNameFormatter = (rawRoomName: string, ctx: RoomNameFormatterContext) => string;
-/** Override how every framework room name is namespaced (multi-tenant prefixing). */
-declare const registerRoomNameFormatter: (formatter: RoomNameFormatter) => void;
-/** Read the active formatter (defaults to identity). */
-declare const getRoomNameFormatter: () => RoomNameFormatter;
-/** Apply the active formatter — the single helper framework room-sites call. */
-declare const formatRoomName: (rawRoomName: string, ctx: RoomNameFormatterContext) => string;
-/** The built-in identity formatter (exported for tests / explicit reset). */
-declare const defaultRoomNameFormatter: RoomNameFormatter;
-
-type LanguageCode = string;
-interface TranslateInput {
-    language: LanguageCode;
-    key: string;
-    params?: ErrorParam[];
-}
-type TranslateFunction = (input: TranslateInput) => string;
-interface NormalizeErrorResponseInput {
-    response: ErrorResponseInput;
-    preferredLocale?: string | null;
-    userLanguage?: string | null;
-    fallbackHttpStatus?: number;
-}
-interface LocalizedNormalizer {
-    normalizeErrorResponse: (input: NormalizeErrorResponseInput) => NormalizedErrorResponse;
-    resolveErrorMessage: (input: {
-        errorCode: string;
-        errorParams?: ErrorParam[];
-        preferredLocale?: string | null;
-        userLanguage?: string | null;
-    }) => string;
-    extractLanguageFromHeader: (header?: string | string[]) => LanguageCode | null;
-}
-interface CreateLocalizedNormalizerInput {
-    translate: TranslateFunction;
-    /**
-     * Language the framework falls back to when the caller provides no
-     * language hints. Defaults to 'en'.
-     */
-    defaultLanguage?: LanguageCode;
-    /**
-     * Decide whether a given string is an acceptable language code. Defaults
-     * to accepting any non-empty short-form code (ISO 639-1 style). Projects
-     * that only support a closed set should pass a narrower predicate.
-     */
-    isSupportedLanguage?: (code: string) => boolean;
-}
-declare const createLocalizedNormalizer: (input: CreateLocalizedNormalizerInput) => LocalizedNormalizer;
-declare const registerLocalizedNormalizer: (normalizer: LocalizedNormalizer) => void;
-declare const getLocalizedNormalizer: () => LocalizedNormalizer;
-declare const isLocalizedNormalizerRegistered: () => boolean;
-declare const normalizeErrorResponse: (input: NormalizeErrorResponseInput) => NormalizedErrorResponse;
-declare const resolveErrorMessage: (input: {
-    errorCode: string;
-    errorParams?: ErrorParam[];
-    preferredLocale?: string | null;
-    userLanguage?: string | null;
-}) => string;
-declare const extractLanguageFromHeader: (header?: string | string[]) => LanguageCode | null;
-
-interface ErrorFormatterContext {
-    /** Resolved route name (`api/billing/getInvoice/v1`, `sync/...`). */
-    routeName: string;
-    /** Transport that triggered the error. */
-    transport: 'socket' | 'http';
-    /** Session id when available. */
-    userId?: string | null;
-}
-/** The normalized error envelope handed to every formatter. */
-interface FormatterErrorEnvelope {
-    status: 'error';
-    errorCode?: string;
-    message?: string;
-    httpStatus?: number;
-    [key: string]: unknown;
-}
-type ErrorFormatter = (error: FormatterErrorEnvelope, ctx: ErrorFormatterContext) => Record<string, unknown>;
-/**
- * Minimal structural contract every formatter-eligible envelope satisfies:
- * a discriminant `status` plus an open string-index so formatters can read /
- * add arbitrary fields. Generic helpers below constrain to this so transport
- * handlers no longer need `as unknown as` double-casts at the formatter
- * boundary — see `applyErrorFormatter` / `buildFormattedError`.
- */
-interface FormatterEnvelope {
-    status?: string;
-    [key: string]: unknown;
-}
-/**
- * Register a global error-response formatter. Receives the normalized
- * error envelope + context; return a (possibly extended) object that the
- * framework will emit. Pass `null` to unregister.
- *
- * For per-endpoint overrides, export `errorFormatter` from your
- * `_api/foo_v1.ts` file directly — the api/sync handler imports + invokes
- * it through `applyErrorFormatter`.
- */
-declare const registerErrorFormatter: (formatter: ErrorFormatter | null) => void;
-/** Read the active global formatter (or null). */
-declare const getErrorFormatter: () => ErrorFormatter | null;
-/**
- * Apply per-route → global → identity formatter chain to a normalized
- * error envelope. Returns the envelope unchanged when `status !== 'error'`
- * so it's safe to wrap every emit call. Errors thrown inside a formatter
- * are caught and logged; the un-formatted envelope is returned in that
- * case to keep the error path crash-resistant.
- */
-declare const applyErrorFormatter: <T extends FormatterEnvelope>(input: {
-    response: T;
-    routeName: string;
-    transport: "socket" | "http";
-    userId?: string | null;
-    perRouteFormatter?: ErrorFormatter | undefined | null;
-}) => T;
-
-interface apiMessage {
-    name: string;
-    data: object;
-    responseIndex: number;
-}
-interface syncMessage {
-    name: string;
-    data: object;
-    cb: string;
-    receiver: string;
-    responseIndex?: number;
-    ignoreSelf?: boolean;
-}
-declare const setIoInstance: (io: Server | null) => void;
-interface GetIoInstanceOptions {
-    /**
-     * Return the raw Socket.io server even outside production. Reach for this
-     * ONLY when the per-instance view is what you want (backpressure sampling, a
-     * sweep cleaning up this process's own connections) — and say why in a
-     * comment, because the lint rule `luckystack/no-local-socket-enumeration`
-     * will still flag the access.
-     */
-    raw?: boolean;
-}
-/**
- * Read the running Socket.io server. Outside production the returned value is
- * a guarded view that THROWS on the per-instance surfaces
- * (`sockets.adapter.rooms`, `sockets.adapter.sids`, enumerating
- * `sockets.sockets`) — see `localSocketEnumerationGuard.ts` for why. Pass
- * `{ raw: true }` for the unwrapped server. In production the raw server is
- * always returned; the guard costs nothing there.
- */
-declare const getIoInstance: (options?: GetIoInstanceOptions) => Server | null;
-
-/** Thrown (outside production) when consumer code touches a per-instance socket map. */
-declare class LocalSocketEnumerationError extends Error {
-    constructor(surface: string);
-}
-
-/** A recipient as returned by Socket.io's adapter-aware `fetchSockets()`. */
-type RoomSocket = Awaited<ReturnType<Server['fetchSockets']>>[number];
-interface GetRoomSocketsOptions {
-    /**
-     * User id forwarded to the room-name formatter as CONTEXT. Leave it out (or
-     * pass `null`) for a shared room — the formatter contract forbids folding it
-     * into a content room's physical name, so it only matters to a formatter that
-     * logs or branches on it.
-     */
-    userId?: string | null;
-}
-/**
- * Resolve every socket currently in `room`, on EVERY instance sharing the
- * Redis adapter. `room` is the LOGICAL code (what the client joined); it is
- * routed through the registered room-name formatter under the canonical
- * `'broadcast'` purpose exactly like the sync fan-out. The `'all'` sentinel
- * returns every connected socket everywhere.
- *
- * Throws when no Socket.io server is registered: a silent `[]` is precisely the
- * failure class this helper exists to remove.
- */
-declare const getRoomSockets: (room: string, options?: GetRoomSocketsOptions) => Promise<RoomSocket[]>;
-
-type RuntimeMapRecord = Record<string, unknown>;
-interface RuntimeApiMapsResult {
-    apisObject: RuntimeMapRecord;
-    functionsObject: RuntimeMapRecord;
-}
-interface RuntimeSyncMapsResult {
-    syncObject: RuntimeMapRecord;
-    functionsObject: RuntimeMapRecord;
-}
-interface RuntimeMapsProvider {
-    getRuntimeApiMaps: () => Promise<RuntimeApiMapsResult>;
-    getRuntimeSyncMaps: () => Promise<RuntimeSyncMapsResult>;
-}
-declare const registerRuntimeMapsProvider: (provider: RuntimeMapsProvider) => void;
-declare const isRuntimeMapsProviderRegistered: () => boolean;
-declare const getRuntimeApiMaps: () => Promise<RuntimeApiMapsResult>;
-declare const getRuntimeSyncMaps: () => Promise<RuntimeSyncMapsResult>;
-
-/**
- * A single email attachment (email F2). Adapters (Resend, SMTP/Nodemailer, SES)
- * thread these into their provider payload. `content` is the raw bytes
- * (`Buffer`/`Uint8Array`) or a base64 string; provide a `path`/`href` instead
- * for adapters that fetch externally. Shapes are intentionally permissive so a
- * single attachment object works across providers — each adapter maps the
- * fields it supports.
- */
-interface EmailAttachment {
-    /** File name shown to the recipient (e.g. `invoice.pdf`). */
-    filename: string;
-    /** Inline bytes or base64 string. Mutually exclusive with `path`/`href`. */
-    content?: Buffer | Uint8Array | string;
-    /**
-     * Local file path the adapter reads (when it supports path-based sends).
-     *
-     * @security Trusted-input field — do NOT derive from client-supplied data
-     * without validation. Framework-level path-traversal or safe-directory checks
-     * are NOT applied automatically; callers must reject paths that escape the
-     * intended directory (e.g. containing `..` or absolute paths outside a known
-     * root) before passing them here.
-     */
-    path?: string;
-    /**
-     * Remote URL the adapter fetches (when it supports href-based sends).
-     *
-     * @security Trusted-input field — do NOT derive from client-supplied data
-     * without validation. Only `https:` and `http:` URLs are safe for
-     * framework-internal use; arbitrary schemes (e.g. `file:`, `data:`) may be
-     * forwarded to nodemailer/Resend without restriction. Validate against an
-     * allowlist before passing here.
-     */
-    href?: string;
-    /** MIME type (e.g. `application/pdf`). Adapter may infer from `filename` if omitted. */
-    contentType?: string;
-    /** `Content-ID` for inline/embedded images referenced by `cid:` in the HTML. */
-    cid?: string;
-}
-interface EmailMessage {
-    to: string | string[];
-    subject: string;
-    html: string;
-    text?: string;
-    from?: string;
-    replyTo?: string;
-    cc?: string | string[];
-    bcc?: string | string[];
-    /**
-     * File attachments (email F2). Owned by core (not `@luckystack/email`) so the
-     * type is the single source of truth across the framework and every adapter;
-     * adapters thread these into their provider's attachment payload. Optional —
-     * a message without attachments behaves exactly as before.
-     */
-    attachments?: EmailAttachment[];
-    /**
-     * Custom message headers (email F2) — e.g. `X-Entity-Ref-ID`,
-     * `List-Unsubscribe`, idempotency keys. Adapters merge these over the headers
-     * they set themselves (adapter-reserved headers win to avoid breaking
-     * delivery). Optional.
-     *
-     * @security CR and LF characters in header keys or values enable SMTP header
-     * injection. `sendEmail` strips `\r` and `\n` from every key and value before
-     * passing them to the adapter (EMAIL-O7). Do NOT derive keys or values from
-     * unsanitized client input.
-     */
-    headers?: Record<string, string>;
-}
-type EmailDeliveryOutcome = 'not-sent' | 'unknown';
-type EmailResult = {
-    ok: true;
-    id: string;
-} | {
-    ok: false;
-    reason: string;
-    cause?: unknown;
-    /**
-     * `unknown` means the caller stopped waiting after dispatch began; retry
-     * only with the same idempotency key. Omitted on legacy/provider failures
-     * whose delivery semantics are adapter-specific.
-     */
-    deliveryOutcome?: EmailDeliveryOutcome;
-};
-interface EmailSendContext {
-    /** Cooperative cancellation. Custom adapters should abort provider I/O when supported. */
-    signal: AbortSignal;
-    /** Stable caller-provided key reused across retries of the same logical email. */
-    idempotencyKey?: string;
-}
-interface EmailSender {
-    /** Adapter identifier for logs + diagnostics ("console", "resend", "smtp", etc.). */
-    name: string;
-    /**
-     * The optional context preserves source compatibility with pre-0.7 adapters.
-     * New adapters should honor `signal` and provider-native idempotency where available.
-     */
-    send: (message: EmailMessage, context?: EmailSendContext) => Promise<EmailResult>;
-}
-/**
- * Registry keyed by adapter-slot name. Reserved slots used by the
- * framework:
- *
- *  - `'default'` — fallback when no specific slot matches.
- *  - `'transactional'` — login password-reset, account-confirmation,
- *    invoice-receipt, security-critical emails.
- *  - `'marketing'` — newsletters, announcements; consumers MAY route
- *    bulk sends here.
- *  - `'diagnostics'` — diagnostic-test endpoints (e.g. playground).
- *
- * Custom slot names ('billing', 'support', etc.) are allowed; consumers
- * resolve them explicitly via `sendEmail({ adapter: 'billing', ... })`.
- */
-type EmailSenderRegistry = Partial<Record<string, EmailSender>>;
-/**
- * Register a single global email sender. Kept for backwards compatibility.
- * For new code, prefer `registerEmailSenders({ ... })` which lets the
- * framework route transactional vs. marketing through different adapters.
- */
-declare const registerEmailSender: (sender: EmailSender) => void;
-/**
- * Register multiple named email senders. Replaces the entire registry
- * (last-write-wins). Use this when your app routes different message
- * types through different adapters — e.g. Resend for marketing and SMTP
- * for transactional. The framework picks adapter slots by convention
- * (see `EmailSenderRegistry`); consumer code can pick explicitly via
- * `sendEmail({ adapter: 'foo', ... })`.
- */
-declare const registerEmailSenders: (senders: EmailSenderRegistry) => void;
-/** Read the legacy single sender (or the `default` slot of the registry). */
-declare const getEmailSender: () => EmailSender | null;
-/**
- * Read a specific named sender. Falls back to the legacy single sender
- * when the requested slot is absent. Returns null when neither exists.
- * Pass the convention-based slots (`'transactional'`, `'marketing'`,
- * `'diagnostics'`, `'default'`) or any custom slot you registered.
- */
-declare const getEmailSenderByName: (name: string) => EmailSender | null;
-/** Read every registered slot name. */
-declare const listEmailSenderNames: () => string[];
-declare const isEmailSenderRegistered: () => boolean;
-
-type LocaleReloader = () => void | Promise<void>;
-declare const registerLocaleReloader: (reloader: LocaleReloader) => LocaleReloader;
-declare const getLocaleReloader: () => LocaleReloader | null;
-
-interface SentryInstance {
-    captureException: (exception: unknown, ...args: unknown[]) => string;
-    captureMessage: (message: string, ...args: unknown[]) => string;
-    setUser: (user: unknown) => void;
-    setContext: (key: string, context: unknown) => void;
-    startInactiveSpan?: (context: unknown) => unknown;
-}
-/**
- * @deprecated Use `registerErrorTracker` from `@luckystack/error-tracking` instead.
- * Will be removed in a future major version.
- */
-declare const initSharedSentry: (instance: SentryInstance) => void;
-declare const captureException: (error: unknown, context?: Record<string, unknown>) => void;
-declare const captureMessage: (message: string, level?: "info" | "warning" | "error" | "fatal", context?: Record<string, unknown>) => void;
-declare const setSentryUser: (user: {
-    id?: string;
-    email?: string;
-    username?: string;
-} | null) => void;
-declare const startSpan: (name: string, op: string) => unknown;
-
-interface ErrorTrackerUser {
-    id?: string;
-    email?: string;
-    username?: string;
-    [key: string]: unknown;
-}
-/** Open an isolated request identity scope before the first async boundary. */
-declare const runWithErrorTrackerIdentityScope: <T>(fn: () => T) => T;
-/** Open an isolated scope with a user that is already known. */
-declare const runWithErrorTrackerIdentity: <T>(user: ErrorTrackerUser | null, fn: () => T) => T;
-/** Set the user inside the active request scope; no-op outside a scope. */
-declare const setCurrentErrorTrackerIdentity: (user: ErrorTrackerUser | null) => void;
-/** Read the current request identity, or null outside a scope. */
-declare const getCurrentErrorTrackerIdentity: () => ErrorTrackerUser | null;
-
-type ErrorTrackerContext = Record<string, unknown>;
-declare const sanitizeErrorString: (value: string) => string;
-declare const sanitizeErrorStrings: (error: unknown) => {
-    message: string;
-    stack: string | undefined;
-} | null;
-interface ErrorTrackerEvent {
-    /** When false, the adapter must not forward this event (beforeSend opt-out). */
-    forwarded: boolean;
-    kind: 'exception' | 'message';
-    payload: Record<string, unknown>;
-}
-type SpanResult<T> = T;
-interface ErrorTracker {
-    /** Human-readable identifier (logs, diagnostics). */
-    name: string;
-    captureException: (error: unknown, context?: ErrorTrackerContext) => void;
-    captureMessage: (message: string, level: 'info' | 'warning' | 'error' | 'fatal', context?: ErrorTrackerContext) => void;
-    setUser: (user: ErrorTrackerUser | null) => void;
-    setContext?: (key: string, context: ErrorTrackerContext | null) => void;
-    startSpan?: <T>(name: string, op: string, fn: () => T) => T;
-    /**
-     * Optional handle-style span (#62): open a span NOW and close it later via the
-     * returned handle's `finish()`. Unlike {@link startSpan} (which wraps a single
-     * synchronous `fn`), this fits an open-at-preExecute / close-at-postExecute
-     * request lifecycle that spans awaits. When present, the registry-level
-     * {@link startSpanHandle} delegates to the FIRST registered adapter that
-     * implements it so the request span reaches an adapter-only backend
-     * (Datadog/PostHog/custom), not just the legacy Sentry SDK path.
-     */
-    startSpanHandle?: (name: string, op: string) => {
-        finish: () => void;
-    };
-    recordMetric?: (name: string, value: number, tags?: Record<string, string>) => void;
-    beforeSend?: (event: ErrorTrackerEvent) => ErrorTrackerEvent | null;
-    /**
-     * Optional flush lifecycle hook (error-tracking ET batch). Called by
-     * {@link flushErrorTrackers} on graceful shutdown so a buffered adapter
-     * (PostHog batch, Sentry transport) can drain in-flight events before exit.
-     * Returns a promise that resolves when the adapter has flushed.
-     */
-    flush?: () => Promise<void>;
-}
-type PreCaptureFilter = (event: ErrorTrackerEvent) => boolean;
-declare const registerPreCaptureFilter: (filter: PreCaptureFilter | null) => void;
-declare const registerErrorTracker: (tracker: ErrorTracker) => void;
-declare const registerErrorTrackers: (trackers: ErrorTracker[]) => void;
-/**
- * APPEND primitive (ET-05): add a tracker WITHOUT clobbering already-registered
- * ones. Fixes the async-PostHog-vs-consumer-overlay race where the loser of
- * `registerErrorTracker`'s replace silently vanished. De-duplicates by `name`
- * (re-appending the same adapter name replaces that one entry in place) so a
- * lazy adapter that registers a proxy then the real client doesn't double-fire.
- */
-declare const appendErrorTracker: (tracker: ErrorTracker) => void;
-declare const getActiveErrorTrackers: () => ErrorTracker[];
-/**
- * Flush lifecycle (error-tracking ET batch): drain every adapter that exposes a
- * `flush()` before shutdown. Per-adapter failures are swallowed + logged so one
- * stuck adapter can't block graceful shutdown. Safe to call when no adapter has
- * `flush`.
- */
-declare const flushErrorTrackers: () => Promise<void>;
-declare const captureExceptionAcrossTrackers: (error: unknown, context?: ErrorTrackerContext) => void;
-declare const captureMessageAcrossTrackers: (message: string, level: "info" | "warning" | "error" | "fatal", context?: ErrorTrackerContext) => void;
-declare const setErrorTrackerUser: (user: ErrorTrackerUser | null) => void;
-declare const recordMetricAcrossTrackers: (name: string, value: number, tags?: Record<string, string>) => void;
-declare const startSpanAcrossTrackers: <T>(name: string, op: string, fn: () => T) => T;
-/**
- * Handle-style span (error-tracking ET batch): for callers that can't wrap the
- * measured work in a single synchronous `fn` (streaming, cross-await spans).
- * Returns a handle whose `finish()` resolves the span's duration. The default
- * implementation is a lightweight wall-clock timer (works with any backend);
- * an adapter can supply a richer span via the existing `startSpan` callback
- * form when it needs native instrumentation. `finish()` is idempotent.
- */
-interface SpanHandle {
-    /** Stop the span; safe to call more than once (subsequent calls are no-ops). */
-    finish: () => void;
-    /** Milliseconds elapsed at the moment `finish()` first ran (0 before). */
-    readonly durationMs: number;
-}
-declare const startSpanHandle: (name: string, op: string) => SpanHandle;
-
-declare const EnvSchema: z.ZodObject<{
-    NODE_ENV: z.ZodDefault<z.ZodEnum<{
-        development: "development";
-        production: "production";
-        test: "test";
-    }>>;
-    SERVER_IP: z.ZodDefault<z.ZodString>;
-    SECURE: z.ZodDefault<z.ZodEnum<{
-        true: "true";
-        false: "false";
-    }>>;
-    REDIS_HOST: z.ZodDefault<z.ZodString>;
-    REDIS_PORT: z.ZodDefault<z.ZodString>;
-    PROJECT_NAME: z.ZodDefault<z.ZodString>;
-}, z.core.$loose>;
-type RuntimeEnv = z.infer<typeof EnvSchema>;
-declare const DEFAULT_ENV_FILES: string[];
-declare const getEnvFiles: () => string[];
-declare const loadEnvFiles: () => void;
-declare const bootstrapEnv: () => RuntimeEnv;
-declare const env: {
-    [x: string]: unknown;
-    NODE_ENV: "development" | "production" | "test";
-    SERVER_IP: string;
-    SECURE: "true" | "false";
-    REDIS_HOST: string;
-    REDIS_PORT: string;
-    PROJECT_NAME: string;
-};
-declare const isProduction: boolean;
-declare const getEnv: () => RuntimeEnv;
-/** Application runtime mode. Keep separate from `resolveEnvKey()`, which is a
- * deploy-topology identity and may be `staging`, `dockerSplit`, etc. */
-declare const resolveRuntimeMode: () => RuntimeEnv["NODE_ENV"];
-declare const isProductionRuntime: () => boolean;
-declare const isTestRuntime: () => boolean;
-
-declare global {
-    var __luckystackPrisma: PrismaClient | undefined;
-}
-/**
- * Is a generated `@prisma/client` present in this install? Used by the
- * default resolver's error path and by `/readyz` to decide whether a missing
- * DB ping means "broken" or "this project has no Prisma by design".
- */
-declare const isPrismaClientResolvable: () => boolean;
-declare const prisma: PrismaClient<_prisma_client.Prisma.PrismaClientOptions, never, _prisma_client_runtime_library.DefaultArgs>;
-
-type DbHealthResult = boolean | 'skipped';
-type DbHealthCheck = () => Promise<DbHealthResult> | DbHealthResult;
-declare const registerDbHealthCheck: (check: DbHealthCheck) => void;
-declare const getDbHealthCheck: () => DbHealthCheck | null;
-declare const isDbHealthCheckRegistered: () => boolean;
-declare const resetDbHealthCheckForTests: () => void;
-
-declare const resetDefaultRedisClient: () => void;
-declare const rebuildDefaultRedisClient: () => Redis;
-interface RedisConnectionOptions {
-    host: string;
-    port: number;
-    username?: string;
-    password?: string;
-}
-declare const getRedisConnectionOptions: () => RedisConnectionOptions;
-declare const registerStrayPrefixCommand: (...commands: string[]) => void;
-declare const redis: Redis$1;
-
-type RedisKeyFormatter = (namespace: string, suffix: string) => string;
-declare const defaultRedisKeyFormatter: RedisKeyFormatter;
-declare const registerRedisKeyFormatter: (fn: RedisKeyFormatter) => void;
-declare const getRedisKeyFormatter: () => RedisKeyFormatter;
-declare const resetRedisKeyFormatterForTests: () => void;
-declare const formatKey: (namespace: string, suffix?: string) => string;
-declare const applyStrayKeyPrefix: (key: string) => string;
-
-/**
- * Acquire an exclusive lease named `name` for `ttlMs` milliseconds. Returns an
- * opaque owner token on success, or `null` when another owner already holds it.
- * `SET key token PX ttl NX` is atomic, so concurrent acquirers race safely.
- * Keep the returned token to `renewLease` / `releaseLease`.
- */
-declare const acquireLease: (name: string, ttlMs: number) => Promise<string | null>;
-/**
- * Extend a held lease by `ttlMs` (sliding ownership). Returns true when the
- * supplied `token` still owns the lease and the TTL was applied, false
- * otherwise (lost ownership, expired, or Redis error).
- */
-declare const renewLease: (name: string, token: string, ttlMs: number) => Promise<boolean>;
-/**
- * Release a held lease. Owner-checked: only succeeds (returns true) when
- * `token` is the current holder. Returns false on mismatch or Redis error.
- */
-declare const releaseLease: (name: string, token: string) => Promise<boolean>;
-
-declare const DEFAULT_CLIENT_KEY = "default";
-declare const registerPrismaClient: (client: PrismaClient, key?: string) => PrismaClient;
-declare const registerRedisClient: (client: Redis, key?: string) => Redis;
-declare const isPrismaClientRegistered: () => boolean;
-declare const isRedisClientRegistered: () => boolean;
-declare const getPrismaClientKeys: () => string[];
-declare const getRedisClientKeys: () => string[];
-declare const getPrismaClientFor: (key?: string) => PrismaClient;
-declare const getRedisClientFor: (key?: string) => Redis;
-declare const getPrismaClient: () => PrismaClient;
-declare const getRedisClient: () => Redis;
-declare const resetClientsForTests: () => void;
-
-interface AttachSocketRedisAdapterOptions {
-    /**
-     * Options forwarded to `@socket.io/redis-adapter`'s `createAdapter`
-     * (e.g. `key` prefix, `requestsTimeout`, `publishOnSpecificResponseChannel`).
-     * `key` defaults to {@link resolveSocketAdapterKey} when omitted.
-     */
-    adapterOptions?: Partial<RedisAdapterOptions>;
-    /**
-     * Supply a pre-built pub client instead of `redis.duplicate()`. Use this for
-     * a dedicated adapter connection, custom auth, or a sentinel/cluster handle.
-     * When omitted the framework duplicates the default `redis` handle.
-     */
-    pubClient?: Redis;
-    /** Pre-built sub client (see `pubClient`). */
-    subClient?: Redis;
-}
-declare const resolveSocketAdapterKey: () => string;
-declare const attachSocketRedisAdapter: (io: Server, options?: AttachSocketRedisAdapterOptions) => void;
-
-declare const BOOT_KEY_PREFIX = "luckystack:boot:";
-declare const resolveEnvKey: () => string;
-declare const writeBootUuid: (envKey?: string) => Promise<string>;
-declare const readBootUuid: (envKey?: string) => Promise<string | null>;
-/**
- * Extends the current environment boot UUID without rotating its value.
- *
- * Every healthy backend may renew the environment-level key, so multi-instance
- * deployments do not depend on whichever process happened to write it last. If
- * Redis recovered after the key expired, the first refresher writes a new UUID.
- */
-declare const refreshBootUuid: (envKey?: string) => Promise<void>;
-interface BootUuidHeartbeat {
-    stop: () => void;
-}
-/**
- * Keeps the Redis boot UUID alive for as long as this backend is running.
- *
- * The self-rescheduling timeout waits for each Redis operation to settle before
- * scheduling another, so an outage cannot accumulate overlapping refreshes.
- * The timer is unref'd and therefore never keeps an otherwise-finished process
- * alive. Failures are logged and retried on the next interval.
- */
-declare const startBootUuidHeartbeat: (envKey?: string) => BootUuidHeartbeat;
-
-/**
- * Hash a synchronized value under an EXPLICIT `{ mode, salt }` (SEC-13). The
- * shared primitive the router calls with the same config the backend used, so
- * the cross-env compare still holds:
- *   - `'plain'`  → `sha256(value)` (today's behavior; `salt` ignored).
- *   - `'salted'` → `sha256(salt + value)`.
- *   - `'hmac'`   → `HMAC-SHA256(key=salt, value)`.
- * A `'salted'`/`'hmac'` mode with an empty resolved salt falls back to `'plain'`
- * (and is the caller's responsibility to avoid) rather than silently hashing
- * with an empty key.
- */
-declare const hashSynchronizedValueWith: (config: Pick<HealthHashConfig, "mode"> & {
-    salt: string;
-}, value: string) => string;
-/**
- * Resolve the effective health-hash config from `http.healthHash`, expanding the
- * `'@bootUuid'` salt sentinel to the supplied boot UUID. Honoured for BOTH
- * `'salted'` and `'hmac'` (the 0.2.0 default is `hmac` + `'@bootUuid'`, so the
- * per-boot UUID becomes the HMAC key — the synchronized-env fingerprint rotates
- * every restart instead of being a stable, dictionary-attackable `sha256`). The
- * server passes its current boot UUID; the router, comparing, passes the same
- * value it read from the backend's handshake. When the sentinel is in play but
- * no boot UUID is available the config collapses to `'plain'` so the cross-env
- * compare never silently diverges.
- */
-declare const resolveHealthHashConfig: (bootUuid?: string | null) => {
-    mode: HealthHashConfig["mode"];
-    salt: string;
-};
-/**
- * Safe-to-expose descriptor of the resolved health-hash config. The router needs
- * to hash with the SAME `{ mode, salt }` the backend used, but a static `salt`
- * (mode `'salted'`/`'hmac'` with a non-sentinel salt) is a SECRET and must never
- * leave the backend. So `/_health` exposes only the `mode` + whether the salt is
- * the `'@bootUuid'` sentinel (the bootUuid itself is already in the response).
- * From this the router can reproduce the hash for `'plain'` and `'@bootUuid'`
- * configs, and KNOWS it cannot reproduce a static-salt config (so it skips the
- * compare instead of reporting a false drift).
- */
-interface HealthHashDescriptor {
-    mode: HealthHashConfig['mode'];
-    bootUuidSalt: boolean;
-}
-/** Describe the active health-hash config for the `/_health` payload (no secret salt). */
-declare const describeHealthHashConfig: () => HealthHashDescriptor;
-/**
- * Reproduce the backend's resolved `{ mode, salt }` from its `/_health`
- * descriptor + the shared boot UUID. Returns `null` when the backend uses a
- * STATIC salt the router cannot see — the caller must then skip the compare
- * rather than hash with a different (default) config and report a false drift.
- */
-declare const resolveHealthHashConfigFromDescriptor: (descriptor: HealthHashDescriptor, bootUuid: string) => {
-    mode: HealthHashConfig["mode"];
-    salt: string;
-} | null;
-declare const collectSynchronizedEnvKeys: () => string[];
-/**
- * Compute the `/_health` hash map for every synchronized env var. Reads
- * `http.healthHash` (call-time) so a consumer's salt/HMAC opt-in applies;
- * `bootUuid` is consulted only when the salt is the `'@bootUuid'` sentinel.
- * The 0.2.0 DEFAULT (`{ mode: 'hmac', salt: '@bootUuid' }`) HMAC-keys the output
- * on `bootUuid`; pass `mode: 'plain'` to restore the historical unsalted output.
- */
-declare const computeSynchronizedEnvHashes: (bootUuid?: string | null) => Record<string, string | null>;
-declare const hashSynchronizedValue: (value: string, bootUuid?: string | null) => string;
-
-declare const initConsolelog: () => void;
-
-declare const DEFAULT_REDACTED_LOG_KEYS: readonly string[];
-declare const registerRedactedLogKeys: (keys: readonly string[]) => void;
-declare const getRedactedLogKeys: () => readonly string[];
-declare const isRedactedLogKey: (key: string) => boolean;
-declare const resetRedactedLogKeysForTests: () => void;
-/** Placeholder substituted for a redacted value. */
-declare const REDACTED_PLACEHOLDER = "[redacted]";
-declare const DEPTH_TRUNCATED_PLACEHOLDER = "[truncated: max depth]";
-/**
- * Recursively deep-copy `value`, replacing any property whose key matches the
- * registered redacted-keys set (case-insensitive) with {@link REDACTED_PLACEHOLDER}
- * (SYNC-17 defense-in-depth). Use it at raw log / `captureException` context
- * sites so a token/password nested anywhere in a payload never lands verbatim in
- * a logger sink or error-tracker breadcrumb.
- *
- * - Primitives pass through unchanged.
- * - Arrays are mapped element-wise (array indices are never "keys", so an
- *   element is only redacted by its own nested object keys).
- * - Cycles / over-deep graphs are cut at {@link MAX_SANITIZE_DEPTH} with
- *   {@link DEPTH_TRUNCATED_PLACEHOLDER}; the input is never mutated.
- */
-declare const sanitizeForLog: (value: unknown, depth?: number, _seen?: WeakSet<object>) => unknown;
-
-declare const getCookieValue: (cookieHeader: string | undefined, cookieName: string) => string | null;
-declare const hasCookie: (cookieHeader: string | undefined, cookieName: string) => boolean;
-/** Attributes a cookie-builder must honour, after applying any name prefix. */
-interface CookiePrefixConstraints {
-    /** Effective cookie name (prefix prepended when applicable). */
-    name: string;
-    /** Whether `Secure` must be set (forced true by either prefix). */
-    secure: boolean;
-    /** Whether `Path=/` is forced (true under `__Host-`). */
-    forcePathRoot: boolean;
-    /** Whether a `Domain` attribute is FORBIDDEN (true under `__Host-`). */
-    forbidDomain: boolean;
-}
-/**
- * Compute the attribute constraints a `__Host-` / `__Secure-` cookie-name prefix
- * imposes (CORE-10/39), so the server's session + CSRF cookie builders apply the
- * browser-enforced rules consistently:
- *
- *   - `'__Host-'`   → name prefixed, `Secure` forced, `Path=/` forced, `Domain` forbidden.
- *   - `'__Secure-'` → name prefixed, `Secure` forced.
- *   - `undefined`   → name unchanged, no forced attributes (today's behavior).
- *
- * Pure + deterministic — the builder still owns serialization; this only
- * resolves the constraints so server and any other cookie-site can't drift.
- * `secureOverride` lets the caller force `Secure` independent of a prefix
- * (mirrors `http.sessionCookieSecure`).
- */
-declare const applyCookiePrefixConstraints: (baseName: string, prefix: "__Host-" | "__Secure-" | undefined, secureOverride?: boolean) => CookiePrefixConstraints;
-
-/**
- * HTTP API Utilities
- *
- * Helpers for HTTP API request handling including:
- * - Smart HTTP method detection based on API name
- * - Method validation
- */
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
-/**
- * Single source of truth for the GET-prefix naming heuristic
- * (`get` / `fetch` / `list`). Used by both `inferHttpMethod` here and the
- * client transport's `isGetMethod` fallback in `apiRequest.ts`, so the two
- * prefix heuristics can't drift apart. Expects an already-lowercased leaf name.
- */
-declare const isGetMethodName: (methodNameLower: string) => boolean;
-/**
- * Infer the HTTP method from an API name based on common naming conventions.
- *
- * - Names starting with "get" → GET
- * - Names starting with "delete" or "remove" → DELETE
- * - Names starting with "update" or "edit" → PUT
- * - Everything else → POST (create operations, actions)
- *
- * @example
- * ```typescript
- * inferHttpMethod('getUserData')   // → 'GET'
- * inferHttpMethod('deleteAccount') // → 'DELETE'
- * inferHttpMethod('updateProfile') // → 'PUT'
- * inferHttpMethod('createUser')    // → 'POST'
- * inferHttpMethod('sendEmail')     // → 'POST'
- * ```
- */
-declare const inferHttpMethod: (apiName: string) => HttpMethod;
-/**
- * Get the effective HTTP method for an API.
- * Uses explicit export if available, otherwise infers from name.
- */
-declare const getEffectiveHttpMethod: (apiConfig: {
-    httpMethod?: HttpMethod;
-}, apiName: string) => HttpMethod;
-/**
- * Check if an HTTP method is valid for an API.
- *
- * @param requestMethod - The method from the HTTP request
- * @param allowedMethod - The method the API accepts
- * @returns true only when the method matches the route's allowed method.
- *
- * NOTE: `OPTIONS` is intentionally NOT treated as allowed here. A custom-route
- * author wiring this into their dispatch must answer CORS preflights BEFORE the
- * route check — letting `OPTIONS` through would execute the handler on a request
- * the CSRF middleware treats as non-state-changing (CSRF-exempt), opening a
- * bypass on method-locked routes.
- */
-declare const isMethodAllowed: (requestMethod: string, allowedMethod: HttpMethod) => boolean;
-
-declare const ROOT_DIR: string;
-declare const getSrcDir: () => string;
-declare const getServerDir: () => string;
-declare const getSharedDir: () => string;
-declare const getUploadsDir: () => string;
-declare const getPublicDir: () => string;
-declare const getServerFunctionDirs: () => string[];
-/**
- * @deprecated Use `getServerFunctionDirs()` instead. Returns the first
- * directory from the array, or `'functions'` resolved against the workspace
- * root when no directories are configured.
- */
-declare const getServerFunctionsDir: () => string;
-declare const getGeneratedSocketTypesPath: () => string;
-declare const getGeneratedApiSchemasPath: () => string;
-declare const getGeneratedApiDocsPath: () => string;
-declare const SRC_DIR: string;
-/** @deprecated use `getServerDir()` instead. */
-declare const SERVER_DIR: string;
-/** @deprecated use `getSharedDir()` instead. */
-declare const SHARED_DIR: string;
-/** @deprecated use `getUploadsDir()` instead. */
-declare const UPLOADS_DIR: string;
-/** @deprecated use `getPublicDir()` instead. */
-declare const PUBLIC_DIR: string;
-/** @deprecated use `getServerFunctionsDir()` instead. */
-declare const SERVER_FUNCTIONS_DIR: string;
-/** @deprecated use `getGeneratedSocketTypesPath()` instead. */
-declare const GENERATED_SOCKET_TYPES_PATH: string;
-/** @deprecated use `getGeneratedApiSchemasPath()` instead. */
-declare const GENERATED_API_SCHEMAS_PATH: string;
-/** @deprecated use `getGeneratedApiDocsPath()` instead. */
-declare const GENERATED_API_DOCS_PATH: string;
-declare const TSCONFIG_ALIAS_FILES: string[];
-declare const resolveFromRoot: (...segments: string[]) => string;
-
-type SocketMiddleware = (socket: Socket, next: (err?: Error) => void) => void;
-/**
- * Register a Socket.io middleware that will be wired via `io.use(...)` when
- * the framework boots the socket server. Multiple middlewares can be
- * registered — they run in registration order before any `connect`
- * handler fires.
- */
-declare const registerSocketMiddleware: (mw: SocketMiddleware) => void;
-/** Read the registered middleware list (read-only view). */
-declare const getSocketMiddlewares: () => readonly SocketMiddleware[];
-/** Test-only / hot-reload helper. Drops every registered middleware. */
-declare const clearSocketMiddlewares: () => void;
-/**
- * Wire every registered middleware into the running Socket.io server.
- * Called by `@luckystack/server`'s `loadSocket` after the `SocketIOServer`
- * is constructed and before any `connect` handler is attached, so custom
- * middlewares run before framework handlers see the socket.
- */
-declare const applySocketMiddlewares: (io: Server) => void;
-
-interface CsrfCookieOptions {
-    sameSite?: 'strict' | 'lax' | 'none';
-    secure?: boolean;
-    /**
-     * Whether the login-absent double-submit cookie is HttpOnly. The client gets
-     * the matching header value from the same-origin `GET /auth/csrf` JSON body,
-     * so either value works; `false` remains the compatibility default.
-     */
-    httpOnly?: boolean;
-    path?: string;
-    maxAgeMs?: number;
-}
-interface CsrfConfig {
-    /** Cookie name used to deliver the CSRF token to the browser. */
-    cookieName: string;
-    /** Request-header name the client attaches on state-changing requests. */
-    headerName: string;
-    /** Length in bytes of the random token minted by the session layer. */
-    tokenLength: number;
-    cookieOptions: CsrfCookieOptions;
-}
-declare const DEFAULT_CSRF_CONFIG: CsrfConfig;
-/**
- * Override one or more CSRF settings. Merges shallowly with the current
- * config; `cookieOptions` is deep-merged so a partial override of (say)
- * `sameSite` does not clobber `path` / `maxAgeMs`. Last-write-wins.
- */
-declare const registerCsrfConfig: (input: Partial<CsrfConfig>) => void;
-/** Read the active config at call time (never at module load). */
-declare const getCsrfConfig: () => CsrfConfig;
-/** Test-only — restore defaults between scenarios. */
-declare const resetCsrfConfigForTests: () => void;
-
-declare const serveAvatar: ({ routePath, res, }: {
-    routePath: string;
-    res: ServerResponse;
-}) => Promise<void>;
-
-interface ProcessUploadInput {
-    /** User the upload is associated with. */
-    userId: string;
-    /** Content type from the source (e.g. parsed from a data URL prefix). */
-    contentType: string;
-    /** Raw upload bytes — used for `sizeBytes` and passed to the encoder. */
-    buffer: Buffer;
-    /** Identifier for the upload category. Defaults to `'avatar'`. */
-    uploadKind?: string;
-    /** Final file name written to disk (used in the `onUploadComplete` payload). */
-    fileName: string;
-    /**
-     * Project-supplied encode + write step. Receives the raw buffer, does
-     * whatever encoding/resizing the installer wants (sharp, ffmpeg, raw fs
-     * write, S3 upload, etc.), and returns the final byte size on disk —
-     * pass through `buffer.byteLength` if you don't have a meaningful
-     * post-encode size.
-     */
-    encodeAndSave: (buffer: Buffer) => Promise<number>;
-}
-type ProcessUploadResult = {
-    status: 'success';
-    sizeBytes: number;
-} | {
-    status: 'rejected';
-    errorCode: string;
-} | {
-    status: 'error';
-    reason: string;
-    cause?: unknown;
-};
-/**
- * Run a project-side upload through the framework's hook contract.
- *
- * Order of operations:
- *   1. Dispatch `onUploadStart` — handlers may return a stop signal to reject
- *      the upload (content moderation, virus scanner, quota check).
- *   2. Run the project-supplied `encodeAndSave` callback (wrapped in tryCatch).
- *   3. Dispatch `onUploadComplete` with the final `sizeBytes`.
- *
- * Returns one of three statuses so the caller can map to its own response
- * envelope without inspecting hook internals.
- */
-declare const processUpload: (input: ProcessUploadInput) => Promise<ProcessUploadResult>;
-
-interface BindAddress {
-    ip: string;
-    port: number;
-}
-interface IntendedBindAddress extends BindAddress {
-    configuredPort?: number;
-}
-declare const registerBindAddress: (address: IntendedBindAddress) => void;
-declare const registerBoundAddress: (address: BindAddress) => void;
-declare const getBindAddress: () => {
-    ip: string;
-    port: string;
-};
-declare const resolveDevCallbackUrl: (callbackUrl: string) => string;
-
-interface AvatarConfig {
-    /**
-     * File format(s) the framework will look for on disk, in order. The first
-     * one that exists wins. Each entry is `{ extension, contentType }` so the
-     * `Content-Type` response header matches what the file actually is.
-     * Default: `[{ extension: 'webp', contentType: 'image/webp' }]`.
-     */
-    formats: {
-        extension: string;
-        contentType: string;
-    }[];
-    /**
-     * `Cache-Control` value sent with the avatar response.
-     * Default: `'public, max-age=86400'` (24 hours).
-     */
-    cacheControl: string;
-}
-declare const DEFAULT_AVATAR_CONFIG: AvatarConfig;
-type AvatarConfigInput = DeepPartial<AvatarConfig>;
-declare const registerAvatarConfig: (config: AvatarConfigInput) => void;
-declare const getAvatarConfig: () => AvatarConfig;
-
-interface getParamsType {
-    method: string;
-    req: IncomingMessage;
-    res: ServerResponse;
-    queryString?: string;
-}
-declare function getParams({ method, req, res: _res, queryString }: getParamsType): Promise<Record<string, unknown> | null>;
-
-/**
- * Extract the authentication token from a Socket.io connection.
- *
- * Checks `config.sessionBasedToken` to determine where to look:
- * - `true`: Token is in `socket.handshake.auth.token` (sessionStorage on client)
- * - `false`: Token is in cookies via `socket.handshake.headers.cookie`
- *
- * @param socket - The Socket.io socket instance
- * @returns The token string or null if not found
- */
-declare const extractTokenFromSocket: (socket: Pick<Socket, "handshake">) => string | null;
-
-/**
- * Extract the authentication token from an HTTP request.
- *
- * Supports tokens from:
- * - `Authorization: Bearer <token>` header
- * - the configured session cookie
- *
- * @param req - The HTTP incoming message
- * @returns The token string or null if not found
- */
-declare const extractTokenFromRequest: (req: IncomingMessage) => string | null;
-
-/**
- * Stable sentinel returned when no usable client address could be resolved.
- * Kept as a single exported constant so every rate-limit key-site funnels
- * missing addresses into one deterministic bucket instead of ad-hoc literals.
- */
-declare const UNKNOWN_CLIENT_IP = "unknown";
-interface ResolveClientIpParams {
-    /**
-     * The raw transport peer address — `socket.handshake.address` (Socket.io)
-     * or `req.socket.remoteAddress` (raw HTTP). May be `undefined`/`null` when
-     * the connection has already been torn down.
-     */
-    rawAddress: string | null | undefined;
-    /** Request / handshake headers. Only consulted when `trustProxy` is true. */
-    headers: IncomingHttpHeaders;
-    /**
-     * Whether a known reverse proxy sits in front of this server. DEFAULT false.
-     * When false the raw peer address is returned verbatim (only IPv4-mapped
-     * IPv6 canonicalization is applied), preserving historical behaviour. Only
-     * enable when a trusted proxy populates `X-Forwarded-For` / `X-Real-IP`,
-     * otherwise a client can spoof its own IP via those headers.
-     */
-    trustProxy?: boolean;
-    /**
-     * Number of proxy hops to skip from the RIGHT of `X-Forwarded-For` when
-     * `trustProxy` is on (CORE-O3). The rightmost entries are appended by your own
-     * trusted proxies; the resolved client IP is the entry that many hops in from
-     * the end. The leftmost hop is client-controlled and is never trusted. DEFAULT
-     * 1 (the immediate upstream proxy). Clamped to the list length so an over-large
-     * count falls back to the leftmost trusted hop rather than the spoofable entry.
-     */
-    trustedProxyHopCount?: number;
-}
-/**
- * Whether a resolved client IP is a loopback / unresolved address — used by the
- * api/sync transports to honour `rateLimiting.skipLoopbackInDev` (api F5/F11).
- * Matches IPv4 loopback (`127.0.0.0/8`), IPv6 loopback (`::1`), the IPv4-mapped
- * form (`::ffff:127.0.0.1`, already canonicalized away by {@link resolveClientIp}),
- * and the {@link UNKNOWN_CLIENT_IP} sentinel. Pass an already-resolved IP.
- */
-declare const isLoopbackIp: (ip: string) => boolean;
-/**
- * Derive the deterministic, non-reversible bucket component for a session
- * token. The same token always yields the same value (bucket identity is
- * preserved) while the raw token never appears in the returned string.
- * Used by api AND sync rate-limit key builders — lives in core so both
- * packages can share one implementation without a cross-package dependency.
- */
-declare const deriveTokenBucketId: (token: string) => string;
-declare const resolveClientIp: ({ rawAddress, headers, trustProxy, trustedProxyHopCount }: ResolveClientIpParams) => string;
-
-interface SessionSaveResult {
-    ok: boolean;
-    errorCode?: string;
-}
-interface SessionLogoutInput {
-    token: string | null;
-    socket?: Socket;
-    userId?: string | null;
-    skipSessionDelete?: boolean;
-}
-interface SessionProvider {
-    getSession: (token: string | null) => Promise<BaseSessionLayout | null>;
-    saveSession: (token: string, data: BaseSessionLayout, newUser?: boolean, options?: {
-        supersedeToken?: string;
-    }) => Promise<SessionSaveResult>;
-    deleteSession: (token: string, options?: {
-        skipSocketLogout?: boolean;
-    }) => Promise<boolean>;
-    logout: (input: SessionLogoutInput) => Promise<void>;
-}
-declare const registerSessionProvider: (next: SessionProvider) => void;
-declare const getRegisteredSessionProvider: () => SessionProvider | null;
-declare const isSessionProviderRegistered: () => boolean;
-declare const resetSessionProviderForTests: () => void;
-declare const readSession: (token: string | null) => Promise<BaseSessionLayout | null>;
-/**
- * Persist a session via the registered provider, or no-op if no login provider
- * is registered (unauthenticated-app case).
- *
- * **WARNING**: when no session provider is registered, this returns `{ ok: true }`
- * as a no-op — the session is NOT actually persisted anywhere. Callers that
- * check `result.ok` before considering a user logged in will incorrectly
- * proceed as if the session was saved. This is intentional for apps that do not
- * use `@luckystack/login`, but on a partial install (login package misconfigured
- * or not yet registered) the failure is silent rather than loud.
- * Use `isSessionProviderRegistered()` at boot to verify the provider is present.
- */
-declare const writeSession: (token: string, data: BaseSessionLayout, newUser?: boolean, options?: {
-    supersedeToken?: string;
-}) => Promise<SessionSaveResult>;
-declare const removeSession: (token: string, options?: {
-    skipSocketLogout?: boolean;
-}) => Promise<boolean>;
-declare const performLogout: (input: SessionLogoutInput) => Promise<void>;
-
-/**
- * Shared validation utilities for API and Sync request handlers.
- * Extracted to avoid code duplication between handleApiRequest and handleSyncRequest.
- */
-
-/**
- * Check if a value is falsy (false, 0, 0n, '', null, undefined, or NaN)
- */
-declare const isFalsy: (value: unknown) => boolean;
-interface ValidationResult$1 {
-    status: 'success' | 'error';
-    errorCode?: string;
-    errorParams?: {
-        key: string;
-        value: string | number | boolean;
-    }[];
-    httpStatus?: number;
-}
-/**
- * Validate a request against authentication requirements.
- *
- * Multiple constraints on a single `additional` entry are AND'd: every
- * specified field (`nullish`, `type`, `value`, `mustBeFalsy`) must pass
- * for that entry to validate. Each entry across the array is also AND'd:
- * the request must pass every entry to succeed.
- *
- * Constraint semantics:
- *   - `nullish: true`     — `val` must be `null` or `undefined`.
- *   - `nullish: false`    — `val` must NOT be `null` or `undefined`.
- *   - `type: 'string'`    — `typeof val === 'string'` (skipped when val is null/undefined).
- *   - `value: <x>`        — strict equality `val === x`. Omit the field entirely if you
- *                           don't want this check; setting `value: undefined`
- *                           explicitly means "val must be undefined".
- *   - `mustBeFalsy: true`  — `isFalsy(val)`.
- *   - `mustBeFalsy: false` — `!isFalsy(val)`.
- *
- * **SECURITY CONTRACT**: this function does NOT check `auth.login`. Login
- * enforcement is the responsibility of the surrounding API/sync handler — it
- * must verify the session exists before calling `validateRequest`. Callers
- * that omit the login check will allow unauthenticated requests through the
- * `additional[]` predicates even when `auth.login: true` is declared, because
- * `validateRequest` short-circuits to success when `additional` is empty.
- * The expected call pattern is:
- *   1. Check session exists (enforce `auth.login`).
- *   2. Call `validateRequest({ auth, user })` to enforce `auth.additional[]`.
- */
-declare const validateRequest: ({ auth, user }: {
-    auth: AuthProps;
-    user?: BaseSessionLayout | null;
-}) => ValidationResult$1;
-
-/**
- * Rate Limiter
- *
- * The framework's rate-limit dispatch is pluggable via
- * `registerRateLimitStrategy()`. The built-in `defaultRateLimitStrategy`
- * implements in-memory counters with optional Redis backing for
- * multi-instance deployments. Consumers can plug in alternative strategies
- * (token-bucket, sliding-window, per-user tiers, edge-KV-backed, etc.) by
- * implementing the `RateLimitStrategy` interface.
- */
-interface CheckRateLimitParams {
-    /** Unique key for rate limiting (e.g., "user:123:api:getData") */
-    key: string;
-    /** Maximum requests allowed in window */
-    limit: number;
-    /** Time window in milliseconds (default: 60_000 = 1 minute) */
-    windowMs?: number;
-}
-interface RateLimitResult {
-    /** Whether the request is allowed */
-    allowed: boolean;
-    /** Remaining requests in current window */
-    remaining: number;
-    /** Seconds until rate limit resets */
-    resetIn: number;
-}
-/**
- * Pluggable rate-limit backend. The framework calls these methods through
- * the active strategy slot. Default implementation is memory + Redis.
- * Replace via `registerRateLimitStrategy(...)` at boot.
- */
-interface RateLimitStrategy {
-    /** Human-readable identifier (used in logs/diagnostics). */
-    name: string;
-    /** Increment the counter for `key` and return whether the request is allowed. */
-    check(params: CheckRateLimitParams): Promise<RateLimitResult>;
-    /** Read current status without incrementing — useful for response headers. */
-    getStatus(key: string, limit: number): Promise<RateLimitResult>;
-    /** Reset the counter for a single key. */
-    clear(key: string): Promise<void>;
-    /** Reset all counters under this strategy's namespace. */
-    clearAll(): Promise<void>;
-}
-/**
- * Built-in strategy: in-memory counters with optional Redis backing for
- * multi-instance deployments. Mode is controlled by
- * `projectConfig.rateLimiting.store` (`'memory'` or `'redis'`). When `redis`
- * mode fails (e.g. Redis disconnect), the strategy silently degrades to
- * in-memory and logs a one-shot warning.
- */
-declare const defaultRateLimitStrategy: RateLimitStrategy;
-/**
- * Replace the active rate-limit backend. Pass a strategy that implements
- * `RateLimitStrategy`. Common use cases:
- *
- *  - Token-bucket / sliding-window algorithms for smoother burst handling.
- *  - Per-user tier limits (premium accounts get higher caps).
- *  - Cloudflare-Workers-KV or upstash-rest-backed counters for edge.
- *  - No-op strategy for test environments.
- *
- * Call this once at boot (typically from `luckystack/server/index.ts`)
- * BEFORE the first request lands. Subsequent calls overwrite the previous
- * registration (last-write-wins).
- */
-declare const registerRateLimitStrategy: (strategy: RateLimitStrategy) => void;
-/** Read the currently-active strategy (defaults to the built-in). */
-declare const getRateLimitStrategy: () => RateLimitStrategy;
-/**
- * Check if a request is allowed under rate limiting rules.
- * Increments the counter for the key if allowed.
- */
-declare const checkRateLimit: (params: CheckRateLimitParams) => Promise<RateLimitResult>;
-/**
- * Get current rate limit status without incrementing counter.
- * Useful for rate limit headers in responses.
- */
-declare const getRateLimitStatus: (key: string, limit: number) => Promise<RateLimitResult>;
-/**
- * Clear rate limit for a specific key.
- * Useful for admin overrides or testing.
- */
-declare const clearRateLimit: (key: string) => Promise<void>;
-/**
- * Clear all rate limits.
- * Intended for testing or dev-mode server reset only.
- * CORE-O8: throws in production to prevent accidental global counter wipe across
- * all tenants. If you need a production-safe reset, pass a scoped key to
- * `clearRateLimit` or implement a tenant-namespaced strategy.
- */
-declare const clearAllRateLimits: () => Promise<void>;
-
-type ValidationResult = {
-    status: 'success';
-} | {
-    status: 'error';
-    message: string;
-};
-declare const validateInputByType: ({ typeText, value, rootKey, filePath, }: {
-    typeText?: string;
-    value: unknown;
-    rootKey: string;
-    filePath?: string;
-}) => Promise<ValidationResult>;
-
-declare const normalizeOrigin: ({ value, secure }: {
-    value: string;
-    secure: boolean;
-}) => string;
-declare const allowedOrigin: (origin: string) => boolean;
-
-declare const registerSyncAbortController: (socketId: string, cb: string, controller: AbortController) => string;
-declare const unregisterSyncAbortController: (key: string) => void;
-declare const abortSyncByCb: (socketId: string, cb: string) => boolean;
-declare const registerApiAbortController: (socketId: string, responseIndex: number | string, controller: AbortController) => string;
-declare const unregisterApiAbortController: (key: string) => void;
-declare const abortApiByResponseIndex: (socketId: string, responseIndex: number | string) => boolean;
-declare const abortAllForSocket: (socketId: string) => void;
-
-/**
- * Handle returned by {@link issueOneTimeToken}. `token` is the RAW token to hand
- * to the caller (embed in the emailed URL); call `store()` to persist its hash
- * to Redis with the configured TTL. Persisting is a separate step so the caller
- * can run veto logic (hooks, validation) between minting and committing without
- * leaving an orphan Redis key.
- */
-interface OneTimeTokenHandle {
-    /** The raw, single-use token. Returned exactly once; never stored verbatim. */
-    token: string;
-    /** Persist `sha256(token)` -> `payload` in Redis with the issue TTL. */
-    store(): Promise<void>;
-}
-/**
- * Mint a one-time token in `namespace` carrying `payload`, redeemable for `ttl`
- * seconds. Returns the raw token plus a `store()` committer. The payload is
- * serialised to a string (objects via JSON); on redemption it is returned as a
- * string and the caller parses it (or use {@link consumeOneTimeTokenJson}).
- *
- * @param namespace Key namespace (e.g. `'-pwreset'`, `'-email-change'`) — routed
- *   through `formatKey` so the active key formatter / project prefix applies.
- * @param ttlSeconds Time-to-live in seconds for the stored hash.
- * @param payload   Value bound to the token. A string is stored verbatim; any
- *   other value is `JSON.stringify`-d.
- */
-declare const issueOneTimeToken: (namespace: string, ttlSeconds: number, payload: string | Record<string, unknown>) => OneTimeTokenHandle;
-/**
- * Atomically validate + consume a one-time token from `namespace`. Returns the
- * stored payload STRING on success (and deletes the entry, so it can never be
- * reused), or `null` when the token is missing / expired / malformed / already
- * consumed. A single `MULTI` `GET`+`DEL` guarantees at-most-once redemption.
- */
-declare const consumeOneTimeToken: (namespace: string, token: string) => Promise<string | null>;
-/**
- * Convenience wrapper over {@link consumeOneTimeToken} that JSON-parses the
- * stored payload into `T`. Returns `null` on miss OR on a malformed JSON
- * payload. Use when the token was issued with an object payload.
- */
-declare const consumeOneTimeTokenJson: <T>(namespace: string, token: string) => Promise<T | null>;
-declare const oneTimeTokenKey: (namespace: string, token: string) => string;
-
-/**
- * Core hook contract: framework-generic payload shapes + augmentable registry.
- *
- * Feature packages (login/sync/api/presence/...) extend `HookPayloads` via
- * TypeScript module augmentation:
- *
- * ```ts
- * // packages/<feature>/src/hookPayloads.ts
- * declare module '@luckystack/core' {
- *   interface HookPayloads {
- *     myFeatureHook: { ... };
- *   }
- * }
- * export {};
- * ```
- *
- * Module-augmentation files MUST be in a tsconfig `include` path for TS to
- * pick up the merge; a side-effect import from the package's `index.ts`
- * (`import './hookPayloads';`) guarantees this.
- */
-
-/**
- * Minimal session shape used inside core-owned hook payloads. Defined here
- * (instead of imported from `@luckystack/login`) so `@luckystack/core` stays
- * independent of login. Any concrete session type (`BaseSessionLayout`,
- * project-level `SessionLayout` extending Prisma User, etc.) is structurally
- * assignable to this shape.
- */
-interface HookSessionShape {
-    id: string;
-    token?: string;
-    email?: string | null;
-    name?: string | null;
-    avatar?: string | null;
-    avatarFallback?: string | null;
-    admin?: boolean | null;
-    language?: string | null;
-    roomCodes?: string[];
-}
-interface HookStopSignal {
-    stop: true;
-    errorCode: string;
-    httpStatus?: number;
-    /**
-     * Optional output override for per-recipient hooks (`preSyncRecipient`).
-     * When present on a stop signal the framework DOES NOT skip the recipient —
-     * instead it sends this value in place of the full `serverOutput`. Use to
-     * redact PII before delivery without excluding the socket from the fanout.
-     * Ignored by all other hook dispatch sites.
-     */
-    overrideOutput?: unknown;
-}
-/** Handlers return undefined / void to continue, or a stop signal to abort the main flow. */
-type HookResult = void | undefined | HookStopSignal;
-type HookHandler<TPayload> = (payload: TPayload) => Promise<HookResult> | HookResult;
-interface PreApiValidatePayload {
-    routeName: string;
-    data: Record<string, unknown>;
-    user: HookSessionShape | null;
-    /**
-     * Optional transport tag — populated by the framework's socket/HTTP API
-     * handlers so hook subscribers can branch on it (e.g. open span with a
-     * different op name). Optional so consumer-side dispatchers don't have to
-     * set it explicitly.
-     */
-    transport?: 'socket' | 'http';
-}
-interface PostApiValidatePayload extends PreApiValidatePayload {
-    validation: {
-        status: 'success';
-    } | {
-        status: 'error';
-        message: string;
-    };
-}
-interface PreApiExecutePayload {
-    routeName: string;
-    data: Record<string, unknown>;
-    user: HookSessionShape | null;
-    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
-    transport?: 'socket' | 'http';
-}
-interface PostApiExecutePayload {
-    routeName: string;
-    data: Record<string, unknown>;
-    user: HookSessionShape | null;
-    result: unknown;
-    error: Error | null;
-    durationMs: number;
-    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
-    transport?: 'socket' | 'http';
-}
-interface ApiResponseEnvelope {
-    status: 'success' | 'error';
-    httpStatus?: number;
-    errorCode?: string;
-    message?: string;
-    [key: string]: unknown;
-}
-interface PreApiRespondPayload {
-    routeName: string;
-    user: HookSessionShape | null;
-    response: ApiResponseEnvelope;
-    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
-    transport?: 'socket' | 'http';
-}
-interface PostApiRespondPayload {
-    routeName: string;
-    user: HookSessionShape | null;
-    response: ApiResponseEnvelope;
-    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
-    transport?: 'socket' | 'http';
-}
-interface PreSyncAuthorizePayload {
-    routeName: string;
-    /** Raw (un-validated) data payload. May be reshape-able by the consumer. */
-    data: Record<string, unknown>;
-    user: HookSessionShape | null;
-    /** Room code / receiver token — the sync's intended audience. */
-    receiver: string;
-    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
-    transport?: 'socket' | 'http';
-}
-interface PostSyncAuthorizePayload {
-    routeName: string;
-    data: Record<string, unknown>;
-    user: HookSessionShape | null;
-    receiver: string;
-    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
-    transport?: 'socket' | 'http';
-}
-interface PreSyncValidatePayload {
-    routeName: string;
-    data: Record<string, unknown>;
-    user: HookSessionShape | null;
-    receiver: string;
-    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
-    transport?: 'socket' | 'http';
-}
-interface PostSyncValidatePayload extends PreSyncValidatePayload {
-    validation: {
-        status: 'success';
-    } | {
-        status: 'error';
-        message: string;
-    };
-}
-interface PreSyncExecutePayload {
-    routeName: string;
-    data: Record<string, unknown>;
-    user: HookSessionShape | null;
-    receiver: string;
-    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
-    transport?: 'socket' | 'http';
-}
-interface PostSyncExecutePayload {
-    routeName: string;
-    data: Record<string, unknown>;
-    user: HookSessionShape | null;
-    receiver: string;
-    result: unknown;
-    error: Error | null;
-    durationMs: number;
-    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
-    transport?: 'socket' | 'http';
-}
-interface PreSyncFanoutPayload {
-    routeName: string;
-    data: Record<string, unknown>;
-    user: HookSessionShape | null;
-    receiver: string;
-    serverOutput: unknown;
-    /** Optional transport tag — see {@link PreApiValidatePayload.transport}. */
-    transport?: 'socket' | 'http';
-}
-interface PostSyncFanoutPayload extends PreSyncFanoutPayload {
-    recipientCount: number;
-}
-interface PreSyncStreamPayload {
-    routeName: string;
-    /** Stream chunk being sent (already serialised by the framework). */
-    chunk: unknown;
-    /** Final recipient — socket id when known, room code otherwise. */
-    recipient: string;
-}
-interface PostSyncStreamPayload extends PreSyncStreamPayload {
-    /** Total chunks streamed so far in this sync invocation. */
-    chunkIndex: number;
-}
-interface ApiErrorPayload {
-    route: string;
-    method?: string;
-    requestId?: string;
-    user?: HookSessionShape | null;
-    error: Error;
-}
-interface SyncErrorPayload {
-    route: string;
-    method?: string;
-    requestId?: string;
-    user?: HookSessionShape | null;
-    error: Error;
-}
-interface RateLimitExceededPayload {
-    /** Where the limit was hit — IP, user, or route. */
-    scope: 'ip' | 'user' | 'route' | 'auth';
-    /** The key that exceeded its limit (sanitized — no tokens). */
-    key: string;
-    /** Configured limit count for this key. */
-    limit: number;
-    /** Window in milliseconds. */
-    windowMs: number;
-    /** Current bucket count after the rejected request. */
-    count: number;
-    /** Optional route or transport context. */
-    route?: string;
-    ip?: string;
-    userId?: string;
-}
-interface CorsRejectedPayload {
-    /** Origin header sent by the client. */
-    origin: string;
-    /** Origin after framework normalization (scheme + host[:port]). */
-    normalizedOrigin: string;
-    /** Effective allowed-origins set at the time of rejection. */
-    allowedOrigins: string[];
-    /** Whether `allowLocalhost` was on. */
-    allowLocalhost: boolean;
-    /** Optional route the rejected request was for. */
-    route?: string;
-    /**
-     * Why the request was rejected (server HOK-27). Distinguishes a present-but-
-     * disallowed Origin (`'origin-not-allowed'`) from a MISSING Origin header
-     * (`'origin-missing'`, the 403 dispatched by the server's origin gate) and the
-     * normalization-failure case. Optional so existing `allowedOrigin()` callers
-     * that don't set it stay source-compatible.
-     */
-    reason?: 'origin-not-allowed' | 'origin-missing' | 'origin-malformed';
-}
-interface PreSessionRefreshPayload {
-    token: string;
-    userId: string | null;
-    oldTtl: number | null;
-    newTtl: number;
-}
-interface PostSessionRefreshPayload {
-    token: string;
-    userId: string | null;
-    oldTtl: number | null;
-    newTtl: number;
-    /** True if Redis EXPIRE succeeded; false on failure or non-existent key. */
-    applied: boolean;
-}
-interface SessionCreatedPayload {
-    token: string;
-    userId: string;
-    /** How the session came to exist (credentials login, OAuth, refresh-mint, ...). */
-    via?: string;
-}
-interface SessionRevokedPayload {
-    token: string;
-    userId: string | null;
-    /** Why the session was revoked (logout, kicked-by-new-device, admin, expiry, ...). */
-    reason?: string;
-}
-interface OnUploadStartPayload {
-    userId: string;
-    contentType: string;
-    sizeBytes: number;
-    uploadKind: 'avatar' | string;
-}
-interface OnUploadCompletePayload {
-    userId: string;
-    fileName: string;
-    sizeBytes: number;
-    uploadKind: 'avatar' | string;
-}
-interface PreAvatarServePayload {
-    /** The route path requested (`/avatars/:fileId`). */
-    routePath: string;
-    /** The allowlisted file id resolved from the route path. */
-    fileId: string;
-}
-interface PostAvatarServePayload {
-    routePath: string;
-    fileId: string;
-    /** Disk extension of the format that was served (e.g. `'webp'`). */
-    extension: string;
-    /** Content-Type header sent for the served file. */
-    contentType: string;
-}
-interface CsrfMismatchPayload {
-    /** Path of the rejected request. */
-    route: string;
-    /** HTTP method of the rejected request. */
-    method?: string;
-    /** Request id (X-Request-Id) for log correlation. */
-    requestId?: string;
-    /** User id from the session that the request claimed, if any. */
-    userId?: string;
-    /** Whether a token was provided in `x-csrf-token` (presence only — never the value). */
-    providedToken: boolean;
-}
-interface PreSocketMessagePayload {
-    /** Which socket pipeline received the message. */
-    channel: 'api' | 'sync';
-    /** Socket.io connection id of the originator. */
-    socketId: string;
-    /** Handshake address of the originator (best-effort; honours no proxy trust). */
-    ip: string;
-    /** Whether the originating socket carried a session token (presence only — never the value). */
-    authenticated: boolean;
-    /** Raw route name from the message envelope, when present (un-parsed, un-trusted). */
-    routeName?: string;
-}
-interface PreHttpRequestPayload {
-    /** HTTP method (always uppercase: GET/POST/...). */
-    method: string;
-    /** Request URL (path + query). */
-    url: string;
-    /** Caller-supplied or framework-generated `X-Request-Id`. */
-    requestId: string;
-    /** Origin header value (or empty string when absent). */
-    origin: string;
-    /**
-     * Subset of headers — `authorization`, `cookie`, etc. are NOT included
-     * to keep payloads safe for logging. Use the full request object via
-     * a custom route if you need raw access.
-     */
-    headers: Record<string, string>;
-}
-interface PostHttpRequestPayload {
-    /** HTTP method (always uppercase). */
-    method: string;
-    /** Request URL (path + query). */
-    url: string;
-    /** Caller-supplied or framework-generated `X-Request-Id`. */
-    requestId: string;
-    /** Final HTTP status code written to the response. */
-    statusCode: number;
-    /** Wall-clock duration from request receipt to response, in ms. */
-    durationMs: number;
-}
-interface ApiAuthRejectedPayload {
-    /** Resolved route name (`api/billing/getInvoice/v1`). */
-    routeName: string;
-    /** Why auth failed. `'login-required'` = no/invalid session on a login route;
-     *  `'additional-failed'` = a session existed but an `additional[]` predicate
-     *  rejected; `'invalid-condition'` = a misconfigured predicate (setup error). */
-    reason: 'login-required' | 'additional-failed' | 'invalid-condition';
-    /** Session user id when a (insufficient) session was present, else null. */
-    userId: string | null;
-    /** Resolved client IP (honours `http.trustProxy`). */
-    ip?: string;
-    /** Transport the request arrived on. */
-    transport?: 'socket' | 'http';
-    /** The specific `additional[]` key that failed, when `reason === 'additional-failed'`. */
-    failedKey?: string;
-}
-interface PreSyncRecipientPayload {
-    /** Resolved route name (`sync/board/moveCard/v1`). */
-    routeName: string;
-    /** Room code / receiver this fanout is for. */
-    receiver: string;
-    /** Socket id of THIS recipient. */
-    recipientSocketId: string;
-    /**
-     * Session token of THIS recipient, as read from its socket handshake — the
-     * same value the fan-out uses for `ignoreSelf`. `null` for an anonymous
-     * socket. Cheap: no session read is performed to produce it.
-     */
-    recipientToken: string | null;
-    /**
-     * Always `null`. Kept on the payload for backward compatibility; resolve the
-     * user from `recipientToken` when you need it.
-     */
-    recipientUserId: string | null;
-    /** The server-validated output about to be sent. */
-    serverOutput: unknown;
-}
-interface PreServerStopPayload {
-    /** Why the server is stopping — the signal name, or `'manual'` for a programmatic stop. */
-    reason: 'SIGTERM' | 'SIGINT' | 'SIGHUP' | 'manual';
-    /**
-     * Soft budget (ms) the server intends to wait for shutdown handlers + in-flight
-     * requests to drain before forcing exit. Handlers should not block longer than
-     * this. `undefined` when the server applies no deadline.
-     */
-    timeoutMs?: number;
-}
-interface HookPayloads {
-    preHttpRequest: PreHttpRequestPayload;
-    postHttpRequest: PostHttpRequestPayload;
-    preSocketMessage: PreSocketMessagePayload;
-    preApiValidate: PreApiValidatePayload;
-    postApiValidate: PostApiValidatePayload;
-    preApiExecute: PreApiExecutePayload;
-    postApiExecute: PostApiExecutePayload;
-    preApiRespond: PreApiRespondPayload;
-    transformApiResponse: PreApiRespondPayload;
-    postApiRespond: PostApiRespondPayload;
-    preSyncAuthorize: PreSyncAuthorizePayload;
-    postSyncAuthorize: PostSyncAuthorizePayload;
-    preSyncValidate: PreSyncValidatePayload;
-    postSyncValidate: PostSyncValidatePayload;
-    preSyncExecute: PreSyncExecutePayload;
-    postSyncExecute: PostSyncExecutePayload;
-    preSyncFanout: PreSyncFanoutPayload;
-    postSyncFanout: PostSyncFanoutPayload;
-    preSyncRecipient: PreSyncRecipientPayload;
-    preSyncStream: PreSyncStreamPayload;
-    postSyncStream: PostSyncStreamPayload;
-    apiError: ApiErrorPayload;
-    syncError: SyncErrorPayload;
-    apiAuthRejected: ApiAuthRejectedPayload;
-    rateLimitExceeded: RateLimitExceededPayload;
-    corsRejected: CorsRejectedPayload;
-    csrfMismatch: CsrfMismatchPayload;
-    preSessionRefresh: PreSessionRefreshPayload;
-    postSessionRefresh: PostSessionRefreshPayload;
-    sessionCreated: SessionCreatedPayload;
-    sessionRevoked: SessionRevokedPayload;
-    onUploadStart: OnUploadStartPayload;
-    onUploadComplete: OnUploadCompletePayload;
-    preAvatarServe: PreAvatarServePayload;
-    postAvatarServe: PostAvatarServePayload;
-    preServerStop: PreServerStopPayload;
-}
-interface PreErrorNormalizePayload {
-    response: ErrorResponseInput;
-    preferredLocale?: string | null;
-    userLanguage?: string | null;
-    fallbackHttpStatus?: number;
-}
-interface PostErrorNormalizePayload {
-    normalized: NormalizedErrorResponse;
-    preferredLocale?: string | null;
-    userLanguage?: string | null;
-}
-interface SyncHookPayloads {
-    preErrorNormalize: PreErrorNormalizePayload;
-    postErrorNormalize: PostErrorNormalizePayload;
-}
-type SyncHookName = keyof SyncHookPayloads;
-type SyncHookHandler<TPayload> = (payload: TPayload) => void;
-type HookName = keyof HookPayloads;
-
-type DispatchResult = {
-    stopped: false;
-} | {
-    stopped: true;
-    signal: HookStopSignal;
-};
-declare const registerHook: <TName extends HookName>(name: TName, handler: HookHandler<HookPayloads[TName]>) => (() => void);
-declare const dispatchHook: <TName extends HookName>(name: TName, payload: HookPayloads[TName]) => Promise<DispatchResult>;
-declare const clearAllHooks: () => void;
-declare const registerSyncHook: <TName extends SyncHookName>(name: TName, handler: SyncHookHandler<SyncHookPayloads[TName]>) => (() => void);
-declare const dispatchSyncHook: <TName extends SyncHookName>(name: TName, payload: SyncHookPayloads[TName]) => void;
-
-export { type ApiAuthRejectedPayload, type ApiErrorPayload, type ApiResponseEnvelope, AuthProps, type AvatarConfig, type AvatarConfigInput, BOOT_KEY_PREFIX, BaseSessionLayout, type BootUuidHeartbeat, type CheckRateLimitParams, type CookiePrefixConstraints, type CorsRejectedPayload, type CreateLocalizedNormalizerInput, type CsrfConfig, type CsrfCookieOptions, type CsrfMismatchPayload, DEFAULT_AVATAR_CONFIG, DEFAULT_CLIENT_KEY, DEFAULT_CSRF_CONFIG, DEFAULT_ENV_FILES, DEFAULT_REDACTED_LOG_KEYS, DEPTH_TRUNCATED_PLACEHOLDER, type DbHealthCheck, type DbHealthResult, DeepPartial, type DispatchResult, type EmailAttachment, type EmailDeliveryOutcome, type EmailMessage, type EmailResult, type EmailSendContext, type EmailSender, type EmailSenderRegistry, type ErrorFormatter, type ErrorFormatterContext, ErrorParam, ErrorResponseInput, type ErrorTracker, type ErrorTrackerContext, type ErrorTrackerEvent, type ErrorTrackerUser, type FormatterEnvelope, GENERATED_API_DOCS_PATH, GENERATED_API_SCHEMAS_PATH, GENERATED_SOCKET_TYPES_PATH, type GetIoInstanceOptions, type GetRoomSocketsOptions, HealthHashConfig, type HealthHashDescriptor, type HookHandler, type HookName, type HookPayloads, type HookResult, type HookSessionShape, type HookStopSignal, type HttpMethod, type LanguageCode, LocalSocketEnumerationError, type LocaleReloader, type LocalizedNormalizer, type NormalizeErrorResponseInput, NormalizedErrorResponse, type OnUploadCompletePayload, type OnUploadStartPayload, type OneTimeTokenHandle, PUBLIC_DIR, type PeerRequire, type PostApiExecutePayload, type PostApiRespondPayload, type PostApiValidatePayload, type PostAvatarServePayload, type PostErrorNormalizePayload, type PostHttpRequestPayload, type PostSessionRefreshPayload, type PostSyncAuthorizePayload, type PostSyncExecutePayload, type PostSyncFanoutPayload, type PostSyncValidatePayload, type PreApiExecutePayload, type PreApiRespondPayload, type PreApiValidatePayload, type PreAvatarServePayload, type PreCaptureFilter, type PreErrorNormalizePayload, type PreHttpRequestPayload, type PreServerStopPayload, type PreSessionRefreshPayload, type PreSocketMessagePayload, type PreSyncAuthorizePayload, type PreSyncExecutePayload, type PreSyncFanoutPayload, type PreSyncRecipientPayload, type PreSyncValidatePayload, type ProcessUploadInput, type ProcessUploadResult, REDACTED_PLACEHOLDER, ROOT_DIR, type RateLimitExceededPayload, type RateLimitResult, type RateLimitStrategy, type RedisConnectionOptions, type RedisKeyFormatter, type Registry, type RegistryOptions, type ResolveClientIpParams, type RoomNameFormatter, type RoomNameFormatterContext, type RoomSocket, type RuntimeApiMapsResult, type RuntimeEnv, type RuntimeMapsProvider, type RuntimeSyncMapsResult, SERVER_DIR, SERVER_FUNCTIONS_DIR, SHARED_DIR, SRC_DIR, type SessionCreatedPayload, type SessionLogoutInput, type SessionProvider, type SessionRevokedPayload, type SessionSaveResult, type SocketMiddleware, type SpanHandle, type SpanResult, type SyncErrorPayload, type SyncHookHandler, type SyncHookName, type SyncHookPayloads, TEST_DIRECTORY_NAMES, TEST_FILE_PATTERN, TSCONFIG_ALIAS_FILES, type TranslateFunction, type TranslateInput, UNKNOWN_CLIENT_IP, UPLOADS_DIR, type ValidationResult$1 as ValidationResult, abortAllForSocket, abortApiByResponseIndex, abortSyncByCb, acquireLease, allowedOrigin, type apiMessage, appendErrorTracker, applyCookiePrefixConstraints, applyErrorFormatter, applySocketMiddlewares, applyStrayKeyPrefix, attachSocketRedisAdapter, bootstrapEnv, captureException, captureExceptionAcrossTrackers, captureMessage, captureMessageAcrossTrackers, checkRateLimit, clearAllHooks, clearAllRateLimits, clearRateLimit, clearSocketMiddlewares, collectSynchronizedEnvKeys, computeSynchronizedEnvHashes, consumeOneTimeToken, consumeOneTimeTokenJson, createLocalizedNormalizer, createRegistry, defaultRateLimitStrategy, defaultRedisKeyFormatter, defaultRoomNameFormatter, deriveTokenBucketId, describeHealthHashConfig, dispatchHook, dispatchSyncHook, ensurePeerDepInstalled, env, escapeHtml, extractLanguageFromHeader, extractTokenFromRequest, extractTokenFromSocket, flushErrorTrackers, formatKey, formatRoomName, getActiveErrorTrackers, getAvatarConfig, getBindAddress, getCookieValue, getCsrfConfig, getCurrentErrorTrackerIdentity, getDbHealthCheck, getEffectiveHttpMethod, getEmailSender, getEmailSenderByName, getEnv, getEnvFiles, getErrorFormatter, getGeneratedApiDocsPath, getGeneratedApiSchemasPath, getGeneratedSocketTypesPath, getIoInstance, getLocaleReloader, getLocalizedNormalizer, getParams, getPrismaClient, getPrismaClientFor, getPrismaClientKeys, getPublicDir, getRateLimitStatus, getRateLimitStrategy, getRedactedLogKeys, getRedisClient, getRedisClientFor, getRedisClientKeys, getRedisConnectionOptions, getRedisKeyFormatter, getRegisteredSessionProvider, getRoomNameFormatter, getRoomSockets, getRuntimeApiMaps, getRuntimeSyncMaps, getServerDir, getServerFunctionDirs, getServerFunctionsDir, getSharedDir, getSocketMiddlewares, getSrcDir, getUploadsDir, hasCookie, hashSynchronizedValue, hashSynchronizedValueWith, inferHttpMethod, initConsolelog, initSharedSentry, isDbHealthCheckRegistered, isEmailSenderRegistered, isFalsy, isGetMethodName, isLocalizedNormalizerRegistered, isLoopbackIp, isMethodAllowed, isPrismaClientRegistered, isPrismaClientResolvable, isProduction, isProductionRuntime, isRedactedLogKey, isRedisClientRegistered, isRuntimeMapsProviderRegistered, isSessionProviderRegistered, isTestDirectory, isTestFile, isTestRuntime, issueOneTimeToken, listEmailSenderNames, loadEnvFiles, loadPeer, normalizeErrorResponse, normalizeOrigin, oneTimeTokenKey, performLogout, prisma, processUpload, readBootUuid, readSession, rebuildDefaultRedisClient, recordMetricAcrossTrackers, redis, refreshBootUuid, registerApiAbortController, registerAvatarConfig, registerBindAddress, registerBoundAddress, registerCsrfConfig, registerDbHealthCheck, registerEmailSender, registerEmailSenders, registerErrorFormatter, registerErrorTracker, registerErrorTrackers, registerHook, registerLocaleReloader, registerLocalizedNormalizer, registerPreCaptureFilter, registerPrismaClient, registerRateLimitStrategy, registerRedactedLogKeys, registerRedisClient, registerRedisKeyFormatter, registerRoomNameFormatter, registerRuntimeMapsProvider, registerSessionProvider, registerSocketMiddleware, registerStrayPrefixCommand, registerSyncAbortController, registerSyncHook, releaseLease, removeSession, renewLease, resetClientsForTests, resetCsrfConfigForTests, resetDbHealthCheckForTests, resetDefaultRedisClient, resetRedactedLogKeysForTests, resetRedisKeyFormatterForTests, resetSessionProviderForTests, resolveClientIp, resolveDevCallbackUrl, resolveEnvKey, resolveErrorMessage, resolveFromRoot, resolveHealthHashConfig, resolveHealthHashConfigFromDescriptor, resolveRuntimeMode, resolveSocketAdapterKey, runWithErrorTrackerIdentity, runWithErrorTrackerIdentityScope, sanitizeErrorString, sanitizeErrorStrings, sanitizeForLog, serveAvatar, setCurrentErrorTrackerIdentity, setErrorTrackerUser, setIoInstance, setSentryUser, startBootUuidHeartbeat, startSpan, startSpanAcrossTrackers, startSpanHandle, type syncMessage, tryCatch, unregisterApiAbortController, unregisterSyncAbortController, validateInputByType, validateRequest, writeBootUuid, writeSession };
+export { default as sleep } from './sleep.js';
+export { default as tryCatch } from './tryCatch.js';
+export { default as tryCatchSync } from './tryCatchSync.js';
+export { deepMerge, isPlainObject } from './configUtils.js';
+export type { DeepPartial } from './configUtils.js';
+export { createRegistry } from './createRegistry.js';
+export type { Registry, RegistryOptions } from './createRegistry.js';
+export { escapeHtml } from './escapeHtml.js';
+export { ROUTED_DATA_QUERY_KEY, buildRoutedGetUrl } from './routedDataQuery.js';
+export { ensurePeerDepInstalled, loadPeer } from './peerDeps.js';
+export type { PeerRequire } from './peerDeps.js';
+export * from './serviceRoute.js';
+export * from './socketEvents.js';
+export { isTestFile, isTestDirectory, TEST_FILE_PATTERN, TEST_DIRECTORY_NAMES, } from './testFileConvention.js';
+export { registerRoomNameFormatter, getRoomNameFormatter, formatRoomName, defaultRoomNameFormatter, } from './roomNameFormatterRegistry.js';
+export type { RoomNameFormatter, RoomNameFormatterContext } from './roomNameFormatterRegistry.js';
+export * from './responseNormalizer.js';
+export * from './localizedNormalizer.js';
+export { registerErrorFormatter, getErrorFormatter, applyErrorFormatter, } from './errorFormatterRegistry.js';
+export type { ErrorFormatter, ErrorFormatterContext, FormatterEnvelope } from './errorFormatterRegistry.js';
+export { validatePagePath, DEFAULT_PAGE_ROUTE_RULES, } from './pageRouteValidation.js';
+export type { PageRouteRules, PagePathValidationResult, } from './pageRouteValidation.js';
+export type { ApiTypeMap, SyncTypeMap, StreamPayload } from './apiTypeStubs.js';
+export type { apiMessage, syncMessage } from './socketTypes.js';
+export { setIoInstance, getIoInstance } from './socketTypes.js';
+export type { GetIoInstanceOptions } from './socketTypes.js';
+export { LocalSocketEnumerationError } from './localSocketEnumerationGuard.js';
+export { getRoomSockets } from './roomSockets.js';
+export type { GetRoomSocketsOptions, RoomSocket } from './roomSockets.js';
+export { registerProjectConfig, getProjectConfig, getProjectName, isProjectConfigRegistered, DEFAULT_PROJECT_CONFIG, } from './projectConfig.js';
+export { registerPortOverride, getPortOverride, resetPortOverrideForTests, } from './portOverrideRegistry.js';
+export type { ProjectConfig, ProjectConfigInput, AppConfig, LoggingConfig, RateLimitingConfig, SessionConfig, HttpConfig, HttpStreamConfig, HealthHashConfig, SecurityHeadersConfig, CorsConfig, AuthConfig, AuthRateLimitConfig, RateLimitIdentity, RateLimitIdentityParams, PasswordPolicyConfig, SocketConfig, ApiConfig, ValidationConfig, SyncConfig, SyncStreamThrottleConfig, SyncFlushPressureConfig, OfflineQueueConfig, DevConfig, PathsConfig, } from './projectConfig.js';
+export { registerRuntimeMapsProvider, getRuntimeApiMaps, getRuntimeSyncMaps, isRuntimeMapsProviderRegistered, } from './runtimeMapsRegistry.js';
+export { registerApiMethodMap, getRegisteredApiMethod, isApiMethodMapRegistered, } from './apiMethodMapRegistry.js';
+export type { HttpMethodLiteral, ApiMethodMap } from './apiMethodMapRegistry.js';
+export type { RuntimeMapsProvider, RuntimeApiMapsResult, RuntimeSyncMapsResult, } from './runtimeMapsRegistry.js';
+export { registerNotifier, getNotifier, notify, } from './notifier.js';
+export type { Notifier, NotifyInput, NotifyParam } from './notifier.js';
+export { registerEmailSender, registerEmailSenders, getEmailSender, getEmailSenderByName, listEmailSenderNames, isEmailSenderRegistered, } from './emailRegistry.js';
+export type { EmailDeliveryOutcome, EmailSendContext, EmailSender, EmailMessage, EmailAttachment, EmailResult, EmailSenderRegistry, } from './emailRegistry.js';
+export { registerDeployConfig, getDeployConfig, isDeployConfigRegistered, } from './deployConfigRegistry.js';
+export type { DeployConfigShape, DeployResourceShape, DeployEnvironmentShape, DeployRoutingShape, DeployDevelopmentShape, } from './deployConfigRegistry.js';
+export { registerServicesConfig, getServicesConfig, isServicesConfigRegistered, } from './servicesConfigRegistry.js';
+export type { ServicesConfigShape, ServiceDefinition, PresetDefinition, } from './servicesConfigRegistry.js';
+export { registerLocaleReloader, getLocaleReloader, } from './localeReloader.js';
+export type { LocaleReloader } from './localeReloader.js';
+export type { statusContent, SOCKETSTATUS } from './socketStatusTypes.js';
+export type { BaseSessionLayout, SessionLocation, AuthProps, Jsonify } from './sessionTypes.js';
+export * from './sentrySetup.js';
+export { registerErrorTracker, registerErrorTrackers, appendErrorTracker, getActiveErrorTrackers, captureExceptionAcrossTrackers, captureMessageAcrossTrackers, setErrorTrackerUser, recordMetricAcrossTrackers, startSpanAcrossTrackers, startSpanHandle, registerPreCaptureFilter, flushErrorTrackers, sanitizeErrorString, sanitizeErrorStrings, } from './errorTrackerRegistry.js';
+export type { ErrorTracker, ErrorTrackerContext, ErrorTrackerUser, ErrorTrackerEvent, SpanResult, SpanHandle, PreCaptureFilter, } from './errorTrackerRegistry.js';
+export { runWithErrorTrackerIdentity, runWithErrorTrackerIdentityScope, setCurrentErrorTrackerIdentity, getCurrentErrorTrackerIdentity, } from './errorTrackerIdentity.js';
+export * from './env.js';
+export * from './db.js';
+export { registerDbHealthCheck, getDbHealthCheck, isDbHealthCheckRegistered, resetDbHealthCheckForTests, } from './dbHealthCheck.js';
+export type { DbHealthCheck, DbHealthResult } from './dbHealthCheck.js';
+export { redis, getRedisConnectionOptions, registerStrayPrefixCommand, resetDefaultRedisClient, rebuildDefaultRedisClient } from './redis.js';
+export type { RedisConnectionOptions } from './redis.js';
+export { registerSecretsResolvedListener, notifySecretsResolved } from './secretsResolved.js';
+export type { SecretsResolvedListener } from './secretsResolved.js';
+export { registerRedisKeyFormatter, getRedisKeyFormatter, resetRedisKeyFormatterForTests, defaultRedisKeyFormatter, formatKey, applyStrayKeyPrefix, } from './redisKeyFormatter.js';
+export type { RedisKeyFormatter } from './redisKeyFormatter.js';
+export { acquireLease, renewLease, releaseLease } from './lease.js';
+export { DEFAULT_CLIENT_KEY, registerPrismaClient, registerRedisClient, getPrismaClient, getRedisClient, getPrismaClientFor, getRedisClientFor, getPrismaClientKeys, getRedisClientKeys, isPrismaClientRegistered, isRedisClientRegistered, resetClientsForTests, } from './clients.js';
+export { attachSocketRedisAdapter, resolveSocketAdapterKey } from './socketRedisAdapter.js';
+export { writeBootUuid, readBootUuid, refreshBootUuid, startBootUuidHeartbeat, resolveEnvKey, BOOT_KEY_PREFIX, type BootUuidHeartbeat, } from './bootUuid.js';
+export { collectSynchronizedEnvKeys, computeSynchronizedEnvHashes, hashSynchronizedValue, hashSynchronizedValueWith, resolveHealthHashConfig, describeHealthHashConfig, resolveHealthHashConfigFromDescriptor, } from './synchronizedEnvHashes.js';
+export type { HealthHashDescriptor } from './synchronizedEnvHashes.js';
+export { initConsolelog } from './consoleLog.js';
+export { registerLogger, getLogger, isLoggerRegistered, resetLoggerForTests, createDevLogger, } from './loggerRegistry.js';
+export type { Logger, LoggerContext } from './loggerRegistry.js';
+export { registerRedactedLogKeys, getRedactedLogKeys, isRedactedLogKey, resetRedactedLogKeysForTests, sanitizeForLog, DEFAULT_REDACTED_LOG_KEYS, REDACTED_PLACEHOLDER, DEPTH_TRUNCATED_PLACEHOLDER, } from './redactedLogKeys.js';
+export * from './cookies.js';
+export * from './httpApiUtils.js';
+export * from './paths.js';
+export { registerSocketMiddleware, getSocketMiddlewares, clearSocketMiddlewares, applySocketMiddlewares, } from './socketMiddlewareRegistry.js';
+export type { SocketMiddleware } from './socketMiddlewareRegistry.js';
+export { registerCsrfConfig, getCsrfConfig, resetCsrfConfigForTests, DEFAULT_CSRF_CONFIG, } from './csrfConfig.js';
+export type { CsrfConfig, CsrfCookieOptions } from './csrfConfig.js';
+export { serveAvatar } from './serveAvatars.js';
+export { processUpload } from './processUpload.js';
+export type { ProcessUploadInput, ProcessUploadResult } from './processUpload.js';
+export { registerBindAddress, registerBoundAddress, getBindAddress, resolveDevCallbackUrl } from './bindAddress.js';
+export { registerAvatarConfig, getAvatarConfig, DEFAULT_AVATAR_CONFIG, } from './avatarConfig.js';
+export type { AvatarConfig, AvatarConfigInput } from './avatarConfig.js';
+export { default as getParams } from './getParams.js';
+export { extractTokenFromSocket } from './extractToken.js';
+export { extractTokenFromRequest } from './extractTokenFromRequest.js';
+export { resolveClientIp, isLoopbackIp, UNKNOWN_CLIENT_IP, deriveTokenBucketId } from './resolveClientIp.js';
+export type { ResolveClientIpParams } from './resolveClientIp.js';
+export { registerSessionProvider, getRegisteredSessionProvider, isSessionProviderRegistered, resetSessionProviderForTests, readSession, writeSession, removeSession, performLogout, } from './sessionProviderRegistry.js';
+export type { SessionProvider, SessionSaveResult, SessionLogoutInput } from './sessionProviderRegistry.js';
+export { validateRequest, isFalsy } from './validateRequest.js';
+export type { ValidationResult } from './validateRequest.js';
+export { checkRateLimit, getRateLimitStatus, clearRateLimit, clearAllRateLimits, registerRateLimitStrategy, getRateLimitStrategy, defaultRateLimitStrategy, } from './rateLimiter.js';
+export type { RateLimitStrategy, CheckRateLimitParams, RateLimitResult } from './rateLimiter.js';
+export { validateInputByType } from './runtimeTypeValidation.js';
+export { default as allowedOrigin, normalizeOrigin } from './checkOrigin.js';
+export { isOnline, enqueueApiRequest, enqueueSyncRequest, removeApiQueueItem, removeSyncQueueItem, removeApiQueueItemsByKey, flushApiQueue, flushSyncQueue, getApiQueueSize, getSyncQueueSize, } from './offlineQueue.js';
+export type { QueueDropReason } from './offlineQueue.js';
+export { socket, setSocket, incrementResponseIndex, waitForSocket } from './socketState.js';
+export { registerSyncAbortController, unregisterSyncAbortController, abortSyncByCb, registerApiAbortController, unregisterApiAbortController, abortApiByResponseIndex, abortAllForSocket, } from './cancelRegistry.js';
+export { getCsrfToken, clearCsrfToken, httpFetch } from './csrf.js';
+export { TEST_RESET_TARGETS, TEST_RESET_ONLY_PARAM, isTestResetTarget, } from './testResetTargets.js';
+export type { TestResetTarget } from './testResetTargets.js';
+export { issueOneTimeToken, consumeOneTimeToken, consumeOneTimeTokenJson, oneTimeTokenKey, } from './oneTimeToken.js';
+export type { OneTimeTokenHandle } from './oneTimeToken.js';
+export { registerHook, dispatchHook, clearAllHooks, registerSyncHook, dispatchSyncHook } from './hooks/registry.js';
+export type { DispatchResult } from './hooks/registry.js';
+export type { HookSessionShape, HookStopSignal, HookResult, HookHandler, HookName, HookPayloads, PreApiValidatePayload, PostApiValidatePayload, PreApiExecutePayload, PostApiExecutePayload, PreApiRespondPayload, PostApiRespondPayload, ApiResponseEnvelope, PreHttpRequestPayload, PostHttpRequestPayload, PreSocketMessagePayload, PreSyncAuthorizePayload, PostSyncAuthorizePayload, PreSyncValidatePayload, PostSyncValidatePayload, PreSyncExecutePayload, PostSyncExecutePayload, PreSyncFanoutPayload, PostSyncFanoutPayload, PreSyncRecipientPayload, ApiErrorPayload, SyncErrorPayload, ApiAuthRejectedPayload, RateLimitExceededPayload, CorsRejectedPayload, CsrfMismatchPayload, PreSessionRefreshPayload, PostSessionRefreshPayload, SessionCreatedPayload, SessionRevokedPayload, OnUploadStartPayload, OnUploadCompletePayload, PreAvatarServePayload, PostAvatarServePayload, PreServerStopPayload, SyncHookName, SyncHookHandler, SyncHookPayloads, PreErrorNormalizePayload, PostErrorNormalizePayload, } from './hooks/types.js';