better-supabase 0.13.0 → 0.14.0

package/dist/statuses-DMMDwXpZ.js

@@ -0,0 +1,29 @@
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/dispatch/options.ts
+const dispatchSqlOptions = blockOptions({
+	extraColumns: option.unknown(),
+	timeZone: option.string({
+		default: "UTC",
+		client: true
+	}),
+	defaultDuration: option.string({ default: "1 hour" })
+});
+//#endregion
+//#region src/blocks/dispatch/statuses.ts
+/** Where a work order is in its life. */
+const WORK_ORDER_STATUSES = [
+	"unscheduled",
+	"scheduled",
+	"en_route",
+	"on_site",
+	"done",
+	"cancelled"
+];
+const WORK_ORDER_PRIORITIES = [
+	"low",
+	"normal",
+	"high",
+	"urgent"
+];
+//#endregion
+export { WORK_ORDER_STATUSES as n, dispatchSqlOptions as r, WORK_ORDER_PRIORITIES as t };

package/dist/statuses-zRcc2TeZ.js

@@ -0,0 +1,28 @@
+//#region src/blocks/shipments/statuses.ts
+const LABEL_FORMATS = [
+	"pdf",
+	"png",
+	"zpl"
+];
+/** The stages a carrier reports, in the order a parcel goes through them. */
+const TRACKING_STATUSES = [
+	"label_created",
+	"in_transit",
+	"out_for_delivery",
+	"delivered",
+	"exception",
+	"returned"
+];
+/** Where a shipment is: a draft, then the status of its latest tracking event. */
+const SHIPMENT_STATUSES = [
+	"draft",
+	"label_created",
+	"in_transit",
+	"out_for_delivery",
+	"delivered",
+	"exception",
+	"returned",
+	"cancelled"
+];
+//#endregion
+export { SHIPMENT_STATUSES as n, TRACKING_STATUSES as r, LABEL_FORMATS as t };

package/dist/storage/index.d.ts

@@ -1,4 +1,4 @@
-import { J as BucketLifecycleRule, X as VersioningStatus, Y as ObjectVersion, n as AccessPolicySql, q as BucketLifecycle, t as AccessBucketPolicy } from "../types-DmshMaXz.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-DBay-ICp.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-CrAKHNJF.js";
+import { A as AccessPolicySql, Ct as ObjectVersion, St as BucketLifecycleRule, k as AccessBucketPolicy, wt as VersioningStatus, xt as BucketLifecycle } from "../executor-CPyrQdjh.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-TkB7_xv8.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-Yep7auV-.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 };

package/dist/storage/index.js

@@ -1,14 +1,14 @@
-import { t as DbException } from "../db-exception-CnWcYPxL.js";
-import { n as dbError } from "../errors-D7u24ZJH.js";
+import { t as DbException } from "../db-exception-Lngc1W49.js";
+import { n as dbError } from "../errors-03ysrOt4.js";
 import { c as optionalTemporal, n as isInstant } from "../temporal-DLZlWbOi.js";
-import { n as temporalMissing } from "../temporal-required-Dt4mcPsi.js";
-import { a as ok, r as err, s as toDbError, t as AsyncResult } from "../result-DIT_qp4G.js";
+import { n as temporalMissing } from "../temporal-required-B8qQHYbI.js";
+import { a as ok, r as err, s as toDbError, t as AsyncResult } from "../result-B3m7xtRY.js";
 import { a as spansAllTenants } from "../plugin-D9bYbYli.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-DXsGm_R0.js";
-import { r as accessCheck } from "../access-sql-BpOdJvfj.js";
-import { t as fromStorageError } from "../errors-Cq72lONT.js";
-import { a as ttlSeconds, i as TTL, r as transformFor, t as checkVariants } from "../variants-Bat9zU8l.js";
+import { a as sqlString, i as sqlIdent, n as parseTemplate, r as slug, t as claimSql } from "../template-BWP7IXZg.js";
+import { r as accessCheck } from "../access-sql-CPoq9F86.js";
+import { t as fromStorageError } from "../errors-DZx8w-MH.js";
+import { a as ttlSeconds, i as TTL, r as transformFor, t as checkVariants } from "../variants-DL7NpFJ7.js";
 import { i as storageImageUrl, r as storageImageSrcSet } from "../image-url-_d7xYsXK.js";
 //#region src/storage/versioning.ts
 const MAX_DAYS = 2147483647;

package/dist/store-o0HwYXl8.d.ts

@@ -0,0 +1,83 @@
+import { t as AsyncResult } from "./result-C6jDfedy.js";
+//#region src/streams/store.d.ts
+/** How a stream is opened. */
+interface StreamOpenOptions {
+  /** The user who may read the stream and cancel it. */
+  readonly owner?: string;
+  readonly tenant?: string;
+  /**
+   * What the stream carries, such as `chat` or `workflow`. Defaults to
+   * `default`.
+   */
+  readonly kind?: string;
+  /**
+   * Seconds the stream lives, or a Postgres interval such as `"2 hours"`.
+   * Defaults to one day.
+   */
+  readonly ttl?: number | string;
+}
+interface StreamAppendResult {
+  /** The index the next chunk gets. */
+  readonly next: number;
+  /** Someone asked the writer to stop. */
+  readonly cancelled: boolean;
+}
+interface StreamStatus {
+  /** The number of chunks stored. */
+  readonly next: number;
+  readonly closed: boolean;
+  readonly cancelled: boolean;
+}
+interface StreamReadOptions {
+  /** Ends the stream early. */
+  readonly signal?: AbortSignal;
+}
+interface StreamPurgeOptions {
+  /**
+   * How long a closed stream is kept: seconds or an interval. Defaults to one
+   * day.
+   */
+  readonly olderThan?: number | string;
+}
+/**
+ * Durable, resumable output: one writer appends ordered text chunks and any
+ * number of readers read from a chunk index, live or after a reconnect. Chunks
+ * keep the index they were appended at, so a reader that counted `n` chunks
+ * resumes with `read(id, n)`.
+ */
+interface StreamStore {
+  readonly apiVersion: 1;
+  readonly name: string;
+  /** Creates the stream; `true` when it was new, `false` when it existed. */
+  open(id: string, options?: StreamOpenOptions): AsyncResult<boolean>;
+  /**
+   * Stores `chunks` at `fromIdx`, `fromIdx + 1`, ... Indexes already stored are
+   * skipped, so a retried batch is harmless. Fails with the hint
+   * `STREAM_NOT_FOUND`, `STREAM_CLOSED` or `STREAM_GAP` (`fromIdx` past the
+   * end).
+   */
+  append(id: string, fromIdx: number, chunks: readonly string[]): AsyncResult<StreamAppendResult>;
+  /**
+   * The chunks from `fromIdx` on, waiting for new ones until the stream is
+   * closed. A stream that doesn't exist (or that the caller can't read) ends at
+   * once. A read error errors the stream with the `DbError`.
+   */
+  read(id: string, fromIdx?: number, options?: StreamReadOptions): ReadableStream<string>;
+  /** The stream's state, or `undefined` when it doesn't exist. */
+  status(id: string): AsyncResult<StreamStatus | undefined>;
+  isCancelled(id: string): AsyncResult<boolean>;
+  /**
+   * Marks the stream finished; `false` when it was closed already or doesn't
+   * exist.
+   */
+  close(id: string): AsyncResult<boolean>;
+  /** Asks the writer to stop; it learns on its next append. */
+  cancel(id: string): AsyncResult<boolean>;
+  /**
+   * Deletes expired streams and closed ones past `olderThan`; resolves with the
+   * count.
+   */
+  purge(options?: StreamPurgeOptions): AsyncResult<number>;
+}
+//#endregion
+export { StreamStatus as a, StreamReadOptions as i, StreamOpenOptions as n, StreamStore as o, StreamPurgeOptions as r, StreamAppendResult as t };

package/dist/streams/index.d.ts

@@ -1,6 +1,6 @@
-import { T as ErrorMapper, t as AsyncResult } from "../result-mijqfoJN.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../block-transport-DBPhgF3W.js";
-import { a as StreamStatus, i as StreamReadOptions, n as StreamOpenOptions, o as StreamStore, r as StreamPurgeOptions, t as StreamAppendResult } from "../store-DKqbuNvw.js";
+import { T as ErrorMapper, t as AsyncResult } from "../result-C6jDfedy.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../block-transport-d53POsem.js";
+import { a as StreamStatus, i as StreamReadOptions, n as StreamOpenOptions, o as StreamStore, r as StreamPurgeOptions, t as StreamAppendResult } from "../store-o0HwYXl8.js";
 import { SupabaseClient } from "@supabase/supabase-js";
 //#region src/streams/postgres.d.ts
 interface PostgresStreamStoreOptions {

package/dist/streams/index.js

@@ -1,7 +1,6 @@
 import { n as isRecord } from "../guards-6F2bCtQR.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../block-transport-Ds0C2mUf.js";
-import { D as recordOf, F as stringsOf, M as seconds, o as blockCall } from "../block-helpers-DwE32_gT.js";
-import { n as teeToStore, r as writeToStore, t as resumeFromStore } from "../tee-1fsH3bEz.js";
+import { B as dbTransport, D as recordOf, F as stringsOf, H as rpcTransport, M as seconds, U as sqlTransport, o as blockCall } from "../block-helpers-CiKtrb6g.js";
+import { n as teeToStore, r as writeToStore, t as resumeFromStore } from "../tee-DwkUvJD_.js";
 import { t as pollingRead } from "../store-McN-2esd.js";
 //#region src/streams/postgres.ts
 function statusOf(value) {

package/dist/streams/redis/index.d.ts

@@ -1,4 +1,4 @@
-import { o as StreamStore } from "../../store-DKqbuNvw.js";
+import { o as StreamStore } from "../../store-o0HwYXl8.js";
 //#region src/streams/redis/redis.d.ts
 /**
  * The commands the store sends, as node-redis 5 and 6 (`createClient()`) name

package/dist/streams/redis/index.js

@@ -1,5 +1,5 @@
-import { n as dbError } from "../../errors-D7u24ZJH.js";
-import { a as ok, r as err, t as AsyncResult } from "../../result-DIT_qp4G.js";
+import { n as dbError } from "../../errors-03ysrOt4.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-B3m7xtRY.js";
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
 import { t as importOptionalPeer } from "../../optional-peer-C1NbBRJm.js";
 import { t as pollingRead } from "../../store-McN-2esd.js";

package/dist/stripe/index.d.ts

@@ -1,4 +1,4 @@
-import { t as StripeClient } from "../stripe-BSEwKCni.js";
+import { t as StripeClient } from "../stripe-X22LjuH-.js";
 //#region src/stripe/stripe.d.ts
 /**
  * The secret key and, optionally, the API version of the Stripe client to

package/dist/stripe-X22LjuH-.d.ts

@@ -0,0 +1,156 @@
+//#region src/blocks/stripe.d.ts
+/**
+ * The part of the Stripe SDK (`stripe`, an optional peer) the billing and usage
+ * blocks call, typed structurally so the blocks never import it.
+ */
+interface StripeClient {
+  readonly customers: {
+    create(params: {
+      readonly email?: string;
+      readonly name?: string;
+      readonly metadata?: Readonly<Record<string, string>>;
+    }, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.updateCustomer`. */
+    update?(id: string, params: Readonly<Record<string, unknown>>): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.taxIds`. */
+    listTaxIds?(id: string, params?: {
+      readonly limit?: number;
+    }): Promise<{
+      readonly data: readonly StripeTaxId[];
+    }>;
+    /** Used by `billing.addTaxId`. */
+    createTaxId?(id: string, params: {
+      readonly type: string;
+      readonly value: string;
+    }): Promise<StripeTaxId>;
+    /** Used by `billing.removeTaxId`. */
+    deleteTaxId?(id: string, taxId: string): Promise<{
+      readonly id: string;
+      readonly deleted?: boolean;
+    }>;
+  };
+  readonly checkout: {
+    readonly sessions: {
+      create(params: Readonly<Record<string, unknown>>, options?: {
+        readonly idempotencyKey?: string;
+      }): Promise<{
+        readonly id: string;
+        readonly url: string | null;
+      }>;
+    };
+  };
+  readonly billingPortal: {
+    readonly sessions: {
+      create(params: {
+        readonly customer?: string;
+        readonly customer_account?: string;
+        readonly return_url?: string;
+      }): Promise<{
+        readonly id: string;
+        readonly url: string;
+      }>;
+    };
+  };
+  readonly subscriptionItems: {
+    update(id: string, params: {
+      readonly quantity: number;
+      readonly proration_behavior?: string;
+    }, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+      readonly quantity?: number | null;
+    }>;
+  };
+  readonly subscriptions: {
+    cancel(id: string): Promise<{
+      readonly id: string;
+    }>;
+    /** Used by `billing.changePlan` and `billing.cancelAtPeriodEnd`. */
+    update?(id: string, params: Readonly<Record<string, unknown>>, options?: {
+      readonly idempotencyKey?: string;
+    }): Promise<{
+      readonly id: string;
+    }>;
+  };
+  /** Used by `billing.voidInvoice` and `billing.markInvoiceUncollectible`. */
+  readonly invoices?: {
+    voidInvoice(id: string): Promise<{
+      readonly id: string;
+      readonly status?: string | null;
+    }>;
+    markUncollectible(id: string): Promise<{
+      readonly id: string;
+      readonly status?: string | null;
+    }>;
+  };
+  readonly billing: {
+    readonly meterEvents: {
+      create(params: {
+        readonly event_name: string;
+        readonly payload: Readonly<Record<string, string>>;
+        readonly identifier?: string;
+        readonly timestamp?: number;
+      }, options?: {
+        readonly idempotencyKey?: string;
+      }): Promise<unknown>;
+    };
+  };
+  /**
+   * Stripe's v2 API. `billing` with `customerAccounts` creates the tenant's
+   * Accounts v2 account through it.
+   */
+  readonly v2?: {
+    readonly core: {
+      readonly accounts: {
+        create(params: Readonly<Record<string, unknown>>, options?: {
+          readonly idempotencyKey?: string;
+        }): Promise<{
+          readonly id: string;
+        }>;
+      };
+    };
+  };
+  readonly webhooks: {
+    constructEventAsync(payload: string, header: string, secret: string): Promise<{
+      readonly id: string;
+      readonly type: string;
+      readonly data: {
+        readonly object: unknown;
+      };
+    }>;
+  };
+}
+/** A customer tax id as Stripe returns it (`eu_vat`, `DE123456789`). */
+interface StripeTaxId {
+  readonly id: string;
+  readonly type: string;
+  readonly value: string;
+  readonly country?: string | null;
+  readonly verification?: {
+    readonly status?: string | null;
+  } | null;
+  readonly created?: number | null;
+}
+/**
+ * A Stripe client, a function that returns a client (`stripeFromKey()` from
+ * `better-supabase/stripe` in a bundled app), or the secret key to create one
+ * from the `stripe` package: the plain Node shortcut, which needs a runtime
+ * that resolves `stripe` when the call runs. The function runs on every Stripe
+ * call, so it can create the client lazily, pick a per-request or per-tenant
+ * client (Stripe Connect), or read a rotated key; cache inside it when needed.
+ * `C` is the part of the SDK the caller uses (`StripeClient` for billing and
+ * usage).
+ */
+type StripeSource<C extends object = StripeClient> = C | {
+  readonly secretKey: string;
+  readonly apiVersion?: string;
+} | (() => C | Promise<C>);
+//#endregion
+export { StripeSource as n, StripeTaxId as r, StripeClient as t };

package/dist/subject-readers-CsTpx44c.js

@@ -0,0 +1,49 @@
+import "./block-helpers-CiKtrb6g.js";
+//#region src/core/subject-readers.ts
+/**
+* A registered subject's type and id, from `subjects/<type>/<id>` or
+* `<type>/<id>`.
+*/
+function parseSubject(subject, types) {
+	const rest = subject.startsWith("subjects/") ? subject.slice(9) : subject;
+	const slash = rest.indexOf("/");
+	if (slash <= 0 || slash === rest.length - 1) return;
+	const type = rest.slice(0, slash);
+	return types.has(type) ? {
+		type,
+		id: rest.slice(slash + 1)
+	} : void 0;
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* The default subscriber policy under an authorization provider: a subscriber
+* gets an event about a subject in `config.subjects` only when
+* `can_subject_for` says it may `read` the subject (the key in
+* `config.subjects.<type>.permissions`, never a share-link grant). Events
+* without a subject, or about a type the registry doesn't list, keep every
+* subscriber, so the block's own tenant check decides them. `transport` must
+* run as the service role.
+*/
+function subjectReaders(transport, options = {}) {
+	const schema = options.schema ?? "better_supabase";
+	const action = options.action ?? "read";
+	let types;
+	const registered = () => types ??= transport.call(schema, "subject_types", {}).then((value) => new Set(Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [])).catch((cause) => {
+		types = void 0;
+		throw cause;
+	});
+	return async (event, subscribers) => {
+		if (typeof event.subject !== "string" || subscribers.length === 0) return subscribers;
+		const subject = parseSubject(event.subject, await registered());
+		if (subject === void 0) return subscribers;
+		const allowed = await Promise.all(subscribers.map(async (subscriber) => UUID.test(subscriber.principal) ? await transport.call(schema, "can_subject_for", {
+			member: subscriber.principal,
+			subject_type: subject.type,
+			subject_id: subject.id,
+			action
+		}) === true : false));
+		return subscribers.filter((_, index) => allowed[index]);
+	};
+}
+//#endregion
+export { subjectReaders as t };

package/dist/subject-readers-DEZ45DQF.d.ts

@@ -0,0 +1,21 @@
+import { t as BlockTransport } from "./block-transport-d53POsem.js";
+import { g as SubscriberPolicy } from "./authorization-hooks-dLmUO_PZ.js";
+//#region src/core/subject-readers.d.ts
+interface SubjectReadersOptions {
+  /** The schema of the `subjects` module. Default `better_supabase`. */
+  readonly schema?: string;
+  /** The `config.subjects` action to check. Default `read`. */
+  readonly action?: string;
+}
+/**
+ * The default subscriber policy under an authorization provider: a subscriber
+ * gets an event about a subject in `config.subjects` only when
+ * `can_subject_for` says it may `read` the subject (the key in
+ * `config.subjects.<type>.permissions`, never a share-link grant). Events
+ * without a subject, or about a type the registry doesn't list, keep every
+ * subscriber, so the block's own tenant check decides them. `transport` must
+ * run as the service role.
+ */
+declare function subjectReaders(transport: BlockTransport, options?: SubjectReadersOptions): SubscriberPolicy;
+//#endregion
+export { subjectReaders as n, SubjectReadersOptions as t };

package/dist/subjects-B6p4oAZJ.d.ts

@@ -0,0 +1,78 @@
+//#region src/config/types/subjects.d.ts
+/**
+ * One entity the app's blocks attach to (`subjects.<type>`): a task, a
+ * customer, a document. Every subject-bound SQL module reads these entries
+ * unless its own `options.subjects` says otherwise. ADR 0020.
+ */
+interface SubjectConfig {
+  /** `schema.table`, or a table in `public`. */
+  readonly table: string;
+  /** The id column. Defaults to `id`. */
+  readonly id?: string;
+  /**
+   * The id column's type, such as `uuid` or `bigint`, so lookups compare on the
+   * primary key's own type. Without it the column is compared as text.
+   */
+  readonly idType?: string;
+  /**
+   * The tenant column. Defaults to `organization_id`, or
+   * `<blocks.tenant.entities.organization>_id` when the tenant is renamed.
+   * `false` for a subject without a tenant, which modules that keep a tenant on
+   * every row skip.
+   */
+  readonly tenant?: string | false;
+  /** The column `subject_title` returns. */
+  readonly title?: string;
+  /**
+   * The path `subject_url` returns, with `{column}` placeholders:
+   * `/tasks/{id}`.
+   */
+  readonly url?: string;
+  /**
+   * A permission key per action (`read`, `write`, or an app action) that
+   * `can_subject` checks in the subject's tenant, on top of the row being
+   * visible to the caller. `read` is also the permission modules check before
+   * they attach rows to the subject.
+   */
+  readonly permissions?: Readonly<Record<string, string>>;
+  /**
+   * A scope the authorization provider declares whose ids are this subject's
+   * ids, so a grant on the record counts as well as one on the tenant.
+   */
+  readonly scope?: string;
+  /** Delete module rows for a subject when its row is deleted. */
+  readonly cascade?: boolean;
+  /**
+   * The column holding the soft-delete time. Blocks hide rows where it is set,
+   * metrics skip them, and `gen` makes it the table's `softDelete()` column.
+   */
+  readonly deletedAt?: string;
+  /** The columns a search index reads. */
+  readonly search?: {
+    readonly title?: string;
+    readonly body?: readonly string[];
+  };
+  /**
+   * The text column holding the subject's rank key, and the column it is
+   * grouped by (a board stage), for `move()`. ADR 0021.
+   */
+  readonly rank?: {
+    readonly column: string;
+    readonly group?: string;
+  };
+  /**
+   * The columns the versions block snapshots and restores, and whether it
+   * snapshots on each change. An app table's `subject.versions` sets it.
+   */
+  readonly versions?: {
+    readonly columns: readonly string[];
+    readonly auto: boolean;
+  };
+}
+/**
+ * The app's subject types, keyed by type name (lowercase, digits and
+ * underscores).
+ */
+type SubjectsConfig = Readonly<Record<string, SubjectConfig>>;
+//#endregion
+export { SubjectsConfig as n, SubjectConfig as t };

package/dist/subjects-DXFmanh5.d.ts

@@ -0,0 +1,90 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult } from "./result-C6jDfedy.js";
+import { dt as SubjectRef } from "./executor-CPyrQdjh.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as BlockOptions } from "./block-helpers-BaugZlJV.js";
+import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
+//#region src/blocks/subjects/my-work-kinds.d.ts
+/** What a `my_work` item waits on. */
+type MyWorkKind = "assigned" | "approval" | "reminder" | "mention" | "sla";
+/** The kinds `my_work` returns, in the order the docs list them. */
+declare const MY_WORK_KINDS: readonly MyWorkKind[];
+//#endregion
+//#region src/blocks/subjects/subjects.d.ts
+/** The most refs one `subject_titles` call takes; `resolve` splits above it. */
+declare const SUBJECT_TITLES_LIMIT = 500;
+interface SubjectsOptions extends BlockOptions {
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: BlockHooks<Subjects>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+}
+/** A subject with its title and path, from `config.subjects`. */
+interface ResolvedSubject extends SubjectRef {
+  /** The `title` column's value, when the type names one. */
+  readonly title?: string;
+  /** The `url` template filled in, such as `/customers/42`. */
+  readonly url?: string;
+}
+/** A record page's header and tab badges, from `record_summary`. */
+interface RecordSummary extends ResolvedSubject {
+  /** Rows per section the caller can read, for each installed section asked. */
+  readonly counts: Readonly<Record<string, number>>;
+  /** Per section, whether a row is newer than `seenAt`. */
+  readonly unread: Readonly<Record<string, boolean>>;
+}
+interface RecordSummaryOptions {
+  /** When the caller last saw the record; every section is read without it. */
+  readonly seenAt?: Temporal.Instant | null;
+}
+/** One thing waiting on the caller, from `my_work`. */
+interface MyWorkItem {
+  readonly kind: MyWorkKind;
+  /** The record it is about: the work item, or the approval's subject. */
+  readonly subject: SubjectRef;
+  /**
+   * The row that put it here: the work item, approval request, reminder,
+   * comment or SLA clock id.
+   */
+  readonly ref: string;
+  readonly title?: string;
+  readonly url?: string;
+  /** The due date, or when it arrived. */
+  readonly at?: Temporal.Instant;
+}
+/** The most items one `my_work` call returns. */
+declare const MY_WORK_LIMIT = 200;
+interface MyWorkOptions {
+  /** Only this organization's work. Default: every organization. */
+  readonly tenant?: string;
+  /** At most this many items, newest first. Default 50, at most 200. */
+  readonly pageSize?: number;
+}
+/** The subjects block's registry as typed calls. */
+interface Subjects {
+  /**
+   * Titles and paths for many subjects in one call, keyed by `subjectKey`
+   * (`type:id`). A subject the caller can't read, a soft-deleted row or an
+   * unknown type is left out.
+   */
+  resolve(refs: readonly SubjectRef[]): AsyncResult<Readonly<Record<string, ResolvedSubject>>>;
+  /**
+   * The subject's title and path with a count and unread state for each of
+   * `sections` (`comments`, `attachments`), in one round trip; `undefined` when
+   * the caller can't read the subject.
+   */
+  summary(subject: SubjectRef, sections: readonly string[], options?: RecordSummaryOptions): AsyncResult<RecordSummary | undefined>;
+  /**
+   * What waits on the caller across the installed blocks, newest first: open
+   * work items assigned to them, approvals they can decide, their reminders
+   * sent this week, recent mentions and SLA clocks warned on their work.
+   */
+  myWork(options?: MyWorkOptions): AsyncResult<readonly MyWorkItem[]>;
+}
+/**
+ * The `subjects` module's `subject_titles` as a typed call, for lists and
+ * mentions that show a link to each subject.
+ */
+declare function createSubjects(options: SubjectsOptions): Subjects;
+//#endregion
+export { RecordSummaryOptions as a, Subjects as c, MY_WORK_KINDS as d, MyWorkKind as f, RecordSummary as i, SubjectsOptions as l, MyWorkItem as n, ResolvedSubject as o, MyWorkOptions as r, SUBJECT_TITLES_LIMIT as s, MY_WORK_LIMIT as t, createSubjects as u };