better-supabase 0.8.0 → 0.10.0

package/dist/problem-CEjyhV5T.d.ts

@@ -0,0 +1,76 @@
+import { E as ValidationIssue, b as DbError, x as DbErrorKind } from "./result-Cj3yWhjH.js";
+//#region src/core/problem.d.ts
+/** RFC 9457 Problem Details, with the `DbError` fields as extension members. */
+interface ProblemDetails {
+  readonly type: string;
+  readonly title: string;
+  readonly status: number;
+  readonly detail?: string;
+  readonly instance?: string;
+  /** The `DbError` kind. */
+  readonly kind: DbErrorKind;
+  readonly code?: string;
+  readonly hint?: string;
+  readonly constraint?: string;
+  readonly columns?: readonly string[];
+  readonly column?: string;
+  readonly issues?: readonly ValidationIssue[];
+  /** The assurance level a `forbidden` answer needs (`aal2`). */
+  readonly required?: "aal1" | "aal2";
+  /** The OAuth scopes a `forbidden` answer needs. */
+  readonly scopes?: readonly string[];
+  /** The permission key an authorizer denied. */
+  readonly permission?: string;
+  /** The permission keys a `forbidden` caller lacks. */
+  readonly permissions?: readonly string[];
+  /** The pending approval of an `APPROVAL_REQUIRED` answer. */
+  readonly approval?: {
+    readonly id: string;
+  };
+  /** Seconds until a `rate_limited` or `quota_exceeded` caller may retry. */
+  readonly retryAfter?: number;
+  /** The meter a `quota_exceeded` answer ran out of, and its limit. */
+  readonly meter?: string;
+  readonly limit?: number;
+  /** The row limit a `max_affected` write exceeded. */
+  readonly maxAffected?: number;
+}
+/** The `type` prefix of kinds that mean more than their HTTP status. */
+declare const PROBLEM_TYPE_BASE = "https://bettersupabase.com/problems/";
+declare const PROBLEM_CONTENT_TYPE = "application/problem+json";
+interface ProblemOptions {
+  /** URI reference for this occurrence, e.g. the request path. */
+  readonly instance?: string;
+  /** Include messages of internal errors. Defaults to false. */
+  readonly expose?: boolean;
+}
+/**
+ * Rewrites the Problem Details a block answers with into the app's own error
+ * body, such as its `type` URIs and error codes. The status, `Retry-After`
+ * and `WWW-Authenticate` headers stay as they are.
+ */
+type ProblemFormat = (problem: ProblemDetails, error: DbError) => Readonly<Record<string, unknown>>;
+/** The `problem` option of the blocks that answer HTTP requests. */
+interface BlockProblemOptions {
+  /** The app's error body for the block's error responses. Defaults to RFC 9457 Problem Details. */
+  readonly problem?: ProblemFormat;
+}
+interface ProblemResponseOptions extends ProblemOptions {
+  readonly headers?: ConstructorParameters<typeof Headers>[0];
+  /** `realm` of the RFC 6750 challenge on 401. */
+  readonly realm?: string;
+  /** Rewrites the body; see `ProblemFormat`. */
+  readonly format?: ProblemFormat | undefined;
+}
+/** Converts a `DbError` to Problem Details. */
+declare function toProblem(error: DbError, options?: ProblemOptions): ProblemDetails;
+/**
+ * An `application/problem+json` response. A 401, and a 403 for a missing
+ * OAuth scope, carry an RFC 6750 `WWW-Authenticate: Bearer` challenge.
+ */
+declare function problemResponse(error: DbError, options?: ProblemResponseOptions): Response;
+declare function isProblem(value: unknown): value is ProblemDetails;
+/** Turns a Problem Details body back into a `DbError` (client side). */
+declare function fromProblem(problem: ProblemDetails): DbError;
+//#endregion
+export { ProblemFormat as a, fromProblem as c, toProblem as d, ProblemDetails as i, isProblem as l, PROBLEM_CONTENT_TYPE as n, ProblemOptions as o, PROBLEM_TYPE_BASE as r, ProblemResponseOptions as s, BlockProblemOptions as t, problemResponse as u };

package/dist/problem-pIiL3WbE.js

@@ -0,0 +1,159 @@
+import { l as statusOf, n as dbError } from "./errors-8i6tSICm.js";
+//#region src/core/problem.ts
+/** The `type` prefix of kinds that mean more than their HTTP status. */
+const PROBLEM_TYPE_BASE = "https://bettersupabase.com/problems/";
+const PROBLEM_CONTENT_TYPE = "application/problem+json";
+/** RFC 9457 section 4.2.1: a problem that means only its HTTP status. */
+const PROBLEM_TYPE_BLANK = "about:blank";
+/**
+* Kinds that say nothing beyond their HTTP status. At their default status
+* they use `about:blank` with the status phrase as `title`.
+*/
+const GENERIC = {
+	invalid_request: "Bad Request",
+	unauthorized: "Unauthorized",
+	forbidden: "Forbidden",
+	not_found: "Not Found",
+	conflict: "Conflict",
+	rate_limited: "Too Many Requests",
+	unexpected: "Internal Server Error"
+};
+const TITLES = {
+	not_found: "Not Found",
+	unauthorized: "Unauthorized",
+	forbidden: "Forbidden",
+	conflict: "Conflict",
+	foreign_key: "Referenced row missing or still referenced",
+	check: "Check constraint violated",
+	not_null: "Required value missing",
+	exclusion: "Exclusion constraint violated",
+	invalid_input: "Invalid input",
+	invalid_value: "Stored value not representable",
+	raised: "Request rejected",
+	timeout: "Timed out",
+	serialization: "Concurrent update, retry",
+	network: "Database unreachable",
+	aborted: "Aborted",
+	invalid_request: "Bad Request",
+	validation: "Validation failed",
+	multiple_rows: "More than one row matched",
+	stale: "Row changed since it was read",
+	max_affected: "Too many rows affected",
+	rate_limited: "Too Many Requests",
+	quota_exceeded: "Quota exceeded",
+	unsupported: "Not supported by this executor",
+	unexpected: "Internal Server Error"
+};
+/**
+* The `type` and `title` of a problem: `about:blank` and the status phrase
+* for a generic kind at its default status, otherwise the kind's URI under
+* `PROBLEM_TYPE_BASE`.
+*/
+function problemType(kind, status = statusOf(kind)) {
+	const phrase = GENERIC[kind];
+	if (phrase !== void 0 && status === statusOf(kind)) return {
+		type: PROBLEM_TYPE_BLANK,
+		title: phrase
+	};
+	return {
+		type: `${PROBLEM_TYPE_BASE}${kind.replaceAll("_", "-")}`,
+		title: TITLES[kind]
+	};
+}
+/** Kinds whose message may contain internals (SQL, hostnames), hidden unless `expose` is set. */
+const INTERNAL = /* @__PURE__ */ new Set([
+	"unexpected",
+	"network",
+	"invalid_request"
+]);
+/** Converts a `DbError` to Problem Details. */
+function toProblem(error, options = {}) {
+	const problem = {
+		...problemType(error.kind, error.status),
+		status: error.status,
+		kind: error.kind
+	};
+	if (!INTERNAL.has(error.kind) || options.expose) problem["detail"] = error.message;
+	if (options.instance) problem["instance"] = options.instance;
+	if (error.code) problem["code"] = error.code;
+	if (error.hint) problem["hint"] = error.hint;
+	if ("constraint" in error && error.constraint) problem["constraint"] = error.constraint;
+	if ("columns" in error) problem["columns"] = error.columns;
+	if ("column" in error && error.column) problem["column"] = error.column;
+	if ("issues" in error) problem["issues"] = error.issues;
+	if ("required" in error) problem["required"] = error.required;
+	if ("scopes" in error) problem["scopes"] = error.scopes;
+	if ("permission" in error) problem["permission"] = error.permission;
+	if ("permissions" in error) problem["permissions"] = error.permissions;
+	if ("approval" in error) problem["approval"] = error.approval;
+	if ("retryAfter" in error) problem["retryAfter"] = error.retryAfter;
+	if ("meter" in error) problem["meter"] = error.meter;
+	if ("limit" in error) problem["limit"] = error.limit;
+	if ("maxAffected" in error) problem["maxAffected"] = error.maxAffected;
+	return problem;
+}
+/**
+* An `application/problem+json` response. A 401, and a 403 for a missing
+* OAuth scope, carry an RFC 6750 `WWW-Authenticate: Bearer` challenge.
+*/
+function problemResponse(error, options = {}) {
+	const headers = new Headers(options.headers);
+	headers.set("content-type", PROBLEM_CONTENT_TYPE);
+	const realm = (options.realm ?? "supabase").replaceAll("\"", "");
+	if (error.status === 401 && !headers.has("www-authenticate")) {
+		const params = error.code === "MISSING_CREDENTIALS" ? "" : ", error=\"invalid_token\"";
+		headers.set("www-authenticate", `Bearer realm="${realm}"${params}`);
+	}
+	if ("scopes" in error && error.code === "INSUFFICIENT_SCOPE" && !headers.has("www-authenticate")) {
+		const scope = error.scopes.join(" ").replaceAll("\"", "");
+		headers.set("www-authenticate", `Bearer realm="${realm}", error="insufficient_scope", scope="${scope}"`);
+	}
+	if ("retryAfter" in error && !headers.has("retry-after")) headers.set("retry-after", String(error.retryAfter));
+	const problem = toProblem(error, options);
+	const body = options.format ? options.format(problem, error) : problem;
+	return Response.json(body, {
+		status: error.status,
+		headers
+	});
+}
+function isProblem(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const problem = value;
+	return typeof problem["type"] === "string" && typeof problem["status"] === "number" && typeof problem["title"] === "string";
+}
+function isKind(value) {
+	return typeof value === "string" && value in TITLES;
+}
+/** Turns a Problem Details body back into a `DbError` (client side). */
+function fromProblem(problem) {
+	const kind = isKind(problem.kind) ? problem.kind : "unexpected";
+	const extra = { status: problem.status };
+	for (const key of [
+		"code",
+		"hint",
+		"constraint",
+		"columns",
+		"column",
+		"required",
+		"scopes",
+		"permission",
+		"permissions",
+		"approval",
+		"retryAfter",
+		"meter",
+		"limit",
+		"maxAffected"
+	]) if (problem[key] !== void 0) extra[key] = problem[key];
+	extra["issues"] = problem.issues ?? [];
+	if (kind !== "validation") delete extra["issues"];
+	return dbError(kind, problem.detail ?? problem.title, extra);
+}
+/** An empty `405` that lists the methods a route does accept. */
+function methodNotAllowed(allowed) {
+	return new Response(null, {
+		status: 405,
+		headers: { allow: allowed.join(", ") }
+	});
+}
+//#endregion
+export { methodNotAllowed as a, toProblem as c, isProblem as i, PROBLEM_TYPE_BASE as n, problemResponse as o, fromProblem as r, problemType as s, PROBLEM_CONTENT_TYPE as t };

package/dist/provider-CQ1SrhLa.d.ts

@@ -0,0 +1,113 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "./result-Cj3yWhjH.js";
+import { r as AuthState } from "./resolve-7atr-wWr.js";
+//#region src/credentials/provider.d.ts
+/**
+ * Names a credential without holding it. Tables store this as a
+ * `credential_ref jsonb` column; `provider` picks the `CredentialProvider`
+ * and the other keys are that provider's.
+ */
+type CredentialRef = {
+  readonly provider: string;
+  /**
+   * The tenant that owns the credential. A provider resolves, sets and
+   * revokes a ref with `tenant` only inside that tenant's namespace, so a
+   * tenant admin who picks a ref can never name another tenant's or the
+   * app's secret.
+   */
+  readonly tenant?: string;
+} & Readonly<Record<string, unknown>>;
+/** `ref` bound to `tenant`'s namespace. */
+declare function tenantCredentialRef<R extends CredentialRef>(tenant: string, ref: R): R & {
+  readonly tenant: string;
+};
+/**
+ * Whether `ref` belongs to `tenant`: its `tenant` is exactly that tenant.
+ * Without a tenant (an app-level row), only a ref without one belongs.
+ */
+declare function credentialRefInTenant(ref: CredentialRef, tenant: string | undefined): boolean;
+/** The error for a ref that names a credential outside the row's tenant. */
+declare function foreignCredentialRef(tenant: string | undefined): DbError;
+/** Whose credential to use: the app's own, or one a user connected. */
+type CredentialSubject = {
+  readonly type: "app";
+} | {
+  readonly type: "user";
+  readonly id: string;
+  readonly issuer?: string;
+};
+interface GetTokenOptions {
+  readonly subject: CredentialSubject;
+  readonly scopes?: readonly string[];
+  readonly installationId?: string;
+  readonly signal?: AbortSignal;
+}
+interface CredentialToken {
+  readonly token: string;
+  /** Unset when the provider doesn't know when the token expires. */
+  readonly expiresAt?: Temporal.Instant;
+  /** Headers that authenticate a request with this token. */
+  readonly headers: Readonly<Record<string, string>>;
+}
+interface CredentialCapabilities {
+  /** The ref holds one credential per user subject. */
+  readonly userSubjects: boolean;
+  /** `startAuthorization` can send the user to connect the account. */
+  readonly authorization: boolean;
+  readonly revoke: boolean;
+  /** `verifyInbound` can check requests the third party sends. */
+  readonly inbound: boolean;
+}
+interface StartAuthorizationOptions {
+  readonly subject: CredentialSubject;
+  readonly redirectUri: string;
+  readonly scopes?: readonly string[];
+  readonly state?: string;
+}
+interface CompleteAuthorizationOptions {
+  readonly subject: CredentialSubject;
+  /** The callback request, or its URL, that carries the code and state. */
+  readonly callback: Request | URL | string;
+}
+/**
+ * Resolves `CredentialRef`s to tokens. Versioned: a breaking change to this
+ * contract ships a new `apiVersion`. Errors are `DbError`s: `invalid_input`
+ * for a ref the provider doesn't handle, `not_found` when no credential is
+ * stored, `forbidden` when the subject may not use it.
+ */
+interface CredentialProvider {
+  readonly apiVersion: 1;
+  readonly name: string;
+  getToken(ref: CredentialRef, options: GetTokenOptions): AsyncResult<CredentialToken>;
+  capabilities(ref: CredentialRef): CredentialCapabilities;
+  /** The URL to send the user to; only when `capabilities(ref).authorization`. */
+  startAuthorization?(ref: CredentialRef, options: StartAuthorizationOptions): AsyncResult<{
+    readonly url: string;
+  }>;
+  completeAuthorization?(ref: CredentialRef, options: CompleteAuthorizationOptions): AsyncResult<void>;
+  /** Forgets the stored credential; `false` when there was none. */
+  revoke(ref: CredentialRef, options: {
+    readonly subject: CredentialSubject;
+  }): AsyncResult<boolean>;
+  /** Checks a request the third party sent (a webhook) against the ref's secret. */
+  verifyInbound?(request: Request, ref: CredentialRef): AsyncResult<boolean>;
+  /**
+   * Stores or replaces the credential a ref names, for `subject` when the
+   * ref is per user. Optional: a provider without it can't take a secret
+   * from the app (an OAuth-only provider, say).
+   */
+  set?(ref: CredentialRef, value: string, options?: SetCredentialOptions): AsyncResult<void>;
+}
+interface SetCredentialOptions {
+  readonly subject?: CredentialSubject;
+  readonly description?: string;
+}
+/**
+ * The subject for a request: the user behind a session or a user-bound API
+ * key, the app for the service role, and `undefined` for anyone else.
+ */
+declare function subjectFor(context: {
+  readonly auth: AuthState;
+}): CredentialSubject | undefined;
+//#endregion
+export { CredentialSubject as a, SetCredentialOptions as c, foreignCredentialRef as d, subjectFor as f, CredentialRef as i, StartAuthorizationOptions as l, CredentialCapabilities as n, CredentialToken as o, tenantCredentialRef as p, CredentialProvider as r, GetTokenOptions as s, CompleteAuthorizationOptions as t, credentialRefInTenant as u };

package/dist/provider-DKh2xFZb.js

@@ -0,0 +1,57 @@
+import { n as dbError } from "./errors-8i6tSICm.js";
+//#region src/credentials/provider.ts
+/** `ref` bound to `tenant`'s namespace. */
+function tenantCredentialRef(tenant, ref) {
+	return {
+		...ref,
+		tenant
+	};
+}
+/**
+* Whether `ref` belongs to `tenant`: its `tenant` is exactly that tenant.
+* Without a tenant (an app-level row), only a ref without one belongs.
+*/
+function credentialRefInTenant(ref, tenant) {
+	const owner = ref.tenant;
+	return tenant === void 0 ? owner === void 0 : typeof owner === "string" && owner === tenant;
+}
+/** The error for a ref that names a credential outside the row's tenant. */
+function foreignCredentialRef(tenant) {
+	return dbError("forbidden", tenant === void 0 ? "An app-level credential_ref can't name a tenant's credential" : `The credential_ref names a credential outside tenant "${tenant}"`, { hint: "CREDENTIAL_REF_FOREIGN" });
+}
+/** Checks the provider's `apiVersion` before the server uses it. */
+function credentialProviderOf(provider) {
+	const version = provider.apiVersion;
+	if (version !== 1) throw new TypeError(`credentials "${provider.name}" targets credential provider API ${String(version)}; this better-supabase supports 1. Upgrade better-supabase or use a release of the provider for API 1.`);
+	return provider;
+}
+/**
+* The subject for a request: the user behind a session or a user-bound API
+* key, the app for the service role, and `undefined` for anyone else.
+*/
+function subjectFor(context) {
+	const { auth } = context;
+	switch (auth.kind) {
+		case "user": {
+			const issuer = auth.claims.iss;
+			return typeof issuer === "string" && issuer.length > 0 ? {
+				type: "user",
+				id: auth.claims.sub,
+				issuer
+			} : {
+				type: "user",
+				id: auth.claims.sub
+			};
+		}
+		case "apiKey": return auth.userId === void 0 ? void 0 : {
+			type: "user",
+			id: auth.userId
+		};
+		case "service": return { type: "app" };
+		case "anon":
+		case "invalid": return;
+		default: return auth;
+	}
+}
+//#endregion
+export { tenantCredentialRef as a, subjectFor as i, credentialRefInTenant as n, foreignCredentialRef as r, credentialProviderOf as t };

package/dist/push-token-CDMgWT13.d.ts

@@ -0,0 +1,24 @@
+import { s as PushTokenPort } from "./ports-Dcnuo3HT.js";
+//#region src/client/native/push-token.d.ts
+/** The part of `expo-notifications` the push token port uses. */
+interface ExpoNotificationsLike {
+  getPermissionsAsync(): Promise<{
+    readonly status: string;
+  }>;
+  requestPermissionsAsync(): Promise<{
+    readonly status: string;
+  }>;
+  getExpoPushTokenAsync(options?: {
+    readonly projectId?: string;
+  }): Promise<{
+    readonly data: string;
+  }>;
+}
+interface ExpoPushTokenOptions {
+  /** `Constants.easConfig?.projectId`; Expo needs it outside Expo Go. */
+  readonly projectId?: string | undefined;
+}
+/** The push token port over `expo-notifications`: the Expo push token. */
+declare function expoPushToken(notifications: ExpoNotificationsLike, options?: ExpoPushTokenOptions): PushTokenPort;
+//#endregion
+export { ExpoPushTokenOptions as n, expoPushToken as r, ExpoNotificationsLike as t };

package/dist/push-token-D6REHMMw.js

@@ -0,0 +1,16 @@
+//#region src/client/native/push-token.ts
+/** The push token port over `expo-notifications`: the Expo push token. */
+function expoPushToken(notifications, options = {}) {
+	return {
+		provider: "expo",
+		token: async ({ request = true } = {}) => {
+			let { status } = await notifications.getPermissionsAsync();
+			if (status !== "granted" && request) ({status} = await notifications.requestPermissionsAsync());
+			if (status !== "granted") return null;
+			const { data } = await notifications.getExpoPushTokenAsync(options.projectId === void 0 ? {} : { projectId: options.projectId });
+			return data;
+		}
+	};
+}
+//#endregion
+export { expoPushToken as t };

package/dist/query/index.d.ts

@@ -1,4 +1,4 @@
-import { t as escapeLike } from "../escape-like-DDWoHzh_.js";
+import { t as escapeLike } from "../escape-like-AUEPn-C5.js";
 import { n as invalidateTables, t as BetterQueryMeta } from "../invalidate-BBqhpxyB.js";
-import { _ as invalidateOnMutation, a as UserChangeSource, c as InfiniteExtras, d as QueriesOptions, f as QueryHelpers, g as createQueries, h as TableQueries, i as optimistic, l as InfiniteOptionsOf, m as QueryOptionsOf, n as OptimisticSnapshot, o as clearOnUserChange, p as QueryKeyOf, r as OptimisticTarget, s as BetterQueries, t as OptimisticHandlers, u as MutationOptionsOf, v as queryCache } from "../index-DoNVLHOU.js";
+import { _ as invalidateOnMutation, a as UserChangeSource, c as InfiniteExtras, d as QueriesOptions, f as QueryHelpers, g as createQueries, h as TableQueries, i as optimistic, l as InfiniteOptionsOf, m as QueryOptionsOf, n as OptimisticSnapshot, o as clearOnUserChange, p as QueryKeyOf, r as OptimisticTarget, s as BetterQueries, t as OptimisticHandlers, u as MutationOptionsOf, v as queryCache } from "../index-Cckxs8IE.js";
 export { type BetterQueries, type BetterQueryMeta, type InfiniteExtras, type InfiniteOptionsOf, type MutationOptionsOf, type OptimisticHandlers, type OptimisticSnapshot, type OptimisticTarget, type QueriesOptions, type QueryHelpers, type QueryKeyOf, type QueryOptionsOf, type TableQueries, type UserChangeSource, clearOnUserChange, createQueries, escapeLike, invalidateOnMutation, invalidateTables, optimistic, queryCache };

package/dist/range-DwpWe8e7.js

@@ -0,0 +1,7 @@
+//#region src/blocks/range.ts
+/** Whether two ranges cover the same instants. */
+function sameRange(a, b) {
+	return a.start.getTime() === b.start.getTime() && a.end.getTime() === b.end.getTime();
+}
+//#endregion
+export { sameRange as t };

package/dist/range-p5V4rBhZ.d.ts

@@ -0,0 +1,8 @@
+//#region src/blocks/range.d.ts
+/** A visible range, as a date picker, schedule or event calendar reports it. */
+interface VisibleRange {
+  readonly start: Date;
+  readonly end: Date;
+}
+//#endregion
+export { VisibleRange as t };

package/dist/rank-keys-DcPMt_Jk.js

@@ -0,0 +1,60 @@
+//#region src/core/rank-keys.ts
+/** The queue `move()` enqueues on when a key grows past 24 digits. */
+const RANK_REBALANCE_QUEUE = "rank.rebalance";
+/** The digits, in byte order. */
+const RANK_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const BASE = 62;
+const KEY = /^[0-9A-Za-z]*[1-9A-Za-z]$/;
+/** True for a key `rankBetween` can take: base-62 digits, not ending in "0". */
+function isRankKey(value) {
+	return typeof value === "string" && KEY.test(value);
+}
+function digitAt(key, index) {
+	return index < key.length ? RANK_ALPHABET.indexOf(key.charAt(index)) : 0;
+}
+/**
+* A key that sorts after `previous` and before `next`. `null` is an open end:
+* `rankBetween(null, null)` is the first key of an empty list. Throws a
+* `RangeError` for an invalid key or when `previous` is not below `next`.
+*/
+function rankBetween(previous, next) {
+	if (previous !== null && !KEY.test(previous)) throw new RangeError(`"${previous}" is not a rank key`);
+	if (next !== null && !KEY.test(next)) throw new RangeError(`"${next}" is not a rank key`);
+	if (previous !== null && next !== null && previous >= next) throw new RangeError(`"${previous}" must sort before "${next}"`);
+	const low = previous ?? "";
+	let key = "";
+	let bounded = next !== null;
+	for (let index = 0;; index += 1) {
+		const lowDigit = digitAt(low, index);
+		const highDigit = bounded && next !== null ? digitAt(next, index) : BASE;
+		if (highDigit === lowDigit) {
+			key += RANK_ALPHABET.charAt(lowDigit);
+			continue;
+		}
+		if (highDigit - lowDigit > 1) return key + RANK_ALPHABET.charAt(Math.floor((lowDigit + highDigit) / 2));
+		if (bounded && next !== null && index + 1 < next.length) return key + next.charAt(index);
+		key += RANK_ALPHABET.charAt(lowDigit);
+		bounded = false;
+	}
+}
+/**
+* `count` keys spread evenly, in order: what the rebalance job writes. No key
+* is longer than the fewest base-62 digits that can number `count` rows.
+*/
+function rankKeys(count) {
+	if (!Number.isSafeInteger(count) || count < 0) throw new RangeError("count must be a whole number of keys");
+	let width = 1;
+	while (BASE ** width <= count) width += 1;
+	const step = Math.floor(BASE ** width / (count + 1));
+	return Array.from({ length: count }, (_, index) => {
+		let value = step * (index + 1);
+		let key = "";
+		for (let place = 0; place < width; place += 1) {
+			key = RANK_ALPHABET.charAt(value % BASE) + key;
+			value = Math.floor(value / BASE);
+		}
+		return key.replace(/0+$/, "");
+	});
+}
+//#endregion
+export { rankKeys as a, rankBetween as i, RANK_REBALANCE_QUEUE as n, isRankKey as r, RANK_ALPHABET as t };

package/dist/rank-result-Dngpt2n5.d.ts

@@ -0,0 +1,14 @@
+import { f as Result } from "./result-Cj3yWhjH.js";
+//#region src/core/rank-result.d.ts
+/** Neighbour keys for a reorder; leave one out (or `null`) for an end. */
+interface RankNeighbors {
+  readonly previous?: string | null;
+  readonly next?: string | null;
+}
+/**
+ * `rankBetween` as a result: an `invalid_request` error with the hint
+ * `RANK_KEY_INVALID` instead of a `RangeError`.
+ */
+declare function rankBetweenResult(neighbors: RankNeighbors): Result<string>;
+//#endregion
+export { rankBetweenResult as n, RankNeighbors as t };

package/dist/rank-result-oUF1DYBm.js

@@ -0,0 +1,18 @@
+import { n as dbError } from "./errors-8i6tSICm.js";
+import { a as ok, r as err } from "./result-COkvI9t5.js";
+import { i as rankBetween } from "./rank-keys-DcPMt_Jk.js";
+//#region src/core/rank-result.ts
+/**
+* `rankBetween` as a result: an `invalid_request` error with the hint
+* `RANK_KEY_INVALID` instead of a `RangeError`.
+*/
+function rankBetweenResult(neighbors) {
+	try {
+		return ok(rankBetween(neighbors.previous ?? null, neighbors.next ?? null));
+	} catch (cause) {
+		const message = cause instanceof Error ? cause.message : String(cause);
+		return err(dbError("invalid_request", message, { hint: "RANK_KEY_INVALID" }));
+	}
+}
+//#endregion
+export { rankBetweenResult as t };

package/dist/rate-limit-BtbddDnE.js

@@ -0,0 +1,49 @@
+import { n as dbError } from "./errors-8i6tSICm.js";
+import { i as rateLimitPolicyHeader, n as periodSeconds, r as rateLimitHeader, t as isRateLimitPolicyName } from "./ratelimit-headers-Bsxx0Tj2.js";
+//#region src/server/rate-limit.ts
+/** Counts a hit for each request and builds the RateLimit fields or the refusal. */
+function rateLimitGate(options) {
+	const policy = options.policy ?? options.scope;
+	if (!isRateLimitPolicyName(policy)) throw new TypeError(`rateLimit(): "${policy}" can't name a RateLimit policy; pass a printable ASCII \`policy\``);
+	const window = options.rule === void 0 ? void 0 : periodSeconds(options.rule.period);
+	const policyHeader = options.rule === void 0 ? void 0 : rateLimitPolicyHeader([{
+		name: policy,
+		quota: options.rule.max,
+		...window === void 0 ? {} : { window }
+	}]);
+	const headersFor = (remaining, reset) => {
+		const headers = new Headers();
+		if (policyHeader !== void 0) headers.set("ratelimit-policy", policyHeader);
+		headers.set("ratelimit", rateLimitHeader([{
+			policy,
+			remaining,
+			...reset === void 0 ? {} : { reset }
+		}]));
+		return headers;
+	};
+	return async (input) => {
+		const key = await options.key(input);
+		if (key === void 0) return { kind: "skip" };
+		const checked = await options.limiter.check(options.scope, key, options.rule);
+		if (!checked.ok) return options.failOpen ? { kind: "skip" } : {
+			kind: "deny",
+			error: checked.error,
+			headers: new Headers()
+		};
+		const verdict = checked.data;
+		if (verdict.allowed) return {
+			kind: "allow",
+			headers: headersFor(Math.max(0, verdict.remaining))
+		};
+		const retryAfter = Math.max(1, Math.ceil(verdict.retryAfter));
+		const headers = headersFor(0, retryAfter);
+		headers.set("retry-after", String(retryAfter));
+		return {
+			kind: "deny",
+			error: dbError("rate_limited", `Too many requests. Retry after ${retryAfter} seconds.`, { retryAfter }),
+			headers
+		};
+	};
+}
+//#endregion
+export { rateLimitGate as t };