@luckystack/core 0.1.8 → 0.2.0

package/dist/{pageRouteValidation-CxZJVwZh.d.ts → pageRouteValidation-BoZ-rQWi.d.ts}

@@ -2,7 +2,22 @@ import { Socket } from 'socket.io-client';
 
 declare function sleep(ms: number): Promise<void>;
 
-declare function tryCatch<T, P>(func: (values: P) => Promise<T> | T, params?: P, context?: Record<string, unknown>): Promise<[Error | null, T | null]>;
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object | undefined ? DeepPartial<NonNullable<T[K]>> : T[K];
+};
+/**
+ * True when `value` is a plain object literal (prototype is `Object.prototype`
+ * or `null`). Arrays, class instances, Maps, Dates, and `null` are rejected so
+ * they are treated as opaque replacement values during a merge.
+ */
+declare const isPlainObject: (value: unknown) => value is Record<string, unknown>;
+/**
+ * Deep-merge a deep-partial `override` over a fully-populated `base`,
+ * returning a new object. See the module header for the exact behaviour
+ * contract. Arrays and non-plain-object values are replaced wholesale; nested
+ * plain objects merge recursively; `undefined` override values are ignored.
+ */
+declare const deepMerge: <T>(base: T, override: DeepPartial<T> | undefined) => T;
 
 interface LoggingConfig {
     devLogs: boolean;
@@ -26,6 +41,77 @@ interface RateLimitingConfig {
     windowMs: number;
     /** How often the in-memory store evicts expired entries. */
     cleanupIntervalMs: number;
+    /**
+     * What the default strategy does when `store: 'redis'` is active but a Redis
+     * operation fails (disconnect, eval error). DEFAULT `'memory'` — degrade to
+     * the process-local in-memory store (fail-open, backwards-compatible) and log
+     * a one-shot warning. In a multi-instance deployment this silently relaxes the
+     * global limit to per-instance (N×). Set `'deny'` to instead reject the
+     * request (fail-closed) so a Redis outage can't bypass rate limiting.
+     */
+    onStoreError: 'memory' | 'deny';
+    /**
+     * Skip rate limiting for requests that resolve to a loopback client IP
+     * (`127.0.0.1`, `::1`, the `UNKNOWN_CLIENT_IP` sentinel) when running in
+     * development (`NODE_ENV !== 'production'`). Lets a dev machine hammer its own
+     * server (HMR reload storms, local load tests) without tripping limits, while
+     * staying fully enforced in production. DEFAULT `false` (enforce everywhere) —
+     * a missing key keeps today's behavior. The api/sync transport handlers read
+     * this when building the per-IP key; core only owns the flag + the
+     * {@link isLoopbackIp} helper.
+     */
+    skipLoopbackInDev: boolean;
+    /**
+     * Identity callback that decides the BASIS of a rate-limit key for a given
+     * request — i.e. whether to key per-user, per-IP, or some custom dimension.
+     * The api/sync handlers call this (when set) to derive the `{ scope, id }`
+     * used to build the bucket key, instead of the built-in user-then-IP default.
+     * Returning `null` falls back to the framework default. Synchronous by design
+     * (it runs on the hot request path). DEFAULT unset.
+     */
+    identity?: (params: RateLimitIdentityParams) => RateLimitIdentity | null;
+    /**
+     * Per-account brute-force lockout slot, keyed independently from the general
+     * api/ip limits so credential endpoints (login, password-reset) can apply a
+     * stricter window without affecting normal traffic.
+     *
+     * NOTE — DD-CORE-D3: **core does NOT consume this slot**. The core package
+     * only declares and stores the config; the `@luckystack/login` package reads
+     * `rateLimiting.auth` when keying a per-account attempt counter
+     * (`auth:<accountKey>`). If you search the core source for usages of this
+     * field and find none, that is expected — it is not dead config; it is login-
+     * owned config that lives here for a single source of truth.
+     *
+     * DEFAULT `{ enabled: false }` — a missing/disabled slot keeps today's
+     * behavior (no per-account lockout; only the per-IP throttle applies).
+     */
+    auth: AuthRateLimitConfig;
+}
+/** Inputs handed to the {@link RateLimitingConfig.identity} callback. */
+interface RateLimitIdentityParams {
+    /** Resolved route name (`api/billing/getInvoice/v1`, `sync/...`). */
+    routeName: string;
+    /** Session user id when the request is authenticated, else null. */
+    userId: string | null;
+    /** Resolved client IP (already honours `http.trustProxy`). */
+    ip: string;
+    /** Transport the request arrived on. */
+    transport: 'socket' | 'http';
+}
+/** Result of a {@link RateLimitingConfig.identity} callback. */
+interface RateLimitIdentity {
+    /** Which dimension the key is built from. */
+    scope: 'user' | 'ip' | 'custom';
+    /** The identity value (user id, ip, or a custom string). Never a raw token. */
+    id: string;
+}
+interface AuthRateLimitConfig {
+    /** When false (default), no per-account lockout is applied. */
+    enabled: boolean;
+    /** Max failed attempts per account within `windowMs` before lockout. Default 5. */
+    maxAttempts: number;
+    /** Rolling window in ms over which `maxAttempts` is counted. Default 900000 (15 min). */
+    windowMs: number;
 }
 interface SessionConfig {
     basedToken: boolean;
@@ -123,11 +209,49 @@ interface CorsConfig {
      * production deployments fail closed.
      */
     allowLocalhost: boolean;
+    /**
+     * Allow WebSocket upgrades that carry NO `Origin` header (server-to-server
+     * native WS clients, proxies). Defaults to `false` (fail-closed): an
+     * origin-less upgrade is rejected because the Socket.io CORS layer is the
+     * last browser-origin gate on the WS path. Set to `true` only when your
+     * architecture includes a non-browser WS consumer (e.g. a backend service
+     * connecting to push events).
+     */
+    allowOriginless?: boolean;
 }
 interface HttpConfig {
     sessionCookieName: string;
     sessionCookieSameSite: 'Strict' | 'Lax' | 'None';
     sessionCookiePath: string;
+    /**
+     * Optional `Domain` attribute for the session cookie (CORE-39). Leave unset
+     * (DEFAULT) for a host-only cookie (most secure). Set to a parent domain
+     * (`.example.com`) only when the cookie must be shared across subdomains.
+     * IGNORED when `sessionCookiePrefix === '__Host-'` (that prefix forbids
+     * `Domain`). A missing key keeps today's host-only behavior.
+     */
+    sessionCookieDomain?: string;
+    /**
+     * Optional cookie name prefix enforcing browser-level guarantees (CORE-10/39):
+     *
+     * - `'__Host-'` — forces `Secure`, `Path=/`, and NO `Domain` (blocks
+     *   subdomain cookie-tossing). The strongest option for a host-only session.
+     * - `'__Secure-'` — forces `Secure` (cookie only sent over HTTPS).
+     * - unset (DEFAULT) — no prefix; today's behavior. A missing key changes
+     *   nothing.
+     *
+     * The server's cookie builder (`buildSessionCookie`) reads this and applies
+     * the prefix to `sessionCookieName` plus the forced attributes. Use
+     * {@link applyCookiePrefixConstraints} to compute the effective attributes.
+     */
+    sessionCookiePrefix?: '__Host-' | '__Secure-';
+    /**
+     * Per-cookie `Secure` override (CORE-39). When unset (DEFAULT) the server
+     * derives `Secure` from `process.env.SECURE` as today. Set explicitly to
+     * force on/off independently of the env flag. A `__Host-`/`__Secure-` prefix
+     * forces `Secure: true` regardless.
+     */
+    sessionCookieSecure?: boolean;
     /** Maximum body size accepted on `/api/*` and `/sync/*` POSTs. */
     requestBodyMaxBytes: number;
     /** Path of the router boot-handshake endpoint. */
@@ -144,10 +268,81 @@ interface HttpConfig {
     readyEndpoint: string;
     /** Path of the dev-only state-reset endpoint (gated by NODE_ENV + token). */
     testResetEndpoint: string;
+    /**
+     * Whether a known reverse proxy sits in front of this server. DEFAULT false.
+     * When false, per-IP rate-limit keys derive from the raw transport peer
+     * address (historical behaviour). When true, the framework resolves the real
+     * client IP from `X-Forwarded-For` / `X-Real-IP` before keying — so per-IP
+     * limits stay meaningful behind nginx/HAProxy. Only enable when a trusted
+     * proxy populates those headers, otherwise clients can spoof their IP.
+     */
+    trustProxy?: boolean;
+    /**
+     * How many proxy hops to skip from the RIGHT of `X-Forwarded-For` when
+     * `trustProxy` is on (CORE-O3). The rightmost entries are the ones appended by
+     * YOUR trusted proxies, so the resolved client IP is the entry that many hops
+     * in from the end. The LEFTMOST hop is client-controlled and must never be
+     * trusted (it enables per-IP rate-limit evasion + audit-IP spoofing).
+     *
+     * DEFAULT 1 — with the standard single-trusted-proxy topology this selects the
+     * immediate upstream peer (the rightmost real hop), i.e. the IP the proxy saw
+     * the connection arrive from. Raise it to match the number of trusted proxies
+     * in the chain. Clamped to the list length so an over-large count falls back
+     * to the leftmost available trusted hop rather than the spoofable client entry.
+     * IGNORED when `trustProxy` is false (raw peer address is used verbatim).
+     */
+    trustedProxyHopCount?: number;
+    /**
+     * Whether cookie-mode sessions (`session.basedToken === false`) also accept a
+     * token supplied via `Authorization: Bearer` / `handshake.auth.token` as a
+     * fallback (CORE-O10). DEFAULT false — in cookie-mode the framework reads ONLY
+     * the session cookie and ignores any bearer/handshake-auth token, so a stolen
+     * token replayed through a header can no longer defeat the cookie/CSRF model.
+     * Set true to restore the legacy behaviour (cookie-then-bearer fallback).
+     * IGNORED in token-mode (`session.basedToken === true`), which is unaffected:
+     * it always reads the bearer/handshake token first, cookie as fallback.
+     */
+    acceptBearerInCookieMode?: boolean;
+    /**
+     * Controls how `/_health` exposes synchronized-env-var hashes (SEC-13).
+     * Previously `/_health` returned an UNSALTED `sha256(value)` of each
+     * synchronized secret, unauthenticated — enabling offline dictionary attacks
+     * on low-entropy secrets + key-name disclosure. This config + the shared
+     * {@link hashSynchronizedValue} helper let both the server (`/_health`) and the
+     * router (boot handshake) salt/HMAC consistently so the compare still works.
+     * DEFAULTS keep today's wire behavior (`mode: 'plain'`) so a missing key does
+     * not break an existing router handshake — opt into `'salted'`/`'hmac'`
+     * explicitly (and bump server + router together).
+     */
+    healthHash: HealthHashConfig;
     stream: HttpStreamConfig;
     securityHeaders: SecurityHeadersConfig;
     cors: CorsConfig;
 }
+interface HealthHashConfig {
+    /**
+     * - `'plain'` — unsalted `sha256(value)`; the pre-0.2.0 behavior, kept so an
+     *   existing router boot handshake keeps comparing successfully. Opt in with
+     *   `mode:'plain'` to restore the legacy wire output.
+     * - `'salted'` — `sha256(salt + value)` using `salt` below (or the boot UUID
+     *   when `salt` is the literal `'@bootUuid'`). Stable across a boot, rotates on
+     *   restart when bound to the boot UUID.
+     * - `'hmac'` (DEFAULT in 0.2.0) — `HMAC-SHA256(key=salt, value)`. The default
+     *   `salt:'@bootUuid'` keys it on the per-boot UUID server + router already
+     *   share, so `/_health` no longer exposes a stable, offline-attackable
+     *   `sha256(secret)`. Collapses to `'plain'` when no boot UUID is available so
+     *   the boot handshake never silently diverges.
+     */
+    mode: 'plain' | 'salted' | 'hmac';
+    /**
+     * Shared salt / HMAC key. Both the backend `/_health` and the router's
+     * compare MUST use the same value. The literal `'@bootUuid'` is a sentinel
+     * meaning "use the current boot UUID as the salt" (valid with `'salted'` or
+     * `'hmac'`). DEFAULTS to `'@bootUuid'` in 0.2.0 (only consulted when
+     * `mode !== 'plain'`); set a non-empty static value to pin a stable key.
+     */
+    salt: string;
+}
 interface PasswordPolicyConfig {
     /** Minimum total length. Default 8. */
     minLength: number;
@@ -175,6 +370,14 @@ interface PasswordPolicyConfig {
     customValidator?: (password: string) => string | null;
 }
 interface AuthConfig {
+    /**
+     * Whether email+password (credentials) auth is enabled. When `true` (default)
+     * `@luckystack/login/register` registers the credentials provider, so it shows
+     * up in `GET /auth/providers` and the login form renders the email/password
+     * fields. Set `false` for an OAuth-only app — the form hides the fields AND the
+     * `/auth/api/credentials` route rejects (`auth.credentialsDisabled`).
+     */
+    credentials: boolean;
     /** TTL for OAuth state tokens stored in Redis. */
     oauthStateTtlSeconds: number;
     /**
@@ -204,8 +407,9 @@ interface AuthConfig {
      * `'per-provider'` (default) — same email via Google and GitHub creates
      *   two separate User rows (current behavior, no schema change).
      * `'unified'` — same email maps to a single User; subsequent sign-ins via
-     *   different providers link an Account row to the same User. Requires a
-     *   Prisma schema change documented in @luckystack/login's README.
+     *   different providers resolve to (link to) that same User row instead of
+     *   creating a duplicate. Requires `email` to be `@unique` — see the
+     *   "Account strategy" migration steps in @luckystack/login's README.
      */
     providerAccountStrategy: 'per-provider' | 'unified';
     /**
@@ -228,6 +432,27 @@ interface AuthConfig {
     passwordResetBrand?: string;
     /** Email-change confirmation-token TTL in seconds. Default 3600 (1 hour). */
     emailChangeTtlSeconds: number;
+    /**
+     * Whether public self-service registration is permitted (login F18). When
+     * `false`, the credentials `/register` route rejects with
+     * `auth.registrationDisabled` and the login UI hides the "create account"
+     * affordance — useful for invite-only / admin-provisioned apps. OAuth-driven
+     * first-login account creation is governed separately by the provider flow.
+     * DEFAULT `true` (today's behavior — open registration).
+     */
+    allowRegistration: boolean;
+    /**
+     * Frontend path the framework-mode password-reset email links to (login F22).
+     * The reset token is appended as a query param. DEFAULT `/reset-password`.
+     * Override when your reset page lives at a different route.
+     */
+    passwordResetPath: string;
+    /**
+     * Frontend path the email-change confirmation email links to (login F22).
+     * The confirmation token is appended as a query param.
+     * DEFAULT `/confirm-email-change`.
+     */
+    emailChangeConfirmPath: string;
 }
 interface OfflineQueueConfig {
     /** Hard cap on items per queue (api + sync are tracked separately). Default 200. */
@@ -250,8 +475,45 @@ interface SyncStreamThrottleConfig {
     /** Default `field` (payload key) for emitted chunks. */
     field: string;
 }
+interface ApiConfig {
+    /**
+     * Default response timeout (ms) for `apiRequest`. After this elapses with no
+     * response (e.g. server restart/crash between emit and reply) the request
+     * settles with `{ status:'error', errorCode:'api.timeout', httpStatus:504 }`
+     * instead of hanging forever. Set `false` to disable the timeout. A per-call
+     * `timeoutMs` overrides this. Default 30000.
+     */
+    requestTimeoutMs: number | false;
+}
+interface ValidationConfig {
+    /**
+     * Whether runtime input validation runs in PRODUCTION (CORE-01).
+     *
+     * - `'enforce'` (DEFAULT) — the structural validator (`validateType`) runs
+     *   against the route's resolved input type in production too, so a malformed
+     *   payload is rejected with `api.invalidInputType` / `sync.invalidInputType`
+     *   instead of reaching the handler. Only the dev-only devkit DEEP type
+     *   resolver (TypeScript compiler API) is skipped in prod — the already-resolved
+     *   generated type text is validated directly.
+     * - `'off'` — restore the legacy behavior where prod skips input validation
+     *   entirely (input shape is the handler's responsibility). This is the loud,
+     *   documented opt-out; set it only if a route's generated type text can't be
+     *   validated structurally in your deployment.
+     *
+     * DEFAULT `'enforce'`. Note: this CHANGES prior behavior (prod was a no-op).
+     * Set `'off'` to keep the old no-op.
+     */
+    runtimeMode: 'enforce' | 'off';
+}
 interface SyncConfig {
     streamThrottle: SyncStreamThrottleConfig;
+    /**
+     * Default response timeout (ms) for `syncRequest`'s acknowledgement. Same
+     * semantics as `api.requestTimeoutMs` but for sync. Settles with
+     * `sync.requestTimeout` / httpStatus 504 on expiry. `false` to disable.
+     * Default 30000.
+     */
+    requestTimeoutMs: number | false;
     /**
      * Yield to the event loop every N recipients during a broadcast fanout
      * (`receiver: 'all'` or large rooms). Lower = more responsive, higher
@@ -260,6 +522,43 @@ interface SyncConfig {
     fanoutYieldEvery: number;
     /** Milliseconds to sleep when yielding. Default 1ms. */
     fanoutYieldMs: number;
+    /**
+     * Receiver-authorization policy (SYNC-07). These flags add framework-level
+     * defaults read by `@luckystack/sync`'s `authorizeSyncReceiver`:
+     *
+     * - `allowClientReceiverAll` — when false, a client requesting the broadcast
+     *   receiver `'all'` is rejected unless a `preSyncAuthorize` handler approves
+     *   it. DEFAULT `false` (0.2.0 secure-default flip — a client can no longer
+     *   broadcast cluster-wide by default; opt back in with `true` for the legacy
+     *   permissive behavior).
+     * - `requireRoomMembership` — when true, a client may only target a room it
+     *   has actually joined (its `roomCodes`); targeting an unjoined room is
+     *   rejected. DEFAULT `true` (0.2.0 secure-default flip — a client can no
+     *   longer fan out to a room it never joined; set `false` for the legacy
+     *   any-room behavior).
+     *
+     * BREAKING (0.2.0): both defaults now fail CLOSED. Apps that relied on
+     * implicit cluster-wide / arbitrary-room broadcasts must either join the room
+     * before targeting it, approve the receiver via a `preSyncAuthorize` handler,
+     * or explicitly opt back into the permissive values.
+     */
+    allowClientReceiverAll: boolean;
+    requireRoomMembership: boolean;
+    /**
+     * Stream backpressure tuning (SYNC-15) for `createStreamThrottle` /
+     * server-initiated stream emits. Constants were previously hardcoded in the
+     * sync package; surfacing them here lets a consumer tune flush cadence under
+     * load without forking. DEFAULTS reproduce the historical hardcoded values.
+     */
+    flushPressure: SyncFlushPressureConfig;
+}
+interface SyncFlushPressureConfig {
+    /** Max queued chunks before the stream applies backpressure (pauses). Default 1000. */
+    highWaterMarkChunks: number;
+    /** Resume emitting once the queue drains below this. Default 250. */
+    lowWaterMarkChunks: number;
+    /** Hard cap on bytes buffered for a single stream before dropping/erroring. Default 5_242_880 (5 MiB). */
+    maxBufferedBytes: number;
 }
 interface SocketConfig {
     /** Maximum payload size for any single Socket.io message (bytes). */
@@ -268,6 +567,14 @@ interface SocketConfig {
     pingTimeout: number;
     /** ms between pings. */
     pingInterval: number;
+    /**
+     * Minimum ms between client → server `activity` heartbeats (repo-src C-CFG /
+     * presence C1). The consumer template's activity tracker + `@luckystack/presence`
+     * read this to throttle how often mouse/keyboard/touch activity is reported
+     * (previously hardcoded to 10s). DEFAULT 10000 (10s) — a missing key keeps the
+     * historical cadence.
+     */
+    activityHeartbeatThrottleMs: number;
 }
 interface DevConfig {
     /** Debounce window for hot-reload triggers. */
@@ -333,7 +640,9 @@ interface ProjectConfig {
     http: HttpConfig;
     auth: AuthConfig;
     socket: SocketConfig;
+    api: ApiConfig;
     sync: SyncConfig;
+    validation: ValidationConfig;
     offlineQueue: OfflineQueueConfig;
     dev: DevConfig;
     paths: PathsConfig;
@@ -348,10 +657,16 @@ interface ProjectConfig {
     locationProviderEnabled?: boolean;
     /** Where to redirect the user after a successful OAuth callback. */
     loginRedirectUrl?: string;
+    /**
+     * Base origin used to build OAuth callback redirect URIs
+     * (`<oauthCallbackBase>/auth/callback/<provider>`). This is the BACKEND
+     * origin the provider redirects to — in dev typically `http://localhost:80`,
+     * in prod the public domain. Read by `@luckystack/login/register`'s env-driven
+     * provider scan so OAuth wiring needs no consumer code. Empty default — the
+     * consumer's `config.ts` sets it.
+     */
+    oauthCallbackBase?: string;
 }
-type DeepPartial<T> = {
-    [K in keyof T]?: T[K] extends object | undefined ? DeepPartial<NonNullable<T[K]>> : T[K];
-};
 type ProjectConfigInput = DeepPartial<ProjectConfig>;
 declare const DEFAULT_PROJECT_CONFIG: ProjectConfig;
 declare const registerProjectConfig: (config: ProjectConfigInput) => void;
@@ -382,6 +697,8 @@ declare const setSocket: (next: Socket | null) => void;
 declare const incrementResponseIndex: () => number;
 declare const waitForSocket: () => Promise<Socket | null>;
 
+/** Why a queued item was dropped (handed to its `onDrop` callback). */
+type QueueDropReason = 'expired' | 'queue-full';
 interface ApiQueueItem {
     id: string;
     key: string;
@@ -392,6 +709,14 @@ interface ApiQueueItem {
      * `SyncQueueItem.dropPolicy` for details.
      */
     dropPolicy?: 'drop-oldest' | 'drop-newest' | 'reject';
+    /**
+     * Optional callback invoked when THIS item is dropped (evicted for age or
+     * because the queue was full / rejected) instead of ever running (SYNC-09).
+     * The transport wires this to settle the pending `syncRequest`/`apiRequest`
+     * promise with an error envelope, so an evicted offline request resolves
+     * rather than hanging forever. Invoked at most once; failures are swallowed.
+     */
+    onDrop?: (reason: QueueDropReason) => void;
 }
 interface SyncQueueItem {
     id: string;
@@ -405,6 +730,8 @@ interface SyncQueueItem {
      * the global config.
      */
     dropPolicy?: 'drop-oldest' | 'drop-newest' | 'reject';
+    /** See {@link ApiQueueItem.onDrop} (SYNC-09). */
+    onDrop?: (reason: QueueDropReason) => void;
 }
 declare const isOnline: () => boolean;
 declare const enqueueApiRequest: (item: ApiQueueItem) => boolean;
@@ -524,8 +851,10 @@ declare const socketEventNames: {
     readonly logout: "logout";
     readonly intentionalDisconnect: "intentionalDisconnect";
     readonly intentionalReconnect: "intentionalReconnect";
+    readonly activity: "activity";
     readonly userAfk: "userAfk";
     readonly userBack: "userBack";
+    readonly userLeft: "userLeft";
     readonly connect: "connect";
     readonly disconnect: "disconnect";
     readonly reconnectAttempt: "reconnect_attempt";
@@ -662,4 +991,4 @@ interface PagePathValidationResult {
  */
 declare const validatePagePath: (srcRelativePath: string, rules?: PageRouteRules) => PagePathValidationResult;
 
-export { setSocket as $, type ApiMethodMap as A, type BaseSessionLayout as B, getProjectConfig as C, DEFAULT_PAGE_ROUTE_RULES as D, getRegisteredApiMethod as E, getSyncQueueSize as F, httpFetch as G, type HttpMethodLiteral as H, incrementResponseIndex as I, isApiMethodMapRegistered as J, isOnline as K, type Logger as L, isProjectConfigRegistered as M, type Notifier as N, normalizeErrorResponseCore as O, type PagePathValidationResult as P, notify as Q, type RateLimitingConfig as R, type SOCKETSTATUS as S, parseServiceRouteName as T, registerApiMethodMap as U, registerLogger as V, registerNotifier as W, registerProjectConfig as X, removeApiQueueItem as Y, removeApiQueueItemsByKey as Z, removeSyncQueueItem as _, type AppConfig as a, sleep as a0, socket as a1, socketEventNames as a2, type statusContent as a3, tryCatch as a4, validatePagePath as a5, waitForSocket as a6, type ErrorParam as a7, type ErrorResponseInput as a8, type NormalizedErrorResponse as a9, parseTransportRouteName as aA, resetLoggerForTests as aB, type AuthConfig as aa, type CorsConfig as ab, DEFAULT_PROJECT_CONFIG as ac, type DevConfig as ad, type HttpConfig as ae, type HttpStreamConfig as af, INVALID_ERROR_RESPONSE_CODE as ag, type OfflineQueueConfig as ah, type PasswordPolicyConfig as ai, type PathsConfig as aj, type ProjectConfigInput as ak, type SecurityHeadersConfig as al, type ServiceRouteParseError as am, type ServiceRouteParseResult as an, type ServiceRouteParseSuccess as ao, type SocketConfig as ap, type SyncConfig as aq, type SyncStreamThrottleConfig as ar, type TransportRouteParseError as as, type TransportRouteParseResult as at, type TransportRouteParseSuccess as au, createDevLogger as av, defaultHttpStatusForResponse as aw, getProjectName as ax, isErrorParamArray as ay, isLoggerRegistered as az, type AuthProps as b, type LoggerContext as c, type LoggingConfig as d, type NotifyInput as e, type NotifyParam as f, type PageRouteRules as g, type ProjectConfig as h, type SessionConfig as i, type SessionLocation as j, buildApiResponseEventName as k, buildApiStreamEventName as l, buildGetJoinedRoomsResponseEventName as m, buildJoinRoomResponseEventName as n, buildLeaveRoomResponseEventName as o, buildSyncProgressEventName as p, buildSyncResponseEventName as q, clearCsrfToken as r, enqueueApiRequest as s, enqueueSyncRequest as t, flushApiQueue as u, flushSyncQueue as v, getApiQueueSize as w, getCsrfToken as x, getLogger as y, getNotifier as z };
+export { setSocket as $, type ApiMethodMap as A, type BaseSessionLayout as B, getProjectConfig as C, DEFAULT_PAGE_ROUTE_RULES as D, getRegisteredApiMethod as E, getSyncQueueSize as F, httpFetch as G, type HttpMethodLiteral as H, incrementResponseIndex as I, isApiMethodMapRegistered as J, isOnline as K, type Logger as L, isProjectConfigRegistered as M, type Notifier as N, normalizeErrorResponseCore as O, type PagePathValidationResult as P, notify as Q, type RateLimitingConfig as R, type SOCKETSTATUS as S, parseServiceRouteName as T, registerApiMethodMap as U, registerLogger as V, registerNotifier as W, registerProjectConfig as X, removeApiQueueItem as Y, removeApiQueueItemsByKey as Z, removeSyncQueueItem as _, type AppConfig as a, sleep as a0, socket as a1, socketEventNames as a2, type statusContent as a3, validatePagePath as a4, waitForSocket as a5, type ErrorParam as a6, type ErrorResponseInput as a7, type NormalizedErrorResponse as a8, type HealthHashConfig as a9, type TransportRouteParseResult as aA, type TransportRouteParseSuccess as aB, type ValidationConfig as aC, createDevLogger as aD, deepMerge as aE, defaultHttpStatusForResponse as aF, getProjectName as aG, isErrorParamArray as aH, isLoggerRegistered as aI, isPlainObject as aJ, parseTransportRouteName as aK, resetLoggerForTests as aL, type DeepPartial as aa, type ApiConfig as ab, type AuthConfig as ac, type AuthRateLimitConfig as ad, type CorsConfig as ae, DEFAULT_PROJECT_CONFIG as af, type DevConfig as ag, type HttpConfig as ah, type HttpStreamConfig as ai, INVALID_ERROR_RESPONSE_CODE as aj, type OfflineQueueConfig as ak, type PasswordPolicyConfig as al, type PathsConfig as am, type ProjectConfigInput as an, type QueueDropReason as ao, type RateLimitIdentity as ap, type RateLimitIdentityParams as aq, type SecurityHeadersConfig as ar, type ServiceRouteParseError as as, type ServiceRouteParseResult as at, type ServiceRouteParseSuccess as au, type SocketConfig as av, type SyncConfig as aw, type SyncFlushPressureConfig as ax, type SyncStreamThrottleConfig as ay, type TransportRouteParseError as az, type AuthProps as b, type LoggerContext as c, type LoggingConfig as d, type NotifyInput as e, type NotifyParam as f, type PageRouteRules as g, type ProjectConfig as h, type SessionConfig as i, type SessionLocation as j, buildApiResponseEventName as k, buildApiStreamEventName as l, buildGetJoinedRoomsResponseEventName as m, buildJoinRoomResponseEventName as n, buildLeaveRoomResponseEventName as o, buildSyncProgressEventName as p, buildSyncResponseEventName as q, clearCsrfToken as r, enqueueApiRequest as s, enqueueSyncRequest as t, flushApiQueue as u, flushSyncQueue as v, getApiQueueSize as w, getCsrfToken as x, getLogger as y, getNotifier as z };

package/dist/projectConfig-JX563K43.js

@@ -0,0 +1,16 @@
+import {
+  DEFAULT_PROJECT_CONFIG,
+  getProjectConfig,
+  getProjectName,
+  isProjectConfigRegistered,
+  registerProjectConfig
+} from "./chunk-W62GGT2P.js";
+import "./chunk-USQA6QTX.js";
+export {
+  DEFAULT_PROJECT_CONFIG,
+  getProjectConfig,
+  getProjectName,
+  isProjectConfigRegistered,
+  registerProjectConfig
+};
+//# sourceMappingURL=projectConfig-JX563K43.js.map

package/dist/projectConfig-JX563K43.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/sentrySetup-Q4BKUAQ3.js

@@ -0,0 +1,16 @@
+import {
+  captureException,
+  captureMessage,
+  initSharedSentry,
+  setSentryUser,
+  startSpan
+} from "./chunk-V2WKGTZH.js";
+import "./chunk-USQA6QTX.js";
+export {
+  captureException,
+  captureMessage,
+  initSharedSentry,
+  setSentryUser,
+  startSpan
+};
+//# sourceMappingURL=sentrySetup-Q4BKUAQ3.js.map

package/dist/sentrySetup-Q4BKUAQ3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}