better-supabase 0.7.1 → 0.9.0

package/dist/client-DG7FwgZD.js

@@ -0,0 +1,104 @@
+import { t as temporal } from "./temporal-required-DqRzr7i0.js";
+import { t as defineController } from "./controller-D6NyNrlZ.js";
+import { t as sameRange } from "./range-DwpWe8e7.js";
+//#region src/blocks/bookings/event-calendar.ts
+/**
+* Bookings as event calendar events for a resource view (ReUI's Event
+* Calendar with `resources`, or a schedule): each booking sits on its
+* resource's row. Cancelled bookings are left out.
+*/
+function toEventCalendarBookings(bookings, options = {}) {
+	return bookings.flatMap((booking) => {
+		if (booking.status === "cancelled") return [];
+		const color = options.colorOf?.(booking);
+		return [{
+			id: booking.id,
+			title: options.titleOf?.(booking) ?? booking.customerName ?? "Booking",
+			start: new Date(booking.startsAt.epochMilliseconds),
+			end: new Date(booking.endsAt.epochMilliseconds),
+			resourceId: booking.resourceId,
+			...color === void 0 ? {} : { color },
+			...booking.status === "hold" ? { readOnly: true } : {},
+			data: booking
+		}];
+	});
+}
+/** Slots grouped by their local date (`YYYY-MM-DD`), in start order, for a day-by-day picker. */
+function slotsByDay(slots) {
+	const days = /* @__PURE__ */ new Map();
+	const sorted = slots.toSorted((a, b) => a.startsAt.epochMilliseconds - b.startsAt.epochMilliseconds);
+	for (const slot of sorted) {
+		const day = slot.localStart.toPlainDate().toString();
+		const list = days.get(day);
+		if (list === void 0) days.set(day, [slot]);
+		else list.push(slot);
+	}
+	return days;
+}
+//#endregion
+//#region src/blocks/bookings/client.ts
+const NO_DAYS = /* @__PURE__ */ new Map();
+/** The open slots of a service in the visible range, for a headless date and time picker. */
+function createAvailableSlotsController(options) {
+	const { client, serviceId, tz, resourceId, token } = options;
+	let range = options.range;
+	let ticket = 0;
+	return defineController({
+		slots: void 0,
+		days: NO_DAYS,
+		error: void 0,
+		loading: true
+	}, (state) => {
+		const refresh = async () => {
+			const request = ++ticket;
+			state.set({ loading: true });
+			const time = temporal();
+			const span = {
+				from: time.Instant.fromEpochMilliseconds(range.start.getTime()),
+				until: time.Instant.fromEpochMilliseconds(range.end.getTime())
+			};
+			const result = token === void 0 ? await client.availableSlots(serviceId, span, {
+				...tz === void 0 ? {} : { tz },
+				...resourceId === void 0 ? {} : { resourceId }
+			}) : await client.public.slots(token, span, tz === void 0 ? {} : { tz });
+			if (request !== ticket) return;
+			state.set(result.ok ? {
+				slots: result.data,
+				days: slotsByDay(result.data),
+				error: void 0,
+				loading: false
+			} : {
+				error: result.error,
+				loading: false
+			});
+		};
+		return {
+			actions: {
+				refresh,
+				setRange: (next) => {
+					if (sameRange(range, next)) return;
+					range = next;
+					refresh();
+				},
+				hold: async (slot, customer) => {
+					const result = token === void 0 ? await client.hold(serviceId, slot.resourceId, slot.startsAt, customer) : await client.public.hold(token, slot.resourceId, slot.startsAt, {
+						...customer,
+						name: customer?.name ?? "",
+						email: customer?.email ?? ""
+					});
+					if (!result.ok) {
+						state.set({ error: result.error });
+						return;
+					}
+					await refresh();
+					return result.data;
+				}
+			},
+			start: () => {
+				refresh();
+			}
+		};
+	});
+}
+//#endregion
+export { slotsByDay as n, toEventCalendarBookings as r, createAvailableSlotsController as t };

package/dist/client-DIrCmOXz.d.ts

@@ -0,0 +1,157 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult, w as ErrorMapper } from "./result-Cj3yWhjH.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "./standard-C3_AAF3g.js";
+import { t as BlockTransport } from "./block-transport-DaGGXjIw.js";
+import { n as BlockHooks } from "./block-hooks-BLPWD3Jt.js";
+import { r as FieldsOf } from "./block-fields-5UA84ZUg.js";
+import { n as Controller } from "./controller-D845qKh2.js";
+import { _ as AttendeeRole, d as OccurrenceOptions, f as OccurrenceRange, g as AttendeeResponse, l as CalendarEvent, n as EventCalendarOptions, t as EventCalendarEvent, u as CalendarOccurrence, y as CalendarEventStatus } from "./event-calendar-DJXXMJ3x.js";
+import { t as VisibleRange } from "./range-p5V4rBhZ.js";
+//#region src/blocks/calendar/calendar.d.ts
+interface CalendarOptions<S extends StandardSchemaV1 | undefined = undefined> {
+  /**
+   * A Standard Schema for the event columns the app adds
+   * (`blocks.calendar.options.extraColumns`), keyed by column name. It
+   * types and parses them on `events`, and validates them on `save` and
+   * the occurrence edits, which return a `validation` error for a bad
+   * value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Calendar<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly transport: BlockTransport;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+}
+interface CalendarInfo {
+  readonly id: string;
+  readonly name: string;
+  readonly tz: string;
+  readonly color?: string;
+  readonly ownerType?: string;
+  readonly ownerId?: string;
+}
+/** The fields of an event to write. Fields left out keep their value on update. */
+interface CalendarEventInput {
+  readonly title?: string;
+  readonly description?: string | null;
+  readonly location?: string | null;
+  readonly startsAt?: Temporal.Instant;
+  readonly endsAt?: Temporal.Instant;
+  readonly allDay?: boolean;
+  readonly tz?: string;
+  readonly status?: CalendarEventStatus;
+  /** An RFC 5545 `RRULE` value, or `null` to end the recurrence. */
+  readonly rrule?: string | null;
+  readonly exdates?: readonly Temporal.Instant[];
+  readonly subjectType?: string | null;
+  readonly subjectId?: string | null;
+  readonly color?: string | null;
+  /** Only on insert. Default the new id. */
+  readonly uid?: string;
+}
+interface SavedCalendarEvent {
+  readonly id: string;
+  readonly uid: string;
+  readonly created: boolean;
+}
+interface CalendarImport {
+  readonly created: number;
+  readonly updated: number;
+  /** Events without a UID or DTSTART, and overrides of an unknown series. */
+  readonly skipped: number;
+}
+/** `F` is the extra event fields `options.fields` describes. */
+interface Calendar<F extends object = Record<never, never>> {
+  createCalendar(organizationId: string, name: string, options?: {
+    readonly tz?: string;
+    readonly ownerType?: string;
+    readonly ownerId?: string;
+  }): AsyncResult<{
+    readonly id: string;
+  }>;
+  deleteCalendar(id: string): AsyncResult<boolean>;
+  listCalendars(organizationId: string): AsyncResult<CalendarInfo[]>;
+  /**
+   * Inserts an event, or updates the one with `id`. Keys besides the
+   * input's own are the event's extra columns.
+   */
+  save(calendarId: string, input: CalendarEventInput & Partial<F> & {
+    readonly id?: string;
+  }): AsyncResult<SavedCalendarEvent>;
+  delete(eventId: string): AsyncResult<boolean>;
+  /** The rows that can fall in the range: events, series and their overrides. */
+  events(calendarIds: readonly string[], range: OccurrenceRange): AsyncResult<(CalendarEvent & F)[]>;
+  /** The occurrences in the range, series expanded. */
+  occurrences(calendarIds: readonly string[], range: OccurrenceRange, options?: OccurrenceOptions): AsyncResult<CalendarOccurrence[]>;
+  /** Changes one occurrence: an override for a series, else the event. */
+  editOccurrence(occurrence: CalendarOccurrence, changes: CalendarEventInput & Partial<F>): AsyncResult<SavedCalendarEvent>;
+  /**
+   * Changes an occurrence and every later one: splits the series, unless the
+   * occurrence is its first. Pass `rrule` when the change moves the weekday.
+   */
+  editFollowing(occurrence: CalendarOccurrence, changes: CalendarEventInput & Partial<F>): AsyncResult<{
+    readonly id: string;
+  }>;
+  /** Removes one occurrence of a series (an `EXDATE`), or a single event. */
+  cancelOccurrence(occurrence: CalendarOccurrence): AsyncResult<boolean>;
+  setAttendee(eventId: string, attendee: {
+    readonly email: string;
+    readonly name?: string;
+    readonly userId?: string;
+    readonly role?: AttendeeRole;
+  }): AsyncResult<boolean>;
+  removeAttendee(eventId: string, email: string): AsyncResult<boolean>;
+  /** The signed-in user answers an invitation. */
+  respond(eventId: string, response: AttendeeResponse): AsyncResult<boolean>;
+  /** Upserts the events of an iCalendar file by UID. */
+  importIcs(calendarId: string, text: string): AsyncResult<CalendarImport>;
+  /** The calendar's events as an iCalendar file. */
+  exportIcs(calendar: CalendarInfo, range?: OccurrenceRange): AsyncResult<string>;
+  /**
+   * The iCalendar feed of a share link to a calendar (`subjectType:
+   * "calendar"`), or `null` when the token is unknown, revoked or expired.
+   */
+  feed(token: string): AsyncResult<string | null>;
+}
+/** A `list_calendar_events` or `calendar_feed` row as an event. */
+declare function calendarEventOf(value: unknown): CalendarEvent;
+declare function createCalendar<S extends StandardSchemaV1 | undefined = undefined>(options: CalendarOptions<S>): Calendar<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/calendar/client.d.ts
+interface CalendarControllerOptions extends EventCalendarOptions {
+  readonly client: Pick<Calendar, "occurrences" | "editOccurrence" | "editFollowing" | "cancelOccurrence">;
+  readonly calendarIds: readonly string[];
+  /** The visible range; `setRange` changes it. */
+  readonly range: VisibleRange;
+}
+interface CalendarSnapshot {
+  /** `undefined` until the first load. */
+  readonly occurrences: readonly CalendarOccurrence[] | undefined;
+  /** The occurrences as event calendar events (ReUI's `CalendarEvent` shape). */
+  readonly events: readonly EventCalendarEvent<CalendarOccurrence>[];
+  readonly error: DbError | undefined;
+  /** True until the occurrences of the current range arrive. */
+  readonly loading: boolean;
+}
+interface CalendarActions {
+  readonly refresh: () => Promise<void>;
+  /** Saves one occurrence's change, then loads the range again. */
+  readonly editOccurrence: (occurrence: CalendarOccurrence, changes: CalendarEventInput) => Promise<boolean>;
+  /** Saves the change for this and every later occurrence, then loads again. */
+  readonly editFollowing: (occurrence: CalendarOccurrence, changes: CalendarEventInput) => Promise<boolean>;
+  readonly cancelOccurrence: (occurrence: CalendarOccurrence) => Promise<boolean>;
+  /** Shows another range; the current occurrences stay until its own arrive. */
+  readonly setRange: (range: VisibleRange) => void;
+}
+type CalendarController = Controller<CalendarSnapshot, CalendarActions>;
+/**
+ * The occurrences of some calendars in the visible range, typed for a
+ * headless event calendar such as ReUI's Event Calendar.
+ */
+declare function createCalendarController(options: CalendarControllerOptions): CalendarController;
+//#endregion
+export { createCalendarController as a, CalendarImport as c, SavedCalendarEvent as d, calendarEventOf as f, CalendarSnapshot as i, CalendarInfo as l, CalendarController as n, Calendar as o, createCalendar as p, CalendarControllerOptions as r, CalendarEventInput as s, CalendarActions as t, CalendarOptions as u };

package/dist/client-DNq8xYb-.js

@@ -0,0 +1,52 @@
+import { n as whileSignedIn, t as defineController } from "./controller-D6NyNrlZ.js";
+//#region src/blocks/announcements/client.ts
+/**
+* The signed-in user's live announcements, loaded again whenever staff
+* publish, change or remove one.
+*/
+function createAnnouncementsController(options) {
+	const { client } = options;
+	const organizationId = options.organizationId ?? null;
+	const topic = options.topic === void 0 ? "announcements" : options.topic;
+	return defineController({
+		items: void 0,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			const run = state.run();
+			const result = await client.listActive(organizationId);
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				items: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		return {
+			actions: {
+				refresh,
+				dismiss: async (announcementId) => {
+					const result = await client.dismiss(announcementId);
+					if (!result.ok) {
+						state.set({ error: result.error });
+						return;
+					}
+					state.set((current) => ({ items: current.items?.filter((item) => item.id !== announcementId) }));
+				}
+			},
+			start: () => whileSignedIn(options.auth, () => {
+				refresh();
+				if (!topic) return;
+				return options.ports.topic(topic, {
+					onMessage: () => void refresh(),
+					onRejoin: () => void refresh(),
+					onStatus: (status) => {
+						state.set({ status });
+					}
+				}).leave;
+			})
+		};
+	});
+}
+//#endregion
+export { createAnnouncementsController as t };

package/dist/client-DdfSIZ3M.d.ts

@@ -0,0 +1,107 @@
+import { b as DbError } from "./result-Cj3yWhjH.js";
+import { O as AiShareLink, a as AiChatInput, c as AiChatPatch, d as AiChatShare, h as AiModel, i as AiChat, k as AiStoredMessage, l as AiChatQuery, u as AiChatRecord } from "./ai-chat-3GBSlFR4.js";
+import { p as SubscriptionStatus } from "./topic-cMS7UtM1.js";
+import { n as TopicPort } from "./watch-topic-EFpOIIDE.js";
+import { n as Controller, t as AuthPort } from "./controller-D845qKh2.js";
+//#region src/blocks/ai-chat/client.d.ts
+interface Ports {
+  readonly topic: TopicPort;
+}
+interface AiChatsControllerOptions {
+  readonly client: Pick<AiChat, "chats">;
+  readonly auth: AuthPort;
+  readonly ports: Ports;
+  /** The list's filters and page size. */
+  readonly query?: Omit<AiChatQuery, "cursor">;
+  /** The prefix of the list topic (`blockConfig["ai-chat"].options.listTopic` from `blocks.generated.ts`); `null` loads once. */
+  readonly topic?: string | null;
+}
+interface AiChatsSnapshot {
+  /** `undefined` until the first load. */
+  readonly items: readonly AiChatRecord[] | undefined;
+  /** Whether `loadMore` has another page. */
+  readonly hasMore: boolean;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+interface AiChatsActions {
+  readonly loadMore: () => Promise<void>;
+  readonly refresh: () => Promise<void>;
+  readonly create: (input?: AiChatInput) => Promise<AiChatRecord | undefined>;
+  readonly update: (chatId: string, patch: AiChatPatch) => Promise<AiChatRecord | undefined>;
+  readonly remove: (chatId: string) => Promise<void>;
+}
+type AiChatsController = Controller<AiChatsSnapshot, AiChatsActions>;
+/**
+ * The signed-in user's chats in a tenant, newest first, loaded again when
+ * any of their chats changes. Pages loaded with `loadMore` load again too.
+ */
+declare function createAiChatsController(options: AiChatsControllerOptions): AiChatsController;
+interface AiChatTreeControllerOptions {
+  readonly client: {
+    readonly messages: Pick<AiChat["messages"], "path" | "switchBranch" | "siblings">;
+  };
+  readonly ports: Ports;
+  /** `null` or `undefined` waits. */
+  readonly chatId: string | null | undefined;
+  /** The prefix of the chat topic (`blockConfig["ai-chat"].options.topic` from `blocks.generated.ts`); `null` loads once. */
+  readonly topic?: string | null;
+}
+interface AiChatTreeSnapshot {
+  /** The active branch, root first; `undefined` until the first load. */
+  readonly path: readonly AiStoredMessage[] | undefined;
+  readonly status: SubscriptionStatus;
+  readonly error: DbError | undefined;
+}
+interface AiChatTreeActions {
+  readonly refresh: () => Promise<void>;
+  /** Shows the branch through `messageId`. */
+  readonly switchBranch: (messageId: string) => Promise<void>;
+  /** Shows the sibling `offset` places from `messageId` (`-1` older, `1` newer). */
+  readonly step: (messageId: string, offset: number) => Promise<void>;
+}
+type AiChatTreeController = Controller<AiChatTreeSnapshot, AiChatTreeActions>;
+/**
+ * One chat's active branch, loaded again when a message is saved or the
+ * branch changes, in this tab or another.
+ */
+declare function createAiChatTreeController(options: AiChatTreeControllerOptions): AiChatTreeController;
+interface AiModelsControllerOptions {
+  readonly client: {
+    readonly models: Pick<AiChat["models"], "allowed">;
+  };
+  readonly organizationId?: string | null;
+}
+interface AiModelsSnapshot {
+  /** `undefined` until loaded. */
+  readonly models: readonly AiModel[] | undefined;
+  readonly error: DbError | undefined;
+}
+interface AiModelsActions {
+  readonly refresh: () => Promise<void>;
+}
+type AiModelsController = Controller<AiModelsSnapshot, AiModelsActions>;
+/** The models the tenant's plans allow, for a model picker. */
+declare function createAiModelsController(options: AiModelsControllerOptions): AiModelsController;
+interface AiShareControllerOptions {
+  readonly client: {
+    readonly shares: Pick<AiChat["shares"], "list" | "create" | "revoke">;
+  };
+  /** `null` or `undefined` waits. */
+  readonly chatId: string | null | undefined;
+}
+interface AiShareSnapshot {
+  /** The chat's share links, newest first; `undefined` until loaded. */
+  readonly shares: readonly AiChatShare[] | undefined;
+  readonly error: DbError | undefined;
+}
+interface AiShareActions {
+  /** Makes a link to the active branch, or to `leafId`; the token is in the result only. */
+  readonly create: (leafId?: string) => Promise<AiShareLink | undefined>;
+  readonly revoke: (shareId: string) => Promise<void>;
+}
+type AiShareController = Controller<AiShareSnapshot, AiShareActions>;
+/** Share links for one chat the user owns. */
+declare function createAiShareController(options: AiShareControllerOptions): AiShareController;
+//#endregion
+export { createAiChatTreeController as _, AiChatsActions as a, createAiShareController as b, AiChatsSnapshot as c, AiModelsControllerOptions as d, AiModelsSnapshot as f, AiShareSnapshot as g, AiShareControllerOptions as h, AiChatTreeSnapshot as i, AiModelsActions as l, AiShareController as m, AiChatTreeController as n, AiChatsController as o, AiShareActions as p, AiChatTreeControllerOptions as r, AiChatsControllerOptions as s, AiChatTreeActions as t, AiModelsController as u, createAiChatsController as v, createAiModelsController as y };

package/dist/client-DjTRlN3a.d.ts

@@ -0,0 +1,68 @@
+import { b as DbError, f as Result } from "./result-Cj3yWhjH.js";
+import { n as Controller, t as AuthPort } from "./controller-D845qKh2.js";
+//#region src/blocks/billing/client.d.ts
+/** A plan the picker lists: a key from the app's plan catalog, plus whatever the app shows. */
+interface PlanOption {
+  readonly key: string;
+  readonly name: string;
+}
+/** The plans to offer and the tenant's current plan. */
+interface PlanCatalog<P> {
+  readonly plans: readonly P[];
+  /** The key of the tenant's current plan, `undefined` without a subscription. */
+  readonly current: string | undefined;
+}
+/** Where Checkout continues: Stripe's hosted page, or `undefined` when the server finished the change itself. */
+interface CheckoutStarted {
+  readonly url: string | undefined;
+}
+interface PlanPickerControllerOptions<P extends {
+  readonly key: string;
+} = PlanOption> {
+  readonly auth: AuthPort;
+  /**
+   * The plans and the current one, such as a server action that reads the
+   * app's plan catalog and the tenant's subscription. It throws on failure.
+   */
+  readonly load: () => Promise<PlanCatalog<P>>;
+  /** What a server already loaded: the first load is skipped. */
+  readonly initial?: PlanCatalog<P>;
+  /**
+   * Starts Checkout for a plan key on the server, such as a server action
+   * that calls `billing.checkout()`. The controller never talks to Stripe:
+   * the secret key stays on the server.
+   */
+  readonly checkout: (plan: string) => Promise<Result<CheckoutStarted>>;
+  /**
+   * Opens the Checkout URL: `location.assign(url)` on the web,
+   * `WebBrowser.openBrowserAsync(url)` from `expo-web-browser` in React Native.
+   */
+  readonly open: (url: string) => void | Promise<void>;
+}
+interface PlanPickerSnapshot<P> {
+  /** `undefined` until the first load. */
+  readonly plans: readonly P[] | undefined;
+  readonly current: string | undefined;
+  /** The plan whose Checkout is starting. */
+  readonly pending: string | undefined;
+  readonly error: DbError | undefined;
+}
+interface PlanPickerActions {
+  /**
+   * Starts Checkout for `plan` and opens its URL; a failure is also kept in
+   * `error`. Choosing the current plan does nothing.
+   */
+  readonly choose: (plan: string) => Promise<Result<CheckoutStarted>>;
+  readonly refresh: () => Promise<void>;
+}
+type PlanPickerController<P> = Controller<PlanPickerSnapshot<P>, PlanPickerActions>;
+/**
+ * The plans with the tenant's current one, for a plan picker: `choose`
+ * starts Checkout through the injected server action and opens the URL it
+ * returns.
+ */
+declare function createPlanPickerController<P extends {
+  readonly key: string;
+} = PlanOption>(options: PlanPickerControllerOptions<P>): PlanPickerController<P>;
+//#endregion
+export { PlanPickerController as a, createPlanPickerController as c, PlanPickerActions as i, PlanCatalog as n, PlanPickerControllerOptions as o, PlanOption as r, PlanPickerSnapshot as s, CheckoutStarted as t };

package/dist/client-Ezlbskjq.js

@@ -0,0 +1,60 @@
+import { t as defineController } from "./controller-D6NyNrlZ.js";
+import { t as tenantOf } from "./tenant-B-fiItlJ.js";
+//#region src/auth/entitlements.ts
+/**
+* Whether the session's plan-features claim grants `key` in `tenantId`.
+* `claim` is `config.claims.features` (default `features`), the claim
+* `better_supabase.feature_claims()` fills, or `{ claim, keys }` when
+* `entitlements.claim.keys` writes short codes. The claim is as fresh as the
+* token: enforce it in RLS with `better_supabase.has_entitlement()`, and
+* refresh the session after checkout. A tenant left out by
+* `entitlements.claim.maxTenants` reads as not granted. Takes a server
+* session or the client's `useAuth()` snapshot.
+*/
+function hasEntitlement(session, tenantId, key, claim = "features") {
+	const options = typeof claim === "string" ? { claim } : claim;
+	const claims = "kind" in session ? session.kind === "user" ? session.claims : void 0 : session.claims;
+	if (!isRecord(claims)) return false;
+	const features = claims[options.claim ?? "features"];
+	if (!isRecord(features) || !Object.hasOwn(features, tenantId)) return false;
+	const keys = features[tenantId];
+	const code = options.keys?.[key] ?? key;
+	return Array.isArray(keys) && keys.includes(code);
+}
+const isRecord = (value) => typeof value === "object" && value !== null;
+//#endregion
+//#region src/blocks/entitlements/client.ts
+/**
+* Whether the active organization's plan includes `feature`, from the
+* session's plan-features claim. It updates when the session does, so a
+* session refresh after checkout opens the gate. UX only: enforce the
+* feature in RLS with `better_supabase.has_entitlement()`.
+*/
+function createFeatureGateController(options) {
+	const read = () => {
+		const session = options.auth.current();
+		if (session.status === "loading") return {
+			allowed: void 0,
+			organizationId: void 0
+		};
+		const organizationId = options.organizationId ?? tenantOf(session, options.tenantClaim);
+		return {
+			allowed: organizationId === void 0 ? false : hasEntitlement(session, organizationId, options.feature, options.claim),
+			organizationId
+		};
+	};
+	return defineController(read(), (state) => {
+		const recheck = () => {
+			state.set(read());
+		};
+		return {
+			actions: { recheck },
+			start: () => {
+				recheck();
+				return options.auth.subscribe(recheck);
+			}
+		};
+	});
+}
+//#endregion
+export { hasEntitlement as n, createFeatureGateController as t };