better-supabase 0.15.1 → 0.16.0

package/dist/sql/index.d.ts

@@ -1,5 +1,5 @@
 import { A as BLOCK_OPTION_SCHEMAS, O as resolveBlock, j as BlockOptionsRegistry } from "../authorization-HZdJCaVm.js";
-import { C as OwnView, Qn as auditRegistrations, S as BlockSqlUpgrade, T as notNullCheckName, Xn as sameTenantLayout, Yn as DeclaredForeignKey, Zn as AuditedTable, _ as BlockSqlDeprecation, a as BlockSqlContext, b as BlockSqlLayout, c as BlockSqlIdType, d as MODULE_ID_TYPES, f as contractSignature, g as BlockSqlAccessProvider, h as BlockSql, i as BlockSqlAudit, l as BlockSqlNames, m as moduleIdType, n as AuditCategory, o as BlockSqlContractFunction, p as isBlockSqlIdType, r as BlockSqlAction, s as BlockSqlEmit, t as AUDIT_CATEGORIES, u as BlockSqlTableSpec, v as BlockSqlEntitlementsProvider, w as blockSqlVersion, x as BlockSqlTestFile, y as BlockSqlFile } from "../context-TGX2eDS5.js";
-import { a as appTableEventTypes } from "../app-tables-CbCFSXLG.js";
-import { $ as modulePermissionKeys, A as sameTenantColumn, B as adoptedTables, C as extensionSchema, D as TenantQuery, E as subjectColumns, F as excludedColumns, G as DEFAULT_ROLES, H as APP_TABLES_MARKER, I as resolveExposeColumns, J as resolveBlocks, K as instanceFunctions, L as AdoptedTable, M as DataExportPlan, N as SECRET_COLUMNS, O as tenantsQuery, P as dataExportPlan, Q as moduleHidingColumns, R as AdoptedView, S as declaredViews, St as renderBlocks, T as rlsTables, U as APP_TABLES_MODULE, V as adoptedViews, W as appTablesFiles, X as BlockSqlPermissionKey, Y as BlockSqlExtension, Z as moduleEventTriggers, _ as DeclaredView, _t as upgradePlan, a as hasColumnAccess, at as moduleDataDir, b as declaredTables, bt as moduleBody, c as compileReadSets, ct as EntityRenameStep, d as migrationOptionUses, dt as currentBlockName, et as moduleSchemaExtensions, f as moduleLayout, ft as formerBlockName, g as templateFunctions, gt as moduleDeprecations, h as scopeProblems, ht as InstalledBlock, i as scopePolicyName, it as sameBlockFile, j as sameTenantTrigger, k as expiredFlagsQuery, l as sharedRolesProblems, lt as entityRenamePlan, m as resolveProviderSql, mt as BlockSqlUpgradePlan, n as widenedCommands, nt as isModuleDataFile, o as CompiledReadSet, ot as moduleFilePaths, p as SCOPE_ID_TYPES, pt as renamedBlock, q as SQL_MODULES, r as TENANT_SCOPE_POLICY, rt as moduleFileVersion, s as compileReadSet, st as EntityRenamePlan, t as declaredPolicies, tt as blockFileState, u as MigrationOptionUse, ut as BLOCK_RENAMES, v as PolicyGrant, vt as BlockSqlTopic, w as policyGrants, x as declaredUpdatedAtTriggers, xt as moduleTopics, y as declaredTableColumns, yt as customContracts, z as adoptedColumnProblems } from "../index-BfK6olKm.js";
+import { C as OwnView, Qn as auditRegistrations, S as BlockSqlUpgrade, T as notNullCheckName, Xn as sameTenantLayout, Yn as DeclaredForeignKey, Zn as AuditedTable, _ as BlockSqlDeprecation, a as BlockSqlContext, b as BlockSqlLayout, c as BlockSqlIdType, d as MODULE_ID_TYPES, f as contractSignature, g as BlockSqlAccessProvider, h as BlockSql, i as BlockSqlAudit, l as BlockSqlNames, m as moduleIdType, n as AuditCategory, o as BlockSqlContractFunction, p as isBlockSqlIdType, r as BlockSqlAction, s as BlockSqlEmit, t as AUDIT_CATEGORIES, u as BlockSqlTableSpec, v as BlockSqlEntitlementsProvider, w as blockSqlVersion, x as BlockSqlTestFile, y as BlockSqlFile } from "../context-8kb8m5uO.js";
+import { a as appTableEventTypes } from "../app-tables-yMQ4ubyY.js";
+import { $ as modulePermissionKeys, A as sameTenantColumn, B as adoptedTables, C as extensionSchema, D as TenantQuery, E as subjectColumns, F as excludedColumns, G as DEFAULT_ROLES, H as APP_TABLES_MARKER, I as resolveExposeColumns, J as resolveBlocks, K as instanceFunctions, L as AdoptedTable, M as DataExportPlan, N as SECRET_COLUMNS, O as tenantsQuery, P as dataExportPlan, Q as moduleHidingColumns, R as AdoptedView, S as declaredViews, St as renderBlocks, T as rlsTables, U as APP_TABLES_MODULE, V as adoptedViews, W as appTablesFiles, X as BlockSqlPermissionKey, Y as BlockSqlExtension, Z as moduleEventTriggers, _ as DeclaredView, _t as upgradePlan, a as hasColumnAccess, at as moduleDataDir, b as declaredTables, bt as moduleBody, c as compileReadSets, ct as EntityRenameStep, d as migrationOptionUses, dt as currentBlockName, et as moduleSchemaExtensions, f as moduleLayout, ft as formerBlockName, g as templateFunctions, gt as moduleDeprecations, h as scopeProblems, ht as InstalledBlock, i as scopePolicyName, it as sameBlockFile, j as sameTenantTrigger, k as expiredFlagsQuery, l as sharedRolesProblems, lt as entityRenamePlan, m as resolveProviderSql, mt as BlockSqlUpgradePlan, n as widenedCommands, nt as isModuleDataFile, o as CompiledReadSet, ot as moduleFilePaths, p as SCOPE_ID_TYPES, pt as renamedBlock, q as SQL_MODULES, r as TENANT_SCOPE_POLICY, rt as moduleFileVersion, s as compileReadSet, st as EntityRenamePlan, t as declaredPolicies, tt as blockFileState, u as MigrationOptionUse, ut as BLOCK_RENAMES, v as PolicyGrant, vt as BlockSqlTopic, w as policyGrants, x as declaredUpdatedAtTriggers, xt as moduleTopics, y as declaredTableColumns, yt as customContracts, z as adoptedColumnProblems } from "../index-Cc4mIQS8.js";
 export { APP_TABLES_MARKER, APP_TABLES_MODULE, AUDIT_CATEGORIES, type AdoptedTable, type AdoptedView, type AuditCategory, type AuditedTable, BLOCK_OPTION_SCHEMAS, BLOCK_RENAMES, type BlockOptionsRegistry, type BlockSql, type BlockSqlAccessProvider, type BlockSqlAction, type BlockSqlAudit, type BlockSqlContext, type BlockSqlContractFunction, type BlockSqlDeprecation, type BlockSqlEmit, type BlockSqlEntitlementsProvider, type BlockSqlExtension, type BlockSqlFile, type BlockSqlIdType, type BlockSqlLayout, type BlockSqlNames, type BlockSqlPermissionKey, type BlockSqlTableSpec, type BlockSqlTestFile, type BlockSqlTopic, type BlockSqlUpgrade, type BlockSqlUpgradePlan, type CompiledReadSet, DEFAULT_ROLES, type DataExportPlan, type DeclaredForeignKey, type DeclaredView, type EntityRenamePlan, type EntityRenameStep, type InstalledBlock, MODULE_ID_TYPES, type MigrationOptionUse, type OwnView, type PolicyGrant, SCOPE_ID_TYPES, SECRET_COLUMNS, SQL_MODULES, TENANT_SCOPE_POLICY, type TenantQuery, adoptedColumnProblems, adoptedTables, adoptedViews, appTableEventTypes, appTablesFiles, auditRegistrations, blockFileState, blockSqlVersion, compileReadSet, compileReadSets, contractSignature, currentBlockName, customContracts, dataExportPlan, declaredPolicies, declaredTableColumns, declaredTables, declaredUpdatedAtTriggers, declaredViews, entityRenamePlan, excludedColumns, expiredFlagsQuery, extensionSchema, formerBlockName, hasColumnAccess, instanceFunctions, isBlockSqlIdType, isModuleDataFile, migrationOptionUses, moduleBody, moduleDataDir, moduleDeprecations, moduleEventTriggers, moduleFilePaths, moduleFileVersion, moduleHidingColumns, moduleIdType, moduleLayout, modulePermissionKeys, moduleSchemaExtensions, moduleTopics, notNullCheckName, policyGrants, renamedBlock, renderBlocks, resolveBlock, resolveBlocks, resolveExposeColumns, resolveProviderSql, rlsTables, sameBlockFile, sameTenantColumn, sameTenantLayout, sameTenantTrigger, scopePolicyName, scopeProblems, sharedRolesProblems, subjectColumns, templateFunctions, tenantsQuery, upgradePlan, widenedCommands };

package/dist/sql/index.js

@@ -1,5 +1,5 @@
 import { A as resolveBlock, l as appTableEventTypes, v as hasColumnAccess } from "../app-tables-D29Rahtg.js";
 import { c as templateFunctions, o as resolveProviderSql, s as scopeProblems, t as SCOPE_ID_TYPES } from "../access-sql-B-MkVARa.js";
 import { Y as notNullCheckName, a as DEFAULT_ROLES } from "../workflow-sdk-Bw6_u0ar.js";
-import { $ as contractSignature, A as moduleFileVersion, B as resolveExposeColumns, C as APP_TABLES_MARKER, D as blockSqlVersion, E as scopePolicyName, F as moduleSchemaExtensions, G as sameTenantTrigger, H as dataExportPlan, I as SQL_MODULES, J as currentBlockName, K as migrationOptionUses, L as resolveBlocks, M as moduleEventTriggers, N as moduleHidingColumns, O as blockFileState, P as modulePermissionKeys, Q as MODULE_ID_TYPES, R as TENANT_SCOPE_POLICY, S as moduleFilePaths, T as appTablesFiles, U as subjectColumns, V as SECRET_COLUMNS, W as sameTenantColumn, X as renamedBlock, Y as formerBlockName, Z as AUDIT_CATEGORIES, _ as moduleDeprecations, a as tenantsQuery, at as declaredUpdatedAtTriggers, b as widenedCommands, c as adoptedColumnProblems, ct as policyGrants, d as instanceFunctions, et as isBlockSqlIdType, f as entityRenamePlan, g as renderBlocks, h as moduleTopics, i as moduleLayout, it as declaredTables, j as sameBlockFile, k as isModuleDataFile, l as adoptedTables, lt as rlsTables, m as moduleBody, n as compileReadSets, nt as BLOCK_OPTION_SCHEMAS, o as expiredFlagsQuery, ot as declaredViews, p as customContracts, q as BLOCK_RENAMES, r as sharedRolesProblems, rt as declaredTableColumns, s as sameTenantLayout, st as extensionSchema, t as compileReadSet, tt as moduleIdType, u as adoptedViews, ut as auditRegistrations, v as upgradePlan, w as APP_TABLES_MODULE, x as moduleDataDir, y as declaredPolicies, z as excludedColumns } from "../sql-OLVW4t08.js";
+import { $ as contractSignature, A as moduleFileVersion, B as resolveExposeColumns, C as APP_TABLES_MARKER, D as blockSqlVersion, E as scopePolicyName, F as moduleSchemaExtensions, G as sameTenantTrigger, H as dataExportPlan, I as SQL_MODULES, J as currentBlockName, K as migrationOptionUses, L as resolveBlocks, M as moduleEventTriggers, N as moduleHidingColumns, O as blockFileState, P as modulePermissionKeys, Q as MODULE_ID_TYPES, R as TENANT_SCOPE_POLICY, S as moduleFilePaths, T as appTablesFiles, U as subjectColumns, V as SECRET_COLUMNS, W as sameTenantColumn, X as renamedBlock, Y as formerBlockName, Z as AUDIT_CATEGORIES, _ as moduleDeprecations, a as tenantsQuery, at as declaredUpdatedAtTriggers, b as widenedCommands, c as adoptedColumnProblems, ct as policyGrants, d as instanceFunctions, et as isBlockSqlIdType, f as entityRenamePlan, g as renderBlocks, h as moduleTopics, i as moduleLayout, it as declaredTables, j as sameBlockFile, k as isModuleDataFile, l as adoptedTables, lt as rlsTables, m as moduleBody, n as compileReadSets, nt as BLOCK_OPTION_SCHEMAS, o as expiredFlagsQuery, ot as declaredViews, p as customContracts, q as BLOCK_RENAMES, r as sharedRolesProblems, rt as declaredTableColumns, s as sameTenantLayout, st as extensionSchema, t as compileReadSet, tt as moduleIdType, u as adoptedViews, ut as auditRegistrations, v as upgradePlan, w as APP_TABLES_MODULE, x as moduleDataDir, y as declaredPolicies, z as excludedColumns } from "../sql-Dl3Alk43.js";
 export { APP_TABLES_MARKER, APP_TABLES_MODULE, AUDIT_CATEGORIES, BLOCK_OPTION_SCHEMAS, BLOCK_RENAMES, DEFAULT_ROLES, MODULE_ID_TYPES, SCOPE_ID_TYPES, SECRET_COLUMNS, SQL_MODULES, TENANT_SCOPE_POLICY, adoptedColumnProblems, adoptedTables, adoptedViews, appTableEventTypes, appTablesFiles, auditRegistrations, blockFileState, blockSqlVersion, compileReadSet, compileReadSets, contractSignature, currentBlockName, customContracts, dataExportPlan, declaredPolicies, declaredTableColumns, declaredTables, declaredUpdatedAtTriggers, declaredViews, entityRenamePlan, excludedColumns, expiredFlagsQuery, extensionSchema, formerBlockName, hasColumnAccess, instanceFunctions, isBlockSqlIdType, isModuleDataFile, migrationOptionUses, moduleBody, moduleDataDir, moduleDeprecations, moduleEventTriggers, moduleFilePaths, moduleFileVersion, moduleHidingColumns, moduleIdType, moduleLayout, modulePermissionKeys, moduleSchemaExtensions, moduleTopics, notNullCheckName, policyGrants, renamedBlock, renderBlocks, resolveBlock, resolveBlocks, resolveExposeColumns, resolveProviderSql, rlsTables, sameBlockFile, sameTenantColumn, sameTenantLayout, sameTenantTrigger, scopePolicyName, scopeProblems, sharedRolesProblems, subjectColumns, templateFunctions, tenantsQuery, upgradePlan, widenedCommands };

package/dist/{sql-OLVW4t08.js → sql-Dl3Alk43.js}

@@ -94909,6 +94909,133 @@ $$;
 revoke execute on function better_supabase.check_rate_limit(text, text, integer, interval) from public, anon, authenticated;
 grant execute on function better_supabase.check_rate_limit(text, text, integer, interval) to service_role;
 
+-- Counts one hit against several limits at once: hits is a JSON array of
+-- { scope, key, max_requests?, period? }, each with its own scope and key.
+-- The counters are locked in a fixed order and the hit counts only when every
+-- limit allows it, so a refused call leaves every counter as it was. Returns
+-- { allowed, blocked, retry_after, results }: blocked is the index of the first
+-- limit over its maximum, retry_after the longest wait of the refusing
+-- limits, and results one { allowed, remaining, retry_after } per hit.
+create or replace function better_supabase.check_rate_limits(hits jsonb)
+returns jsonb
+language plpgsql
+security definer
+set search_path = ''
+as $$
+declare
+  total integer;
+  scopes text[] := '{}';
+  keys text[] := '{}';
+  maxes integer[] := '{}';
+  periods interval[] := '{}';
+  used integer[] := '{}';
+  starts timestamptz[] := '{}';
+  hit jsonb;
+  rule better_supabase.rate_limit_rules;
+  counter better_supabase.rate_limits;
+  limit_max integer;
+  limit_period interval;
+  current_hits integer;
+  first_blocked integer;
+  longest integer := 0;
+  passed boolean;
+  results jsonb := '[]'::jsonb;
+begin
+  if jsonb_typeof(hits) is distinct from 'array' or jsonb_array_length(hits) = 0 then
+    raise exception 'check_rate_limits needs a non-empty array of hits'
+      using errcode = '22023', hint = 'RATE_LIMIT_HITS';
+  end if;
+  total := jsonb_array_length(hits);
+  for i in 1 .. total loop
+    hit := hits -> (i - 1);
+    if coalesce(hit ->> 'scope', '') = '' or (hit ->> 'key') is null then
+      raise exception 'Hit % of check_rate_limits needs a scope and a key', i - 1
+        using errcode = '22023', hint = 'RATE_LIMIT_HITS';
+    end if;
+    select * into rule from better_supabase.rate_limit_rules r where r.scope = hit ->> 'scope';
+    limit_max := coalesce((hit ->> 'max_requests')::integer, rule.max_requests);
+    limit_period := coalesce((hit ->> 'period')::interval, rule.period);
+    if limit_max is null or limit_period is null then
+      raise exception 'No rate limit for %: call set_rate_limit or pass max_requests and period', hit ->> 'scope'
+        using errcode = '22023', hint = 'RATE_LIMIT_UNKNOWN';
+    end if;
+    if limit_max < 1 or limit_period <= interval '0' then
+      raise exception 'The rate limit for % needs a positive max_requests and period', hit ->> 'scope'
+        using errcode = '22023', hint = 'RATE_LIMIT_HITS';
+    end if;
+    for j in 1 .. i - 1 loop
+      if scopes[j] = hit ->> 'scope' and keys[j] = hit ->> 'key' then
+        raise exception 'Hits % and % of check_rate_limits count the same scope % and key; give each limit its own scope', j - 1, i - 1, hit ->> 'scope'
+          using errcode = '22023', hint = 'RATE_LIMIT_HITS';
+      end if;
+    end loop;
+    scopes := scopes || (hit ->> 'scope');
+    keys := keys || (hit ->> 'key');
+    maxes := maxes || limit_max;
+    periods := periods || limit_period;
+  end loop;
+
+  insert into better_supabase.rate_limits as l (scope, key, window_start, hits, period)
+  select u.scope, u.key, now(), 0, u.period
+  from unnest(scopes, keys, periods) as u(scope, key, period)
+  order by u.scope, u.key
+  on conflict on constraint rate_limits_pkey do nothing;
+
+  perform 1
+  from better_supabase.rate_limits l
+  join unnest(scopes, keys) as u(scope, key) on l.scope = u.scope and l.key = u.key
+  order by l.scope, l.key
+  for update of l;
+
+  for i in 1 .. total loop
+    select * into counter from better_supabase.rate_limits l
+    where l.scope = scopes[i] and l.key = keys[i];
+    if counter.window_start + periods[i] <= now() then
+      used := used || 0;
+      starts := starts || now();
+    else
+      used := used || counter.hits;
+      starts := starts || counter.window_start;
+    end if;
+    if used[i] + 1 > maxes[i] then
+      longest := greatest(longest, greatest(1, ceil(extract(epoch from starts[i] + periods[i] - now()))::integer));
+      first_blocked := coalesce(first_blocked, i - 1);
+    end if;
+  end loop;
+
+  passed := first_blocked is null;
+
+  if passed then
+    for i in 1 .. total loop
+      update better_supabase.rate_limits l set
+        window_start = starts[i],
+        hits = used[i] + 1,
+        period = periods[i]
+      where l.scope = scopes[i] and l.key = keys[i];
+    end loop;
+  end if;
+
+  for i in 1 .. total loop
+    current_hits := used[i] + case when passed then 1 else 0 end;
+    results := results || jsonb_build_array(jsonb_build_object(
+      'allowed', used[i] + 1 <= maxes[i],
+      'remaining', greatest(maxes[i] - current_hits, 0),
+      'retry_after', case when used[i] + 1 <= maxes[i] then 0
+        else greatest(1, ceil(extract(epoch from starts[i] + periods[i] - now()))::integer) end
+    ));
+  end loop;
+
+  return jsonb_build_object(
+    'allowed', passed,
+    'blocked', first_blocked,
+    'retry_after', longest,
+    'results', results
+  );
+end
+$$;
+revoke execute on function better_supabase.check_rate_limits(jsonb) from public, anon, authenticated;
+grant execute on function better_supabase.check_rate_limits(jsonb) to service_role;
+
 -- Deletes up to batch counters whose window has ended: the period the
 -- counter was last hit with, else its rule's, else a day (counters from
 -- before the period column). Every caller keeps a row until then, so

package/dist/sqlite/index.d.ts

@@ -1,6 +1,6 @@
 import { Bt as Executor } from "../types-DFdg_4yN.js";
 import { c as LocalTablesOption, n as DataEngine, s as LiveEngineOptions } from "../data-engine-BWoz9lED.js";
-import { i as fromSqliteError, n as SqliteDatabaseLike, o as CheckSqliteOptions, r as SqliteExecutorOptions, s as checkSqlite, t as SqliteContextLike } from "../executor-CVIn6JHa.js";
+import { i as fromSqliteError, n as SqliteDatabaseLike, o as CheckSqliteOptions, r as SqliteExecutorOptions, s as checkSqlite, t as SqliteContextLike } from "../executor-BcNWcD-4.js";
 //#region src/sqlite/engine.d.ts
 /** A SQLite database that may report which tables changed. */
 interface ChangingSqliteDatabase extends SqliteDatabaseLike {

package/dist/ssr/index.d.ts

@@ -1,6 +1,6 @@
 import { C as readSession, D as writeSession, E as sessionEncoding, S as pruneSessionChunks, T as sessionCookieName, _ as StoredSession, a as ResolveAuthOptions, b as clearSessionAtScopes, d as CookieOptions, f as CookieRecord, g as SessionEncoding, h as DEFAULT_SESSION_ENCODING, l as resolveAuth, m as CookieWrite, n as AuthResolver, p as CookieScope, r as AuthState, t as AuthResolution, u as AUTH_CACHE_HEADERS, v as WriteSessionOptions, w as serializeCookie, x as parseCookies, y as applyCookieWrites } from "../resolve-CXX6DHv3.js";
 import { n as toSession, t as AuthSession } from "../view-DyFdMCqg.js";
-import { r as MembershipClaim } from "../entitlements-BnhDBxLW.js";
+import { r as MembershipClaim } from "../entitlements-sO977DO-.js";
 import { n as RefreshOutcome, r as refreshSession, t as RefreshOptions } from "../refresh-DT_ICaK-.js";
 import { a as sessionStatus, i as clearSessionCookies, n as SessionStatus, o as authContext, r as SessionStatusOptions, t as ClearSessionCookiesOptions } from "../ended-gUsMZVNg.js";
 export { AUTH_CACHE_HEADERS, type AuthResolution, type AuthResolver, type AuthSession, type AuthState, type ClearSessionCookiesOptions, type CookieOptions, type CookieRecord, type CookieScope, type CookieWrite, DEFAULT_SESSION_ENCODING, type MembershipClaim, type RefreshOptions, type RefreshOutcome, type ResolveAuthOptions, type SessionEncoding, type SessionStatus, type SessionStatusOptions, type StoredSession, type WriteSessionOptions, applyCookieWrites, authContext, clearSessionAtScopes, clearSessionCookies, parseCookies, pruneSessionChunks, readSession, refreshSession, resolveAuth, serializeCookie, sessionCookieName, sessionEncoding, sessionStatus, toSession, writeSession };

package/dist/storage/index.d.ts

@@ -1,4 +1,4 @@
 import { E as AccessPolicySql, T as AccessBucketPolicy, _t as BucketLifecycle, bt as VersioningStatus, vt as BucketLifecycleRule, yt as ObjectVersion } from "../types-DFdg_4yN.js";
-import { $ as TemplateValues, A as StorageBucketApi, B as StorageListV2Result, C as UploadOptions, D as TTL, E as parseSize, F as StorageFetchParameters, G as StorageSearchV2Options, H as StorageRemoveEntry, I as StorageFileOptions, J as StorageUrlOptions, K as StorageSignedUrlEntry, L as StorageListEntry, M as StorageDestinationOptions, N as StorageDownloadOptions, O as TtlPreset, P as StorageFailure, Q as TemplateParams, R as StorageListV2Folder, S as UploadBody, T as defineBucket, U as StorageResponse, V as StorageObjectInfo, W as StorageSearchOptions, X as StoragePath, Y as PathIn, Z as AppliedBucket, _ as StoredObject, a as BucketConnectOptions, b as TransferOptions, c as DownloadOptions, d as PathValues, f as PurgeCacheOptions, g as StorageAdminClient, h as Reservation, i as BucketConfig, j as StorageClient, k as StorageApi, l as ImageTransform, m as ReplaceResult, n as Bucket, o as BucketDrift, p as ReplaceOptions, q as StorageTransform, r as BucketClient, s as BucketPolicy, t as ActualBucket, u as ObjectTarget, v as SweepOptions, w as UrlOptions, x as TransformOptions, y as SweepResult, z as StorageListV2Object } from "../bucket-CiNi8sIw.js";
-import { A as StoredRef, C as AnyBucket, D as Buckets, E as BucketWithId, F as storageImageUrl, I as fromStorageError, M as StorageImageOptions, N as StorageImageSize, O as ConnectedRef, P as storageImageSrcSet, S as organizationLogoBucket, T as BucketMap, _ as IMAGE_TYPES, a as VectorHit, b as OrganizationLogoBucketOptions, c as VectorMetadata, d as defineVectorBucket, f as AnalyticsBucket, g as AvatarBucketOptions, h as defineAnalyticsBucket, i as VectorDistance, j as defineBuckets, k as ResolvedRef, l as VectorQueryOptions, m as AnalyticsCatalog, n as VectorBucketClient, o as VectorIndexClient, p as AnalyticsBucketClient, r as VectorBucketConfig, s as VectorIndexConfig, t as VectorBucket, u as VectorRecord, v as ImageBucketOptions, w as BucketIdOf, x as avatarBucket, y as ImageVariant } from "../index-Do2ChN_y.js";
-export { type AccessBucketPolicy, type AccessPolicySql, type ActualBucket, type AnalyticsBucket, type AnalyticsBucketClient, type AnalyticsCatalog, type AnyBucket, type AppliedBucket, type AvatarBucketOptions, type Bucket, type BucketClient, type BucketConfig, type BucketConnectOptions, type BucketDrift, type BucketIdOf, type BucketLifecycle, type BucketLifecycleRule, type BucketMap, type BucketPolicy, type BucketWithId, type Buckets, type ConnectedRef, type DownloadOptions, IMAGE_TYPES, type ImageBucketOptions, type ImageTransform, type ImageVariant, type ObjectTarget, type ObjectVersion, type OrganizationLogoBucketOptions, type PathIn, type PathValues, type PurgeCacheOptions, type ReplaceOptions, type ReplaceResult, type Reservation, type ResolvedRef, type StorageAdminClient, type StorageApi, type StorageBucketApi, type StorageClient, type StorageDestinationOptions, type StorageDownloadOptions, type StorageFailure, type StorageFetchParameters, type StorageFileOptions, type StorageImageOptions, type StorageImageSize, type StorageListEntry, type StorageListV2Folder, type StorageListV2Object, type StorageListV2Result, type StorageObjectInfo, type StoragePath, type StorageRemoveEntry, type StorageResponse, type StorageSearchOptions, type StorageSearchV2Options, type StorageSignedUrlEntry, type StorageTransform, type StorageUrlOptions, type StoredObject, type StoredRef, type SweepOptions, type SweepResult, TTL, type TemplateParams, type TemplateValues, type TransferOptions, type TransformOptions, type TtlPreset, type UploadBody, type UploadOptions, type UrlOptions, type VectorBucket, type VectorBucketClient, type VectorBucketConfig, type VectorDistance, type VectorHit, type VectorIndexClient, type VectorIndexConfig, type VectorMetadata, type VectorQueryOptions, type VectorRecord, type VersioningStatus, avatarBucket, defineAnalyticsBucket, defineBucket, defineBuckets, defineVectorBucket, fromStorageError, organizationLogoBucket, parseSize, storageImageSrcSet, storageImageUrl };
+import { $ as AppliedBucket, A as TtlPreset, B as StorageListV2Folder, C as TransformOptions, D as defineBucket, E as UrlOptions, F as StorageDownloadOptions, G as StorageResponse, H as StorageListV2Result, I as StorageFailure, J as StorageSignedUrlEntry, K as StorageSearchOptions, L as StorageFetchParameters, M as StorageBucketApi, N as StorageClient, O as parseSize, P as StorageDestinationOptions, Q as StoragePath, R as StorageFileOptions, S as TransferOptions, T as UploadOptions, U as StorageObjectInfo, V as StorageListV2Object, W as StorageRemoveEntry, X as StorageUrlOptions, Y as StorageTransform, Z as PathIn, _ as ResumableReservation, a as BucketConnectOptions, b as SweepOptions, c as DownloadOptions, d as PathValues, et as TemplateParams, f as PurgeCacheOptions, g as ReserveResumableOptions, h as Reservation, i as BucketConfig, j as StorageApi, k as TTL, l as ImageTransform, m as ReplaceResult, n as Bucket, o as BucketDrift, p as ReplaceOptions, q as StorageSearchV2Options, r as BucketClient, s as BucketPolicy, t as ActualBucket, tt as TemplateValues, u as ObjectTarget, v as StorageAdminClient, w as UploadBody, x as SweepResult, y as StoredObject, z as StorageListEntry } from "../bucket-vc-QRrva.js";
+import { A as ConnectedRef, C as avatarBucket, D as BucketMap, E as BucketIdOf, F as StorageImageSize, I as storageImageSrcSet, L as storageImageUrl, M as StoredRef, N as defineBuckets, O as BucketWithId, P as StorageImageOptions, R as fromStorageError, S as OrganizationLogoBucketOptions, T as AnyBucket, _ as defineAnalyticsBucket, a as VectorBucketConfig, b as ImageBucketOptions, c as VectorIndexClient, d as VectorQueryOptions, f as VectorRecord, g as AnalyticsCatalog, h as AnalyticsBucketClient, i as VectorBucketClient, j as ResolvedRef, k as Buckets, l as VectorIndexConfig, m as AnalyticsBucket, n as resumableEndpoint, o as VectorDistance, p as defineVectorBucket, r as VectorBucket, s as VectorHit, t as ResumableEndpointOptions, u as VectorMetadata, v as AvatarBucketOptions, w as organizationLogoBucket, x as ImageVariant, y as IMAGE_TYPES } from "../index-CQhPHHDF.js";
+export { type AccessBucketPolicy, type AccessPolicySql, type ActualBucket, type AnalyticsBucket, type AnalyticsBucketClient, type AnalyticsCatalog, type AnyBucket, type AppliedBucket, type AvatarBucketOptions, type Bucket, type BucketClient, type BucketConfig, type BucketConnectOptions, type BucketDrift, type BucketIdOf, type BucketLifecycle, type BucketLifecycleRule, type BucketMap, type BucketPolicy, type BucketWithId, type Buckets, type ConnectedRef, type DownloadOptions, IMAGE_TYPES, type ImageBucketOptions, type ImageTransform, type ImageVariant, type ObjectTarget, type ObjectVersion, type OrganizationLogoBucketOptions, type PathIn, type PathValues, type PurgeCacheOptions, type ReplaceOptions, type ReplaceResult, type Reservation, type ReserveResumableOptions, type ResolvedRef, type ResumableEndpointOptions, type ResumableReservation, type StorageAdminClient, type StorageApi, type StorageBucketApi, type StorageClient, type StorageDestinationOptions, type StorageDownloadOptions, type StorageFailure, type StorageFetchParameters, type StorageFileOptions, type StorageImageOptions, type StorageImageSize, type StorageListEntry, type StorageListV2Folder, type StorageListV2Object, type StorageListV2Result, type StorageObjectInfo, type StoragePath, type StorageRemoveEntry, type StorageResponse, type StorageSearchOptions, type StorageSearchV2Options, type StorageSignedUrlEntry, type StorageTransform, type StorageUrlOptions, type StoredObject, type StoredRef, type SweepOptions, type SweepResult, TTL, type TemplateParams, type TemplateValues, type TransferOptions, type TransformOptions, type TtlPreset, type UploadBody, type UploadOptions, type UrlOptions, type VectorBucket, type VectorBucketClient, type VectorBucketConfig, type VectorDistance, type VectorHit, type VectorIndexClient, type VectorIndexConfig, type VectorMetadata, type VectorQueryOptions, type VectorRecord, type VersioningStatus, avatarBucket, defineAnalyticsBucket, defineBucket, defineBuckets, defineVectorBucket, fromStorageError, organizationLogoBucket, parseSize, resumableEndpoint, storageImageSrcSet, storageImageUrl };

package/dist/storage/index.js

@@ -4,6 +4,7 @@ import { c as optionalTemporal, n as isInstant } from "../temporal-DLZlWbOi.js";
 import { n as temporalMissing } from "../temporal-required-Dy0GGD8E.js";
 import { a as ok, r as err, s as toDbError, t as AsyncResult } from "../result-ntFBW2p2.js";
 import { a as spansAllTenants } from "../plugin-AKwwe2gF.js";
+import { n as decodeJwtPayload } from "../base64-B9Wlsdj7.js";
 import { a as tenantClaimPaths, o as tenantFrom, s as tenantPathsFor } from "../claims-Bp9My7XP.js";
 import { a as sqlString, i as sqlIdent, n as parseTemplate, r as slug, t as claimSql } from "../template-Drgg3v2J.js";
 import { r as accessCheck } from "../access-sql-B-MkVARa.js";
@@ -281,6 +282,38 @@ function parseFailure(status, text) {
 	};
 }
 //#endregion
+//#region src/storage/resumable.ts
+/** Storage signs upload tokens for two hours. */
+const UPLOAD_TOKEN_SECONDS = 7200;
+const HOSTED = /^(?<ref>[a-z0-9-]+)\.supabase\.co$/i;
+const SIGNED_UPLOAD = "/object/upload/sign/";
+const STORAGE_PATH = "/storage/v1";
+/**
+* The TUS endpoint for a signed resumable upload,
+* `<storage>/upload/resumable/sign`. `url` is the project URL (`SUPABASE_URL`),
+* the Storage URL (`.../storage/v1`) or a signed upload URL from
+* `createSignedUploadUrl`.
+*/
+function resumableEndpoint(url, options = {}) {
+	const parsed = new URL(url);
+	const path = parsed.pathname;
+	const storage = path.indexOf(STORAGE_PATH);
+	const signed = path.indexOf(SIGNED_UPLOAD);
+	const base = storage === -1 ? signed === -1 ? `${path.replace(/\/+$/, "")}${STORAGE_PATH}` : path.slice(0, signed) : path.slice(0, storage + 11);
+	const hosted = HOSTED.exec(parsed.hostname);
+	if ((options.direct ?? true) && hosted?.groups?.["ref"] !== void 0) parsed.hostname = `${hosted.groups["ref"]}.storage.supabase.co`;
+	parsed.pathname = `${base}/upload/resumable/sign`;
+	parsed.search = "";
+	parsed.hash = "";
+	return parsed.toString();
+}
+/** When a signed upload token expires: its `exp`, else two hours from `now`. */
+function uploadTokenExpiry(token, now) {
+	const exp = decodeJwtPayload(token)?.["exp"];
+	const seconds = typeof exp === "number" && Number.isFinite(exp) ? exp : Math.floor(now / 1e3) + UPLOAD_TOKEN_SECONDS;
+	return (/* @__PURE__ */ new Date(seconds * 1e3)).toISOString();
+}
+//#endregion
 //#region src/storage/storage-api.ts
 /** The `StorageApi` of a client, or the client itself. */
 function storageApiOf(client) {
@@ -673,6 +706,26 @@ function connectBucket(bucket, client, resolveTarget, connectOptions, guard) {
 				signedUrl: data.signedUrl
 			}));
 		}),
+		reserveResumable: (target, options) => AsyncResult.from(async () => {
+			const path = resolve(target);
+			const upsert = options?.upsert ?? false;
+			return run(() => api().createSignedUploadUrl(path, upsert ? { upsert } : void 0)).map((data) => ({
+				path: data.path,
+				token: data.token,
+				signedUrl: data.signedUrl,
+				bucket: bucket.id,
+				tusEndpoint: resumableEndpoint(data.signedUrl, options?.direct === void 0 ? {} : { direct: options.direct }),
+				expiresAt: uploadTokenExpiry(data.token, options?.now?.() ?? Date.now()),
+				headers: {
+					"x-signature": data.token,
+					"x-upsert": upsert ? "true" : "false"
+				},
+				metadata: {
+					bucketName: bucket.id,
+					objectName: data.path
+				}
+			}));
+		}),
 		uploadReserved: (reservation, body, options) => AsyncResult.from(async () => {
 			options?.signal?.throwIfAborted();
 			const path = resolve(reservation.path);
@@ -1412,4 +1465,4 @@ function connectVectorBucket(config, client) {
 	};
 }
 //#endregion
-export { IMAGE_TYPES, TTL, avatarBucket, defineAnalyticsBucket, defineBucket, defineBuckets, defineVectorBucket, fromStorageError, organizationLogoBucket, parseSize, storageImageSrcSet, storageImageUrl };
+export { IMAGE_TYPES, TTL, avatarBucket, defineAnalyticsBucket, defineBucket, defineBuckets, defineVectorBucket, fromStorageError, organizationLogoBucket, parseSize, resumableEndpoint, storageImageSrcSet, storageImageUrl };

package/dist/support-B4ZBVxt3.d.ts

@@ -0,0 +1,357 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult } from "./result-DZeA5KS6.js";
+import { o as EventHub } from "./events-vcqenSYU.js";
+import { r as AuthState } from "./resolve-CXX6DHv3.js";
+import { a as ProblemFormat } from "./problem-DNwN8iGz.js";
+import { _ as SupportAuthorize, i as AuthorizationHooks } from "./authorization-hooks-D_pwXlBs.js";
+import { t as BetterPostgres } from "./pool-CrtT4dg-.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/auth/support.d.ts
+type SupportEndedBy = "admin" | "expired" | "revoked";
+/** A support session: a platform admin viewing the app as `targetUserId`. */
+interface SupportSession {
+  readonly id: string;
+  readonly adminId: string;
+  readonly targetUserId: string;
+  readonly reason: string;
+  /** Writes fail while it is true (`begin read only`). */
+  readonly readOnly: boolean;
+  readonly tenant?: string;
+  readonly startedAt: Temporal.Instant;
+  readonly expiresAt: Temporal.Instant;
+  readonly endedAt?: Temporal.Instant;
+  readonly endedBy?: SupportEndedBy;
+  /** App data, such as a ticket id. */
+  readonly metadata: Readonly<Record<string, unknown>>;
+}
+interface SupportStartInput {
+  readonly adminId: string;
+  /**
+   * The admin's verified claims. The SQL store runs `start_support_session`
+   * with them, so `is_platform()` checks the admin in the database too.
+   */
+  readonly adminClaims: Readonly<Record<string, unknown>>;
+  readonly targetUserId: string;
+  readonly reason: string;
+  readonly ttlSeconds: number;
+  readonly readOnly: boolean;
+  readonly tenant?: string;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  /** The approved request this start uses, when the server found one. */
+  readonly requestId?: string;
+}
+/**
+ * A request for a support session that waits for a second admin. A start uses
+ * an approved request once; `approvedBy` is never `adminId`.
+ */
+interface SupportRequest {
+  readonly id: string;
+  readonly adminId: string;
+  readonly targetUserId: string;
+  readonly reason: string;
+  readonly readOnly: boolean;
+  readonly tenant?: string;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  readonly requestedAt: Temporal.Instant;
+  /** An unapproved or unused request is closed after this. */
+  readonly expiresAt: Temporal.Instant;
+  readonly approvedBy?: string;
+  readonly approvedAt?: Temporal.Instant;
+  /** The session the approval started. */
+  readonly sessionId?: string;
+}
+interface SupportRequestInput {
+  readonly adminId: string;
+  /** The admin's verified claims; the SQL store asks as the admin with them. */
+  readonly adminClaims: Readonly<Record<string, unknown>>;
+  readonly targetUserId: string;
+  readonly reason: string;
+  readonly readOnly: boolean;
+  readonly tenant?: string;
+  readonly metadata: Readonly<Record<string, unknown>>;
+  /**
+   * An approver the server's authorization hook already decided, never the
+   * admin. The SQL store then records the request approved, over the admin
+   * connection.
+   */
+  readonly approvedBy?: string;
+}
+/**
+ * Who approves a request: with `claims` the store runs as them and decides
+ * eligibility itself.
+ */
+interface SupportApprover {
+  readonly id: string;
+  readonly claims?: SupportCallerClaims;
+}
+/** What `approvedRequest` looks up. */
+interface SupportApprovalQuery {
+  readonly adminId: string;
+  readonly targetUserId: string;
+  readonly tenant?: string;
+  readonly readOnly: boolean;
+}
+/** A caller's verified claims, which the store runs a call with. */
+type SupportCallerClaims = Readonly<Record<string, unknown>>;
+interface SupportListFilter {
+  readonly adminId?: string;
+  readonly targetUserId?: string;
+  /** `true`: running sessions only; `false`: ended or expired ones only. */
+  readonly active?: boolean;
+  /** Defaults to 50. */
+  readonly limit?: number;
+}
+/**
+ * Where support sessions live. `sqlSupportStore` uses the `impersonation` SQL
+ * module; implement this for another store and check it with
+ * `testSupportSessionStore` from `better-supabase/testing`.
+ */
+interface SupportSessionStore {
+  readonly apiVersion: 1;
+  readonly name: string;
+  /**
+   * Starts a session and ends the admin's previous one. Rejects when the store
+   * refuses.
+   */
+  start(input: SupportStartInput): Promise<SupportSession>;
+  /**
+   * The admin's session while it is running; `undefined` once ended or expired.
+   * With the admin's `claims`, the store also checks that the admin may still
+   * start sessions.
+   */
+  get(sessionId: string, adminId: string, claims?: SupportCallerClaims): Promise<SupportSession | undefined>;
+  /**
+   * `false` when it was not running. With `claims`, it runs as that caller: the
+   * session's admin, or staff with the revoke permission.
+   */
+  end(sessionId: string, endedBy: SupportEndedBy, claims?: SupportCallerClaims): Promise<boolean>;
+  /** With `claims`, only what that caller may view. */
+  list(filter?: SupportListFilter, claims?: SupportCallerClaims): Promise<readonly SupportSession[]>;
+  /** The claims `targetUserId` would get, when the store can build them. */
+  claims?(targetUserId: string): Promise<Readonly<Record<string, unknown>>>;
+  /**
+   * Ends every running session past its expiry with `endedBy: "expired"` and
+   * returns them. Optional; `support.expire()` fails without it.
+   */
+  expire?(): Promise<readonly SupportSession[]>;
+  /**
+   * The store with `namespace` for its time values, unless it was given one
+   * itself. Optional; `createServer` calls it with the definition's
+   * `temporal`.
+   */
+  withTemporal?(namespace: typeof Temporal): SupportSessionStore;
+  /**
+   * Records a request for a session that waits for a second admin. Optional;
+   * without it and the two methods below, starts that need an approval are
+   * refused.
+   */
+  request?(input: SupportRequestInput): Promise<SupportRequest>;
+  /** A request by id, or `undefined`. */
+  getRequest?(requestId: string): Promise<SupportRequest | undefined>;
+  /** Approves a request. Rejects when the approver is the requester. */
+  approve?(requestId: string, approver: SupportApprover): Promise<SupportRequest>;
+  /** The approved, unused, unexpired request a start would use, or `undefined`. */
+  approvedRequest?(query: SupportApprovalQuery): Promise<SupportRequest | undefined>;
+}
+interface SqlSupportStoreOptions {
+  /** `blocks.impersonation.schema`. Defaults to `better_supabase`. */
+  readonly schema?: string;
+  /**
+   * The Temporal namespace for the sessions' time values, for runtimes without
+   * a global one. Defaults to the one `createServer` passes from the
+   * definition, then the provided or global Temporal.
+   */
+  readonly temporal?: typeof Temporal;
+}
+/**
+ * Support sessions in the `impersonation` SQL module. `start` runs as the
+ * admin, so the module's `is_platform()` gate applies; the reads run on the
+ * admin connection.
+ */
+declare function sqlSupportStore(postgres: Pick<BetterPostgres, "admin" | "asUser">, options?: SqlSupportStoreOptions): SupportSessionStore;
+/**
+ * The claims a support session runs with: the target's, plus `act` naming the
+ * admin, the reason and the session (the audit module records all three),
+ * marked `kind: "support"` so `actorOf` never reads it as an OAuth client.
+ * `role` falls back to `authenticated`; the admin's claims never leak in.
+ */
+declare function supportClaims(session: Pick<SupportSession, "id" | "adminId" | "targetUserId" | "reason" | "readOnly">, target: Readonly<Record<string, unknown>>): Record<string, unknown>;
+//#endregion
+//#region src/auth/support-cookie.d.ts
+/** The cookie that carries the support session id. */
+declare const SUPPORT_COOKIE = "bsb-support";
+interface SupportCookieOptions {
+  /** Defaults to `bsb-support`. */
+  readonly name?: string;
+  /** Defaults to `/`. */
+  readonly path?: string;
+  /** Defaults to true; set false for plain-HTTP local development. */
+  readonly secure?: boolean;
+}
+/**
+ * `Set-Cookie` for a session: HttpOnly, SameSite=Lax, gone when the session
+ * expires.
+ */
+declare function supportCookie(session: Pick<SupportSession, "id" | "expiresAt">, options?: SupportCookieOptions, now?: number): string;
+/** `Set-Cookie` that removes the support cookie. */
+declare function clearSupportCookie(options?: SupportCookieOptions): string;
+/** The support session id in a `Cookie` header, or `undefined`. */
+declare function supportCookieValue(cookieHeader: string | null, name?: string): string | undefined;
+//#endregion
+//#region src/server/support.d.ts
+interface SupportPolicy {
+  /** Seconds a session lasts. Defaults to 1800 (30 minutes). */
+  readonly ttl?: number;
+  /** The longest `ttl` a start may ask for. Defaults to 14400 (4 hours). */
+  readonly maxTtl?: number;
+  /** Defaults to true. */
+  readonly requireReason?: boolean;
+  /**
+   * `always` (the default): every session is read-only. `default`: read-only
+   * unless the start passes `readOnly: false`.
+   */
+  readonly readOnly?: "always" | "default";
+  /**
+   * `distinct` (the default): a start needs a request that another admin
+   * approved (`support.request`, then `support.approve`), or an `authorize`
+   * decision of `{ approvedBy }` naming someone else. `none`: no second admin.
+   * Set `blocks.impersonation.options.approval` to the same value, because the
+   * SQL store checks it again.
+   */
+  readonly approval?: "distinct" | "none";
+}
+interface SupportOptions {
+  readonly store: SupportSessionStore;
+  /**
+   * Whether `admin` may view the app as the target. Without it, the
+   * authorization hooks' `support.authorize` decides, and without those every
+   * start is refused (`SUPPORT_FORBIDDEN`). A throw or rejection counts as a
+   * deny. `true` still needs a second admin under `policy.approval:
+   * 'distinct'`; `{ approvedBy }` names that admin.
+   *
+   * `'store'` hands the decision to the store alone: the SQL store checks
+   * `is_platform(blocks['impersonation'].permissions.start)` and nothing else,
+   * so use it only when that permission is the whole rule.
+   */
+  readonly authorize?: SupportAuthorize | "store";
+  /**
+   * The claims the target gets. Defaults to `store.claims` (the SQL store runs
+   * your custom access token hook), then `{ role: 'authenticated' }`.
+   */
+  readonly claims?: (targetUserId: string) => Readonly<Record<string, unknown>> | Promise<Readonly<Record<string, unknown>>>;
+  readonly policy?: SupportPolicy;
+  readonly cookie?: SupportCookieOptions;
+  /**
+   * Where a request names its support session, for apps that keep it in a
+   * header or their own request store instead of the `bsb-support` cookie.
+   * Defaults to reading the cookie.
+   */
+  readonly sessionId?: (request: Request) => string | undefined;
+}
+interface SupportStartRequest {
+  readonly targetUserId: string;
+  readonly reason?: string;
+  /** Seconds; defaults to `policy.ttl`. */
+  readonly ttl?: number;
+  /** Honoured only with `policy.readOnly: 'default'`. */
+  readonly readOnly?: boolean;
+  readonly tenant?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Options for `support.expireRoute`. */
+interface SupportExpireRouteOptions {
+  /** The bearer token the cron caller sends, such as `process.env.CRON_SECRET`. */
+  readonly secret: string | undefined;
+  /** Rewrites the Problem Details bodies of the route's errors. */
+  readonly problem?: ProblemFormat;
+}
+/** A running support session, as the request that carries its cookie sees it. */
+interface ActiveSupport {
+  readonly session: SupportSession;
+  /** The admin behind the session, from their own verified token. */
+  readonly admin: {
+    readonly id: string;
+    readonly email?: string;
+  };
+  /** The target's claims plus `act`, which repositories run with. */
+  readonly claims: Readonly<Record<string, unknown>>;
+}
+/** `bsb.support`: start, stop and inspect support sessions. */
+interface SupportApi {
+  /**
+   * Starts a session for a signed-in admin and returns it with the `Set-Cookie`
+   * value that switches the admin's next requests to the target.
+   */
+  start(admin: AuthState, request: SupportStartRequest): AsyncResult<{
+    readonly session: SupportSession;
+    readonly cookie: string;
+  }>;
+  /**
+   * Asks for a session that a second admin approves with `approve`; the policy
+   * checks of `start` apply. `ttl` is not stored: `start` passes it.
+   */
+  request(admin: AuthState, request: SupportStartRequest): AsyncResult<SupportRequest>;
+  /**
+   * Approves a request as `approver`, who is never the admin who asked. With
+   * the hooks' `approverOf`, it decides who may approve; otherwise the store
+   * does (the SQL store: the provider's `isApprover`, else the start
+   * permission).
+   */
+  approve(approver: AuthState, requestId: string): AsyncResult<SupportRequest>;
+  /**
+   * Ends the admin's own session and returns the `Set-Cookie` that clears the
+   * cookie.
+   */
+  stop(admin: AuthState, sessionId: string): AsyncResult<{
+    readonly ended: boolean;
+    readonly cookie: string;
+  }>;
+  /**
+   * Ends a session as `caller`: the SQL store allows the session's admin and
+   * staff with the revoke permission.
+   */
+  revoke(caller: AuthState, sessionId: string): AsyncResult<boolean>;
+  /** The running session the request names (`sessionIdOf`) for `auth`, if any. */
+  current(request: Request, auth: AuthState): Promise<ActiveSupport | undefined>;
+  /**
+   * The running session `sessionId` for the admin in `auth`, if any. Use it
+   * when the app keeps the session id in its own request context; pass the
+   * result to `contextFor(auth, { support })` or `dbFor(auth, context, {
+   * support })`.
+   */
+  resolve(sessionId: string, auth: AuthState): Promise<ActiveSupport | undefined>;
+  /** The sessions `caller` may view (the SQL store checks the view permission). */
+  list(caller: AuthState, filter?: SupportListFilter): AsyncResult<readonly SupportSession[]>;
+  /**
+   * Ends every session past its expiry through the store and emits
+   * `support.ended` with `endedBy: "expired"` for each; the SQL store runs over
+   * `postgres.admin`. Returns the sessions it ended.
+   */
+  expire(): AsyncResult<readonly SupportSession[]>;
+  /**
+   * A `GET` or `POST` handler for a cron caller that runs `expire()` and
+   * answers `{ expired }`, the number of sessions it ended.
+   */
+  expireRoute(options: SupportExpireRouteOptions): (request: Request) => Promise<Response>;
+  /** The support session id a request names: `options.sessionId`, or the cookie. */
+  sessionIdOf(request: Request): string | undefined;
+  /** `Set-Cookie` that clears the support cookie. */
+  clearCookie(): string;
+}
+/** `ServerOptions.support`, from `supportSessions(options)`. */
+interface SupportSessions {
+  readonly options: SupportOptions;
+  /**
+   * Builds `bsb.support`; `createServer` calls it once, with the definition's
+   * `temporal`, which goes on to the store's `withTemporal`, and the server's
+   * authorization hooks.
+   */
+  readonly create: (events: EventHub, claimsSchema: StandardSchemaV1 | undefined, temporal?: typeof Temporal, authorization?: AuthorizationHooks) => SupportApi;
+}
+/**
+ * Support sessions for `createServer(betterSupabase, { support })`. Apps that
+ * never import it don't bundle the support code.
+ */
+declare function supportSessions(options: SupportOptions): SupportSessions;
+//#endregion
+export { SupportSessionStore as C, supportClaims as E, SupportSession as S, sqlSupportStore as T, SupportCallerClaims as _, SupportPolicy as a, SupportRequest as b, supportSessions as c, clearSupportCookie as d, supportCookie as f, SupportApprover as g, SupportApprovalQuery as h, SupportOptions as i, SUPPORT_COOKIE as l, SqlSupportStoreOptions as m, SupportApi as n, SupportSessions as o, supportCookieValue as p, SupportExpireRouteOptions as r, SupportStartRequest as s, ActiveSupport as t, SupportCookieOptions as u, SupportEndedBy as v, SupportStartInput as w, SupportRequestInput as x, SupportListFilter as y };