@rebasepro/server 0.14.2-canary.g991e9df → 0.14.2-canary.gf913b76

package/dist/api/logs-routes.d.ts

@@ -9,19 +9,34 @@ export interface LogEntry {
     message: string;
     metadata?: Record<string, unknown>;
 }
+/** What a caller can narrow the log by, in either direction (query or stream). */
+export interface LogFilterOptions {
+    level?: string;
+    source?: string;
+    search?: string;
+    since?: string;
+}
+/** Notified for every entry pushed, in push order. */
+export type LogListener = (entry: LogEntry) => void;
 declare class LogRingBuffer {
     private buffer;
     private maxSize;
     private idCounter;
+    private listeners;
     constructor(maxSize?: number);
     push(entry: Omit<LogEntry, "id">): void;
-    query(options: {
-        level?: string;
-        source?: string;
-        search?: string;
+    /**
+     * Follow the buffer. Returns the unsubscribe — call it, always: a listener
+     * left behind holds its whole closure, and on this class that closure is a
+     * pending-entry array.
+     *
+     * A listener must not log. It is called from inside `push`, so anything that
+     * reaches `addLog` from here recurses until the stack gives out.
+     */
+    subscribe(listener: LogListener): () => void;
+    query(options: LogFilterOptions & {
         limit?: number;
         offset?: number;
-        since?: string;
     }): {
         entries: LogEntry[];
         total: number;
@@ -31,7 +46,31 @@ declare class LogRingBuffer {
 export declare const logBuffer: LogRingBuffer;
 /** Add a log entry */
 export declare function addLog(level: LogEntry["level"], source: LogEntry["source"], message: string, metadata?: Record<string, unknown>): void;
+export interface LogMiddlewareOptions {
+    /**
+     * Paths this sink ignores, matched exactly against `c.req.path`.
+     *
+     * For requests whose only reason to exist is to read the log. Recording
+     * those makes the reader the loudest thing in its own output, and on a quiet
+     * server it is also the thing evicting real entries out of the ring.
+     */
+    ignorePaths?: string[];
+}
 /** Hono middleware to log API requests */
-export declare function logMiddleware(): MiddlewareHandler<HonoEnv>;
-declare const app: Hono<HonoEnv, import("hono/types").BlankSchema, "/">;
-export default app;
+export declare function logMiddleware(options?: LogMiddlewareOptions): MiddlewareHandler<HonoEnv>;
+/**
+ * The stream's timings, injectable only so they can be tested.
+ *
+ * The defaults above are the contract and nothing in production passes this. A
+ * heartbeat is a 25-second wait to observe, and a suite that cannot observe it is
+ * a suite where the keepalive can rot — which surfaces as "the tail dies after a
+ * few minutes behind the load balancer", months later, on someone else's cluster.
+ */
+export interface LogStreamTiming {
+    flushMs?: number;
+    heartbeatMs?: number;
+    maxPending?: number;
+}
+export declare function createLogsRoutes(timing?: LogStreamTiming): Hono<HonoEnv>;
+declare const _default: Hono<HonoEnv, import("hono/types").BlankSchema, "/">;
+export default _default;

package/dist/auth/index.d.ts

@@ -41,6 +41,10 @@ export { createRateLimiter, defaultAuthLimiter, strictAuthLimiter, createDataRat
 export type { DataRateLimitConfig } from "./rate-limiter";
 export { MemoryRateLimitStore } from "./rate-limit-store";
 export type { RateLimitStore, RateLimitDecision } from "./rate-limit-store";
+export { createSqlRateLimitStore } from "./sql-rate-limit-store";
+export type { SqlRateLimitStoreOptions } from "./sql-rate-limit-store";
+export { resolveRateLimitStoreKind, RateLimitStoreConfigurationError } from "./resolve-rate-limit-store";
+export type { RateLimitStoreKind, RateLimitStoreEnv } from "./resolve-rate-limit-store";
 export { createApiKeyStore, createApiKeyRoutes, isApiKeyToken, validateApiKey, httpMethodToOperation, isOperationAllowed } from "./api-keys";
 export type { ApiKey, ApiKeyMasked, ApiKeyPermission, ApiKeyWithSecret, CreateApiKeyRequest, UpdateApiKeyRequest, ApiKeyStore, ApiKeyOperation } from "./api-keys";
 export { createBuiltinAuthAdapter } from "./builtin-auth-adapter";

package/dist/auth/resolve-rate-limit-store.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Choosing where rate-limit counts live, from configuration and environment.
+ *
+ * Pure, and separate from both stores, because the decision is the risk. Getting
+ * it wrong in either direction is silent: a deployment that wanted shared counts
+ * and got per-process ones enforces N times its limit, and a single-container
+ * deployment that got shared ones pays a database round trip on every request
+ * for a count nobody is sharing with.
+ *
+ * ## Why memory is still the default
+ *
+ * The same reason `role.ts` gives for having no channel-bus refusal: **a process
+ * cannot read its own replica count.** A single container scaled to three needs
+ * a shared store exactly as much as a split deployment does, and neither is
+ * visible from inside one process. So this does not guess. It stays on the
+ * default that costs nothing, and the deployment that knows it has peers says
+ * so — with one environment variable, which is the same sentence whether it is
+ * written in a compose file, a Helm value, or a platform-pinned pod spec.
+ */
+/** Where a deployment keeps its rate-limit counts. */
+export type RateLimitStoreKind = "memory" | "sql";
+/** The environment this module reads. Narrowed so it can be called with a literal. */
+export interface RateLimitStoreEnv {
+    /** `memory` (default) or `sql`. */
+    REBASE_RATE_LIMIT_STORE?: string;
+}
+/**
+ * A refusal to boot, phrased as the variable to change.
+ *
+ * Its own class so `bootFromBundle` can present it as a configuration problem
+ * rather than a crash, matching `RoleConfigurationError`.
+ */
+export declare class RateLimitStoreConfigurationError extends Error {
+    readonly hint?: string | undefined;
+    constructor(message: string, hint?: string | undefined);
+}
+/**
+ * Which store this process should build.
+ *
+ * A misspelled value **refuses to boot** rather than falling back to memory.
+ * Every other outcome here is silent — the whole failure mode of this setting is
+ * that nothing looks wrong — so the one moment it can be caught is the moment it
+ * is read. `REBASE_RATE_LIMIT_STORE=postgres` is the obvious thing to type and
+ * would otherwise be a per-replica limit wearing the shape of a shared one.
+ *
+ * A blank or whitespace-only value is *unset*, not invalid:
+ * `REBASE_RATE_LIMIT_STORE=${SOMETHING}` with `SOMETHING` undefined is the
+ * ordinary way to write a compose file, and it is how the platform neutralises a
+ * tenant's own variable.
+ */
+export declare function resolveRateLimitStoreKind(env: RateLimitStoreEnv): RateLimitStoreKind;

package/dist/auth/sql-rate-limit-store.d.ts

@@ -0,0 +1,63 @@
+/**
+ * A rate-limit store every process in a deployment shares.
+ *
+ * {@link MemoryRateLimitStore} counts in one process's memory, so N replicas
+ * enforce N times the limit between them. That is fine for the single container
+ * almost every deployment runs, and wrong the moment a deployment splits — an
+ * `api` pod and a `functions` pod each grant a caller the full allowance, and
+ * nothing anywhere reports it. A limit that silently lets through 3× the traffic
+ * is worse than no limit, because it is believed.
+ *
+ * So this keeps the counts in Postgres, on the same seam the cron store already
+ * uses: `DataDriver.admin.executeSql`. No new dependency, no new service, and it
+ * degrades on a driver with no SQL (Mongo) rather than failing to boot.
+ *
+ * ## Why two buckets rather than one row per hit
+ *
+ * The memory store keeps a timestamp per hit, which is exact and costs a row per
+ * request here. This keeps **one row per key per window** and approximates the
+ * same sliding behaviour by weighting the previous window by how much of it is
+ * still in view:
+ *
+ *     estimate = current + previous × (1 − elapsed ÷ window)
+ *
+ * At the moment a window rolls over the previous bucket counts fully and decays
+ * to nothing by the end, so the boundary burst a fixed window allows — spend the
+ * whole allowance in the last second, spend it again in the first second of the
+ * next — is bounded rather than free. This is the standard approximation and its
+ * error is at most one window's distribution skew, which for a floor against
+ * runaway clients is not a number worth a row per request.
+ *
+ * ## Why a denied hit is given back
+ *
+ * `INSERT … ON CONFLICT DO UPDATE … RETURNING` is atomic per row, which is what
+ * the interface demands: two concurrent hits cannot both read `limit - 1` and
+ * both be allowed. But it means the count is incremented *before* the decision,
+ * so a request that turns out to be over the limit has already been charged for.
+ *
+ * The memory store does not charge denied hits, and a store whose semantics
+ * differ from the default is a store nobody can safely switch to — the limit
+ * would tighten for reasons an operator would attribute to their traffic. So a
+ * denial issues a compensating decrement. That is a second statement, on the
+ * path that is by definition the rare one; the allowed path stays at one.
+ */
+import type { DataDriver } from "@rebasepro/types";
+import type { RateLimitStore } from "./rate-limit-store.js";
+export interface SqlRateLimitStoreOptions {
+    /** How often to delete expired buckets. Defaults to 5 minutes. */
+    sweepMs?: number;
+    /**
+     * Clock, for tests. Driving the window directly beats sleeping through half
+     * of one — a real sleep overruns on a loaded machine and takes the hits it
+     * expected to still be in the window with it.
+     */
+    now?: () => number;
+}
+/**
+ * Build the store, or `undefined` if this driver cannot back it.
+ *
+ * Returning `undefined` rather than throwing matches `createCronStore`: a
+ * deployment on a driver with no SQL admin should degrade to per-process counts
+ * with a warning, not refuse to serve.
+ */
+export declare function createSqlRateLimitStore(driver: DataDriver, options?: SqlRateLimitStoreOptions): RateLimitStore | undefined;

package/dist/{auth-BobZVd0j.js → auth-CIWux0Ol.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from "module";
 import process from "process";
 __createRequire(import.meta.url);
 import { i as __toESM, n as __exportAll } from "./rolldown-runtime-DSJWtz9O.js";
-import { C as ListLimitError, D as isAnonymousUid, E as ANONYMOUS_USER_ID, T as resolveClientListLimit, a as deserializeLogicalCondition, i as deserializeFilter, r as UnknownFilterOperatorError } from "./src-8XDWyDfR.js";
+import { C as ListLimitError, D as isAnonymousUid, E as ANONYMOUS_USER_ID, T as resolveClientListLimit, a as deserializeLogicalCondition, i as deserializeFilter, r as UnknownFilterOperatorError } from "./src-Cx24hMDv.js";
 import "./src-Cz9nMgUR.js";
 import { n as createDdlBootstrapper, o as revokeInternalTableSql, s as isSQLAdmin } from "./ddl-bootstrap-Cywoj8Ta.js";
 import { S as canonicalStorageId, T as require_jsonwebtoken, _ as verifyMfaPendingToken, a as generateMfaPendingToken, c as getJwks, d as hasAsymmetricSigningKey, f as hashRefreshToken, g as verifyDownloadToken, h as verifyAccessToken, i as generateDownloadToken, l as getRefreshTokenExpiry, n as configureJwt, o as generateRefreshToken, p as isJwtConfigured, r as generateAccessToken, s as getAccessTokenExpiry, t as MAX_COOKIE_AGE_MS, u as getRefreshTokenTtlMs, w as tryCanonicalStorageKey } from "./jwt-VJyXTdQQ.js";
@@ -10036,6 +10036,198 @@ function createSpotifyProvider(config) {
 	};
 }
 //#endregion
+//#region src/auth/sql-rate-limit-store.ts
+var SCHEMA = "rebase";
+var TABLE_NAME = "rate_limit_hits";
+var TABLE$1 = `${SCHEMA}.${TABLE_NAME}`;
+/** How often expired buckets are deleted. */
+var DEFAULT_SWEEP_MS = 300 * 1e3;
+/**
+* Build the store, or `undefined` if this driver cannot back it.
+*
+* Returning `undefined` rather than throwing matches `createCronStore`: a
+* deployment on a driver with no SQL admin should degrade to per-process counts
+* with a warning, not refuse to serve.
+*/
+function createSqlRateLimitStore(driver, options = {}) {
+	const admin = driver.admin;
+	if (!isSQLAdmin(admin)) {
+		logger.warn("⚠️ [rate-limit] The configured driver has no SQL admin, so rate-limit counts cannot be shared between processes. Falling back to this process's memory — each replica will enforce the limit independently.");
+		return;
+	}
+	const exec = (sqlText, options) => admin.executeSql(sqlText, options?.params ? { params: options.params } : void 0);
+	const ddl = createDdlBootstrapper(exec, "rate-limit-store");
+	const now = options.now ?? Date.now;
+	const sweepMs = options.sweepMs ?? DEFAULT_SWEEP_MS;
+	let sweepTimer;
+	let ready;
+	/**
+	* Create the table once, and remember whether it worked.
+	*
+	* Lazily rather than at boot because the store is constructed while routes
+	* are being mounted, and an `await` there would put a database round trip on
+	* the boot path of every deployment — including the ones that never take a
+	* request. The first request pays for it.
+	*
+	* The result is cached even on failure: a store that cannot create its table
+	* must not retry the DDL on every request, which would turn one broken
+	* permission into a per-request query storm.
+	*
+	* Readiness is decided by reading the table, never by the DDL not throwing —
+	* `ensureObject` routes through `step`, which logs a failure and returns
+	* normally. Keying on the absence of an exception would report a table that
+	* was never created as ready, and every later request would fall into the
+	* per-request error path instead of the one-time fallback.
+	*/
+	async function ensureReady() {
+		if (!ready) ready = (async () => {
+			try {
+				await ddl.ensureObject("Creating schema rebase", "CREATE SCHEMA IF NOT EXISTS rebase");
+				await ddl.ensureObject(`Creating ${TABLE$1}`, `
+                        CREATE TABLE IF NOT EXISTS ${TABLE$1} (
+                            key TEXT NOT NULL,
+                            bucket BIGINT NOT NULL,
+                            hits INTEGER NOT NULL DEFAULT 0,
+                            expires_at TIMESTAMPTZ NOT NULL,
+                            PRIMARY KEY (key, bucket)
+                        )
+                    `);
+				await ddl.ensureObject("Creating idx_rate_limit_hits_expiry", `
+                        CREATE INDEX IF NOT EXISTS idx_rate_limit_hits_expiry
+                        ON ${TABLE$1}(expires_at)
+                    `);
+				const readable = await ddl.isReadable(TABLE$1);
+				if (readable) await ddl.step("Revoking end-user access to rate_limit_hits", () => exec(revokeInternalTableSql(SCHEMA, TABLE_NAME)));
+				else logger.error("[rate-limit] The shared rate-limit table could not be created, so counts stay per-process. Every replica will enforce the limit independently.");
+				return readable;
+			} catch (err) {
+				logger.error("[rate-limit] Could not prepare the shared rate-limit table. Falling back to per-process counts for the life of this process.", { error: err instanceof Error ? err.message : String(err) });
+				return false;
+			}
+		})();
+		return ready;
+	}
+	function startSweeping() {
+		if (sweepTimer) return;
+		sweepTimer = setInterval(() => {
+			exec(`DELETE FROM ${TABLE$1} WHERE expires_at < now()`).catch((err) => {
+				logger.debug("[rate-limit] Bucket sweep failed", { error: err instanceof Error ? err.message : String(err) });
+			});
+		}, sweepMs);
+		sweepTimer.unref?.();
+	}
+	return {
+		async hit(key, windowMs, limit) {
+			if (!await ensureReady()) return {
+				allowed: true,
+				remaining: limit,
+				retryAfterMs: 0
+			};
+			startSweeping();
+			const at = now();
+			const bucket = Math.floor(at / windowMs);
+			const carry = 1 - (at - bucket * windowMs) / windowMs;
+			const expiresAt = new Date((bucket + 2) * windowMs).toISOString();
+			let current;
+			let previous;
+			try {
+				const row = firstRow(await exec(`WITH bumped AS (
+                         INSERT INTO ${TABLE$1} AS r (key, bucket, hits, expires_at)
+                         VALUES ($1, $2, 1, $3)
+                         ON CONFLICT (key, bucket)
+                         DO UPDATE SET hits = r.hits + 1, expires_at = EXCLUDED.expires_at
+                         RETURNING hits
+                     )
+                     SELECT
+                         (SELECT hits FROM bumped) AS current,
+                         COALESCE((SELECT hits FROM ${TABLE$1} WHERE key = $1 AND bucket = $4), 0) AS previous`, { params: [
+					key,
+					bucket,
+					expiresAt,
+					bucket - 1
+				] }));
+				current = Number(row?.current ?? 1);
+				previous = Number(row?.previous ?? 0);
+			} catch (err) {
+				logger.debug("[rate-limit] Shared count unavailable for this request", { error: err instanceof Error ? err.message : String(err) });
+				return {
+					allowed: true,
+					remaining: limit,
+					retryAfterMs: 0
+				};
+			}
+			const estimate = current + previous * carry;
+			if (estimate > limit) {
+				exec(`UPDATE ${TABLE$1} SET hits = GREATEST(hits - 1, 0) WHERE key = $1 AND bucket = $2`, { params: [key, bucket] }).catch(() => {});
+				return {
+					allowed: false,
+					remaining: 0,
+					retryAfterMs: Math.max(0, (bucket + 1) * windowMs - at)
+				};
+			}
+			return {
+				allowed: true,
+				remaining: Math.max(0, Math.floor(limit - estimate)),
+				retryAfterMs: 0
+			};
+		},
+		dispose() {
+			if (sweepTimer) clearInterval(sweepTimer);
+			sweepTimer = void 0;
+		}
+	};
+}
+/**
+* The first row of whatever shape this driver returns.
+*
+* `SqlExec` declares an array of rows, but drivers in this repository have also
+* returned a `{ rows }` envelope through the same escape hatch. Reading one
+* shape only is how a store silently counts nothing and reports every caller as
+* being on their first request — a limiter that never limits, with no error
+* anywhere. Tolerating both costs one line.
+*/
+function firstRow(result) {
+	if (Array.isArray(result)) return result[0];
+	const rows = result?.rows;
+	return Array.isArray(rows) ? rows[0] : void 0;
+}
+//#endregion
+//#region src/auth/resolve-rate-limit-store.ts
+/**
+* A refusal to boot, phrased as the variable to change.
+*
+* Its own class so `bootFromBundle` can present it as a configuration problem
+* rather than a crash, matching `RoleConfigurationError`.
+*/
+var RateLimitStoreConfigurationError = class extends Error {
+	hint;
+	constructor(message, hint) {
+		super(message);
+		this.hint = hint;
+		this.name = "RateLimitStoreConfigurationError";
+	}
+};
+/**
+* Which store this process should build.
+*
+* A misspelled value **refuses to boot** rather than falling back to memory.
+* Every other outcome here is silent — the whole failure mode of this setting is
+* that nothing looks wrong — so the one moment it can be caught is the moment it
+* is read. `REBASE_RATE_LIMIT_STORE=postgres` is the obvious thing to type and
+* would otherwise be a per-replica limit wearing the shape of a shared one.
+*
+* A blank or whitespace-only value is *unset*, not invalid:
+* `REBASE_RATE_LIMIT_STORE=${SOMETHING}` with `SOMETHING` undefined is the
+* ordinary way to write a compose file, and it is how the platform neutralises a
+* tenant's own variable.
+*/
+function resolveRateLimitStoreKind(env) {
+	const raw = (env.REBASE_RATE_LIMIT_STORE ?? "").trim().toLowerCase();
+	if (raw === "") return "memory";
+	if (raw === "memory" || raw === "sql") return raw;
+	throw new RateLimitStoreConfigurationError(`REBASE_RATE_LIMIT_STORE="${raw}" is not a rate-limit store.`, "Use \"sql\" to share counts across processes, or \"memory\" (the default) to keep them in this process. A deployment running more than one replica or more than one role wants \"sql\" — otherwise each process enforces the whole limit by itself.");
+}
+//#endregion
 //#region src/auth/api-keys/api-key-store.ts
 /**
 * Database operations for Service API Keys.
@@ -10433,6 +10625,7 @@ function createCustomAuthAdapter(options) {
 //#region src/auth/index.ts
 var auth_exports = /* @__PURE__ */ __exportAll({
 	MemoryRateLimitStore: () => MemoryRateLimitStore,
+	RateLimitStoreConfigurationError: () => RateLimitStoreConfigurationError,
 	apiKeyKeyGenerator: () => apiKeyKeyGenerator,
 	configureJwt: () => configureJwt,
 	createAdapterAuthMiddleware: () => createAdapterAuthMiddleware,
@@ -10457,6 +10650,7 @@ var auth_exports = /* @__PURE__ */ __exportAll({
 	createResetPasswordRoute: () => createResetPasswordRoute,
 	createSlackProvider: () => createSlackProvider,
 	createSpotifyProvider: () => createSpotifyProvider,
+	createSqlRateLimitStore: () => createSqlRateLimitStore,
 	createTwitterProvider: () => createTwitterProvider,
 	decideOAuthAutoLink: () => decideOAuthAutoLink,
 	defaultAuthLimiter: () => defaultAuthLimiter,
@@ -10490,6 +10684,7 @@ var auth_exports = /* @__PURE__ */ __exportAll({
 	requireAdmin: () => requireAdmin,
 	requireAuth: () => requireAuth,
 	resolveAuthHooks: () => resolveAuthHooks,
+	resolveRateLimitStoreKind: () => resolveRateLimitStoreKind,
 	safeCompare: () => safeCompare,
 	strictAuthLimiter: () => strictAuthLimiter,
 	tryVerifyOidcIdToken: () => tryVerifyOidcIdToken,
@@ -10501,6 +10696,6 @@ var auth_exports = /* @__PURE__ */ __exportAll({
 	verifyPassword: () => verifyPassword
 });
 //#endregion
-export { extractUserFromToken as $, createDataRateLimiter as A, generateSecurePassword as B, createBuiltinAuthAdapter as C, isPublicStoragePath as Ct, string as D, object as E, resolveEmailLinkBase as F, getWelcomeEmailTemplate as G, getMagicLinkTemplate as H, resolveAuthHooks as I, html as J, RawHtml as K, hashPassword as L, SMTPEmailService as M, createEmailService as N, _coercedNumber as O, assertEmailLinkBases as P, createRequireAuth as Q, validatePasswordStrength as R, createJwksRoutes as S, PUBLIC_STORAGE_PREFIX as St, _enum as T, getPasswordResetTemplate as U, getEmailVerificationTemplate as V, getUserInvitationTemplate as W, createAdapterAuthMiddleware as X, raw as Y, createAuthMiddleware as Z, createLinkedinProvider as _, orderByEntriesToTuples as _t, createSpotifyProvider as a, requireAuth as at, pkceTokenParams as b, parseQueryOptions as bt, createGitLabProvider as c, createStorageApiKeyGuard as ct, createFacebookProvider as d, extractBearerToken as dt, fileTokenAuth as et, createAppleProvider as f, safeCompare as ft, createGitHubProvider as g, isOperationAllowed as gt, verifyOidcIdToken as h, httpMethodToOperation as ht, createApiKeyStore as i, requireAdmin as it, MemoryRateLimitStore as j, DEFAULT_FUNCTIONS_ANONYMOUS_LIMIT as k, createDiscordProvider as l, isApiKeyToken as lt, tryVerifyOidcIdToken as m, scopeDataDriver as mt, createCustomAuthAdapter as n, publicObjectAuth as nt, createSlackProvider as o, createApiKeyPreAuth as ot, createMicrosoftProvider as p, SERVICE_IDENTITY as pt, escapeHtml as q, createApiKeyRoutes as r, queryTokenAuth as rt, createBitbucketProvider as s, createFunctionApiKeyGuard as st, auth_exports as t, optionalAuth as tt, createTwitterProvider as u, validateApiKey as ut, createGoogleProvider as v, parseAggregateSelect as vt, ZodNumber as w, providerVerifiedEmail as x, resolveListLimitParam as xt, oauthCodeFlowSchema as y, parseGroupBy as yt, verifyPassword as z };
+export { createAuthMiddleware as $, _coercedNumber as A, validatePasswordStrength as B, providerVerifiedEmail as C, resolveListLimitParam as Ct, _enum as D, ZodNumber as E, createEmailService as F, getPasswordResetTemplate as G, generateSecurePassword as H, assertEmailLinkBases as I, RawHtml as J, getUserInvitationTemplate as K, resolveEmailLinkBase as L, createDataRateLimiter as M, MemoryRateLimitStore as N, object as O, SMTPEmailService as P, createAdapterAuthMiddleware as Q, resolveAuthHooks as R, pkceTokenParams as S, parseQueryOptions as St, createBuiltinAuthAdapter as T, isPublicStoragePath as Tt, getEmailVerificationTemplate as U, verifyPassword as V, getMagicLinkTemplate as W, html as X, escapeHtml as Y, raw as Z, verifyOidcIdToken as _, httpMethodToOperation as _t, resolveRateLimitStoreKind as a, queryTokenAuth as at, createGoogleProvider as b, parseAggregateSelect as bt, createSlackProvider as c, createApiKeyPreAuth as ct, createDiscordProvider as d, isApiKeyToken as dt, createRequireAuth as et, createTwitterProvider as f, validateApiKey as ft, tryVerifyOidcIdToken as g, scopeDataDriver as gt, createMicrosoftProvider as h, SERVICE_IDENTITY as ht, createApiKeyStore as i, publicObjectAuth as it, DEFAULT_FUNCTIONS_ANONYMOUS_LIMIT as j, string as k, createBitbucketProvider as l, createFunctionApiKeyGuard as lt, createAppleProvider as m, safeCompare as mt, createCustomAuthAdapter as n, fileTokenAuth as nt, createSqlRateLimitStore as o, requireAdmin as ot, createFacebookProvider as p, extractBearerToken as pt, getWelcomeEmailTemplate as q, createApiKeyRoutes as r, optionalAuth as rt, createSpotifyProvider as s, requireAuth as st, auth_exports as t, extractUserFromToken as tt, createGitLabProvider as u, createStorageApiKeyGuard as ut, createGitHubProvider as v, isOperationAllowed as vt, createJwksRoutes as w, PUBLIC_STORAGE_PREFIX as wt, oauthCodeFlowSchema as x, parseGroupBy as xt, createLinkedinProvider as y, orderByEntriesToTuples as yt, hashPassword as z };
 
-//# sourceMappingURL=auth-BobZVd0j.js.map
+//# sourceMappingURL=auth-CIWux0Ol.js.map