better-supabase 0.12.0 → 0.14.0

package/dist/expo/index.d.ts

@@ -1,38 +1,48 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-BrpW5ixT.js";
-import { t as BetterSupabase } from "../define-DYZnvAbs.js";
-import { a as ServerContext, c as ServerOptions, n as BetterServer, r as ContextOptions } from "../server-types-fLdep4gb.js";
-import { i as MiddlewareOptions, r as GuardOptions } from "../respond-BSL36dQp.js";
-import { t as Validated } from "../shared-DDSjEGDR.js";
+import { M as AnyFunctions, N as AnyModels } from "../executor-CPyrQdjh.js";
+import { t as BetterSupabase } from "../define-Dw7pRO4h.js";
+import { a as ServerContext, c as ServerOptions, n as BetterServer, r as ContextOptions } from "../server-types-BOs-eFpo.js";
+import { i as MiddlewareOptions, r as GuardOptions } from "../respond-CZYibxUx.js";
+import { t as Validated } from "../shared-CRRfQAKG.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { ImmutableRequest, MiddlewareFunction } from "expo-server";
 //#region src/bridges/expo.d.ts
 /** Route parameters from the file name (`[id]`, `[...slug]`). */
 type ExpoParams = Record<string, string | string[]>;
 interface ToExpoOptions {
-  /** The host's env object for `getEnv`, read per request (EAS Hosting runs on Workers). */
+  /**
+   * The host's env object for `getEnv`, read per request (EAS Hosting runs on
+   * Workers).
+   */
   readonly env?: (request: Request) => unknown;
 }
 /**
- * Runs an entry array around an Expo Router API route handler
- * (`export const GET = toExpo([...], handler)`). Short-circuit responses
- * (a 401 from the guard, a CORS preflight) answer before the handler runs,
- * and the handler's response passes back through the entries.
+ * Runs an entry array around an Expo Router API route handler (`export const
+ * GET = toExpo([...], handler)`). Short-circuit responses (a 401 from the
+ * guard, a CORS preflight) answer before the handler runs, and the handler's
+ * response passes back through the entries.
  */
 export declare function toExpo<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, handler: (request: Request, ctx: Contributions<Entries>, params: ExpoParams) => Response | Promise<Response>, options?: ToExpoOptions): (request: Request, params?: ExpoParams) => Promise<Response>;
 //#endregion
 //#region src/expo/index.d.ts
-/** A request as Expo Router passes it: `ImmutableRequest` in loaders and middleware, `Request` in API routes. */
+/**
+ * A request as Expo Router passes it: `ImmutableRequest` in loaders and
+ * middleware, `Request` in API routes.
+ */
 export type ExpoRequest = Request | ImmutableRequest;
 export interface ExpoOptions extends ServerOptions {
-  /** Include error details in problem responses. Defaults to `NODE_ENV === 'development'`. */
+  /**
+   * Include error details in problem responses. Defaults to `NODE_ENV ===
+   * 'development'`.
+   */
   readonly exposeErrors?: boolean;
 }
 export interface ExpoContextOptions extends Omit<ContextOptions, "refresh">, GuardOptions {
   /**
    * Refresh an expired cookie session and write the new cookies with
-   * `setResponseHeaders`. Defaults to true; bearer tokens never refresh.
-   * When `bs.middleware()` already ran for the request, the context reads the
-   * session it refreshed and never calls Auth again, whatever this option says.
+   * `setResponseHeaders`. Defaults to true; bearer tokens never refresh. When
+   * `bs.middleware()` already ran for the request, the context reads the
+   * session it refreshed and never calls Auth again, whatever this option
+   * says.
    */
   readonly refresh?: boolean;
 }
@@ -44,24 +54,24 @@ export interface ExpoMiddlewareOptions extends MiddlewareOptions {
   readonly redirectTo?: string;
   /**
    * Paths every caller may open, such as `/` or `/pricing`. An entry matches
-   * the path itself and everything under it (`/auth` matches
-   * `/auth/callback`). The `redirectTo` path and everything under it are
-   * always public, so its callback routes never loop back to it.
+   * the path itself and everything under it (`/auth` matches `/auth/callback`).
+   * The `redirectTo` path and everything under it are always public, so its
+   * callback routes never loop back to it.
    */
   readonly publicPaths?: readonly string[];
 }
 export interface BetterExpo<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> extends BetterServer<M, F, E, C, P, B> {
   /**
-   * The verified caller for a server loader, API route or middleware: a
-   * bearer token first, the session cookie second. Refreshed session
-   * cookies go out through `setResponseHeaders`. With `allow`, a refused
-   * caller throws a `StatusError` (401 or 403) that Expo Router answers.
+   * The verified caller for a server loader, API route or middleware: a bearer
+   * token first, the session cookie second. Refreshed session cookies go out
+   * through `setResponseHeaders`. With `allow`, a refused caller throws a
+   * `StatusError` (401 or 403) that Expo Router answers.
    */
   request(request: ExpoRequest, options?: ExpoContextOptions): Promise<ServerContext<M, F, E, C, P, B>>;
   /**
-   * A server loader (`export const loader = bs.loader(...)`) that runs `fn`
-   * as the caller. A `DbException` from `.orThrow()` becomes a `StatusError`
-   * with the error's status. Throws during static rendering, which has no request.
+   * A server loader (`export const loader = bs.loader(...)`) that runs `fn` as
+   * the caller. A `DbException` from `.orThrow()` becomes a `StatusError` with
+   * the error's status. Throws during static rendering, which has no request.
    */
   loader<T>(fn: (ctx: ServerContext<M, F, E, C, P, B>, params: ExpoParams, request: ImmutableRequest) => Promise<T> | T, options?: ExpoContextOptions): (request: ImmutableRequest | undefined, params: ExpoParams) => Promise<T>;
   /**
@@ -71,7 +81,8 @@ export interface BetterExpo<M extends AnyModels, F extends AnyFunctions, E, C =
   handler(fn: (request: Request, ctx: ServerContext<M, F, E, C, P, B>, params: ExpoParams) => unknown, options?: MiddlewareOptions): (request: Request, params?: ExpoParams) => Promise<Response>;
   /**
    * `+middleware.ts`: refreshes an expired cookie session once per request,
-   * before loaders run, and redirects refused callers when `redirectTo` is set.
+   * before loaders run, and redirects refused callers when `redirectTo` is
+   * set.
    */
   middleware(options?: ExpoMiddlewareOptions): MiddlewareFunction;
 }

package/dist/expo/index.js

@@ -1,19 +1,19 @@
-import { t as DbException } from "../db-exception-CnWcYPxL.js";
-import { c as toProblem } from "../problem-JRCohp1j.js";
-import { a as unexpectedResponse, c as extendServer, s as createServer, x as refreshFor } from "../adapter-CRNH2aX_.js";
-import { m as serializeCookie } from "../resolve-AtncaPTU.js";
-import { a as respond, r as guard, t as defaultExpose } from "../respond-Bhp3G__q.js";
-import { t as withBetterSupabase } from "../composite-1kPAxXto.js";
-import { r as handoffOf } from "../shared-BmMcMoW9.js";
+import { t as DbException } from "../db-exception-Lngc1W49.js";
+import { c as toProblem } from "../problem-BWElIgIb.js";
+import { a as unexpectedResponse, c as extendServer, s as createServer, x as refreshFor } from "../adapter-BCFAg58A.js";
+import { m as serializeCookie } from "../resolve-DAYdcs22.js";
+import { a as respond, r as guard, t as defaultExpose } from "../respond-z_yfyitp.js";
+import { t as withBetterSupabase } from "../composite-Dv6o2BSw.js";
+import { r as handoffOf } from "../shared-Bf-I13Ht.js";
 import { bufferRequest, pipeline, seedContext } from "@supabase/middleware";
 import { StatusError, setResponseHeaders } from "expo-server";
 //#region src/bridges/expo.ts
 const PARAMS = Symbol("toExpo.params");
 /**
-* Runs an entry array around an Expo Router API route handler
-* (`export const GET = toExpo([...], handler)`). Short-circuit responses
-* (a 401 from the guard, a CORS preflight) answer before the handler runs,
-* and the handler's response passes back through the entries.
+* Runs an entry array around an Expo Router API route handler (`export const
+* GET = toExpo([...], handler)`). Short-circuit responses (a 401 from the
+* guard, a CORS preflight) answer before the handler runs, and the handler's
+* response passes back through the entries.
 */
 function toExpo(entries, handler, options = {}) {
 	const run = pipeline(entries, (request, ctx) => Promise.resolve(handler(request, ctx, handoffOf(ctx, PARAMS))));
@@ -29,7 +29,10 @@ function under(path, prefix) {
 	const base = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
 	return base === "" ? path === "/" : path === base || path.startsWith(`${base}/`);
 }
-/** `ImmutableRequest` has no body and immutable headers; the resolver only reads URL, method and headers. */
+/**
+* `ImmutableRequest` has no body and immutable headers; the resolver only reads
+* URL, method and headers.
+*/
 function toRequest(request) {
 	if (request instanceof Request) return request;
 	return new Request(request.url, {
@@ -38,9 +41,9 @@ function toRequest(request) {
 	});
 }
 /**
-* expo-server wraps the incoming request in a new `ImmutableRequest` for the
-* middleware and for each loader, so a handoff can't key on the object. The
-* old cookie header pins it to one session: another request with the same key
+* Expo-server wraps the incoming request in a new `ImmutableRequest` for the
+* middleware and for each loader, so a handoff can't key on the object. The old
+* cookie header pins it to one session: another request with the same key
 * carries the same cookies and would refresh to the same session.
 */
 const HANDOFF_TTL_MS = 1e4;

package/dist/expo-sqlite/index.d.ts

@@ -1,6 +1,6 @@
-import { r as Executor } from "../executor-BnMC0lj3.js";
-import { n as PowerSyncExecutorOptions, t as PowerSyncDatabaseLike } from "../executor-CvsNcQsa.js";
-import { a as checkSqlite, n as sqliteTables, r as watch, t as WatchOptions } from "../watch-5btote1y.js";
+import { r as Executor } from "../executor-CPyrQdjh.js";
+import { n as PowerSyncExecutorOptions, t as PowerSyncDatabaseLike } from "../executor-BElVQpaB.js";
+import { a as checkSqlite, n as sqliteTables, r as watch, t as WatchOptions } from "../watch-DziJudwj.js";
 //#region src/expo-sqlite/executor.d.ts
 /** What an expo-sqlite database or exclusive transaction can run. */
 interface ExpoSqliteContextLike {
@@ -8,8 +8,8 @@ interface ExpoSqliteContextLike {
   runAsync(source: string, params: unknown[]): Promise<unknown>;
 }
 /**
- * The part of expo-sqlite's `SQLiteDatabase` the executor uses. Typed by
- * shape, so better-supabase doesn't depend on expo-sqlite.
+ * The part of expo-sqlite's `SQLiteDatabase` the executor uses. Typed by shape,
+ * so better-supabase doesn't depend on expo-sqlite.
  */
 interface ExpoSqliteDatabaseLike extends ExpoSqliteContextLike {
   /** Filters change events to this database when several are open. */
@@ -24,8 +24,8 @@ interface DatabaseChangeEventLike {
   readonly databaseFilePath?: string;
 }
 /**
- * expo-sqlite's `addDatabaseChangeListener`. Open the database with
- * `{ enableChangeListener: true }` so it reports changes.
+ * Expo-sqlite's `addDatabaseChangeListener`. Open the database with `{
+ * enableChangeListener: true }` so it reports changes.
  */
 type AddDatabaseChangeListener = (listener: (event: DatabaseChangeEventLike) => void) => {
   remove(): void;
@@ -36,21 +36,24 @@ interface ExpoSqliteOptions extends PowerSyncExecutorOptions {
 }
 /**
  * An expo-sqlite database in the shape the SQLite executor, `watch()` and
- * `useWatch()` read. Writes run in `withExclusiveTransactionAsync` on
- * native and `withTransactionAsync` on web.
+ * `useWatch()` read. Writes run in `withExclusiveTransactionAsync` on native
+ * and `withTransactionAsync` on web.
  */
 export declare function expoSqliteDatabase(db: ExpoSqliteDatabaseLike, options?: Pick<ExpoSqliteOptions, "addDatabaseChangeListener">): PowerSyncDatabaseLike;
 /**
- * Runs repository operations on an expo-sqlite database, without PowerSync:
- * the same repositories and list definitions work on a local database the
- * app owns. Reads return rows in the PostgREST shape; what SQLite can't
- * express returns a `DbError` of kind `unsupported`. An insert that leaves
- * out a text or uuid key gets `crypto.randomUUID()`, else a UUID from
- * SQLite.
+ * Runs repository operations on an expo-sqlite database, without PowerSync: the
+ * same repositories and list definitions work on a local database the app owns.
+ * Reads return rows in the PostgREST shape; what SQLite can't express returns a
+ * `DbError` of kind `unsupported`. An insert that leaves out a text or uuid key
+ * gets `crypto.randomUUID()`, else a UUID from SQLite.
  *
  * ```ts
- * const sqlite = await openDatabaseAsync("app.db", { enableChangeListener: true });
- * const db = betterSupabase.connect(expoSqliteExecutor(sqlite, { addDatabaseChangeListener }));
+ * const sqlite = await openDatabaseAsync("app.db", {
+ *   enableChangeListener: true,
+ * });
+ * const db = betterSupabase.connect(
+ *   expoSqliteExecutor(sqlite, { addDatabaseChangeListener }),
+ * );
  * ```
  */
 export declare function expoSqliteExecutor(db: ExpoSqliteDatabaseLike, options?: ExpoSqliteOptions): Executor;

package/dist/expo-sqlite/index.js

@@ -1,8 +1,11 @@
-import { n as watch, t as sqliteTables } from "../watch-BAuIzC2r.js";
-import { i as checkSqlite, t as powersyncExecutor } from "../executor-BiB0wMBA.js";
+import { n as watch, t as sqliteTables } from "../watch-CfMT6vX7.js";
+import { i as checkSqlite, t as powersyncExecutor } from "../executor-o9HkOJ0m.js";
 //#region src/expo-sqlite/executor.ts
 const DEFAULT_THROTTLE_MS = 30;
-/** A UUID v4 from SQLite's `randomblob`, for runtimes without `crypto.randomUUID`. */
+/**
+* A UUID v4 from SQLite's `randomblob`, for runtimes without
+* `crypto.randomUUID`.
+*/
 const UUID_SQL = "select lower(hex(randomblob(4)) || '-' || hex(randomblob(2)) || '-4' || substr(hex(randomblob(2)), 2) || '-' || substr('89ab', 1 + (abs(random()) % 4), 1) || substr(hex(randomblob(2)), 2) || '-' || hex(randomblob(6))) as id";
 function contextOf(db) {
 	return {
@@ -40,8 +43,8 @@ function changesOf(db, addListener) {
 }
 /**
 * An expo-sqlite database in the shape the SQLite executor, `watch()` and
-* `useWatch()` read. Writes run in `withExclusiveTransactionAsync` on
-* native and `withTransactionAsync` on web.
+* `useWatch()` read. Writes run in `withExclusiveTransactionAsync` on native
+* and `withTransactionAsync` on web.
 */
 function expoSqliteDatabase(db, options = {}) {
 	const context = contextOf(db);
@@ -71,16 +74,19 @@ function randomId() {
 	return crypto?.randomUUID?.();
 }
 /**
-* Runs repository operations on an expo-sqlite database, without PowerSync:
-* the same repositories and list definitions work on a local database the
-* app owns. Reads return rows in the PostgREST shape; what SQLite can't
-* express returns a `DbError` of kind `unsupported`. An insert that leaves
-* out a text or uuid key gets `crypto.randomUUID()`, else a UUID from
-* SQLite.
+* Runs repository operations on an expo-sqlite database, without PowerSync: the
+* same repositories and list definitions work on a local database the app owns.
+* Reads return rows in the PostgREST shape; what SQLite can't express returns a
+* `DbError` of kind `unsupported`. An insert that leaves out a text or uuid key
+* gets `crypto.randomUUID()`, else a UUID from SQLite.
 *
 * ```ts
-* const sqlite = await openDatabaseAsync("app.db", { enableChangeListener: true });
-* const db = betterSupabase.connect(expoSqliteExecutor(sqlite, { addDatabaseChangeListener }));
+* const sqlite = await openDatabaseAsync("app.db", {
+*   enableChangeListener: true,
+* });
+* const db = betterSupabase.connect(
+*   expoSqliteExecutor(sqlite, { addDatabaseChangeListener }),
+* );
 * ```
 */
 function expoSqliteExecutor(db, options = {}) {

package/dist/feature-BBLdbGu7.js

@@ -0,0 +1,224 @@
+import { n as dbError } from "./errors-03ysrOt4.js";
+import { t as AsyncResult } from "./result-B3m7xtRY.js";
+import { t as can } from "./permissions-BetA_Fo_.js";
+//#region src/records/sections.ts
+/** The block key, module and section a section name refers to. */
+function findSection(blocks, name) {
+	for (const [key, block] of Object.entries(blocks)) {
+		const section = block.sections?.[name];
+		if (section !== void 0) return {
+			key,
+			module: section.module ?? block.sql[0] ?? key,
+			section
+		};
+	}
+}
+function clientOf(clients, key) {
+	return clients[key];
+}
+function missing(name, detail) {
+	return dbError("invalid_request", `Section "${name}" ${detail}`);
+}
+/**
+* A `can` for `loadSections` from the caller's `PermissionSet` and the
+* `permissions` constant of `blocks.generated.ts`: a section needs the key its
+* module's action names there. An action with no key there is allowed, and RLS
+* decides.
+*/
+function sectionCan(set, permissions) {
+	return ({ module, action }) => {
+		const key = permissions[module]?.[action];
+		return key === void 0 || can(set, key);
+	};
+}
+/**
+* Loads a record's sections in parallel, each one settled: `ok` with its rows,
+* `error` with a `DbError`, or `hidden` when `can` says the caller can't read
+* it, which never runs its query. It never throws.
+*
+* ```ts
+* const { comments, tags } = await loadSections(
+*   { blocks: blockSet.blocks, clients: blocks },
+*   { type: "customer", id },
+*   ["comments", "tags"],
+*   { can: sectionCan(permissionSet, permissions) },
+* );
+* ```
+*/
+async function loadSections(source, subject, names, options = {}) {
+	const settled = await Promise.all(names.map(async (name) => {
+		const found = findSection(source.blocks, name);
+		if (found === void 0) return [name, {
+			kind: "error",
+			error: missing(name, "is in no block")
+		}];
+		if (!(options.can?.({
+			section: name,
+			module: found.module,
+			action: found.section.permissions.read
+		}) ?? true)) return [name, { kind: "hidden" }];
+		const client = clientOf(source.clients, found.key);
+		if (client === void 0) return [name, {
+			kind: "error",
+			error: missing(name, `needs the "${found.key}" block built`)
+		}];
+		const load = found.section.load;
+		const given = options.options?.[name];
+		const result = await load(client, subject, given);
+		return [name, result.ok ? {
+			kind: "ok",
+			data: result.data
+		} : {
+			kind: "error",
+			error: result.error
+		}];
+	}));
+	return Object.fromEntries(settled);
+}
+/**
+* How many rows a section has for each of `subjects`, keyed by `subjectKey`
+* (`type:id`), for a badge on each row of a list. A section without `count`
+* fails with `unsupported`.
+*/
+function countSection(source, name, subjects) {
+	const found = findSection(source.blocks, name);
+	const client = found && clientOf(source.clients, found.key);
+	if (found?.section.count === void 0 || client === void 0) return AsyncResult.err(dbError("unsupported", `Section "${name}" can't count rows`));
+	const count = found.section.count;
+	return count(client, subjects);
+}
+//#endregion
+//#region src/records/feature.ts
+/** Describes one subject's record page from the blocks that own its sections. */
+function defineRecordFeature(spec) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const block of Object.values(spec.blocks)) for (const name of Object.keys(block.sections ?? {})) seen.add(name);
+	return {
+		...spec,
+		sections: [...seen]
+	};
+}
+/** The record a feature's page shows. */
+function recordSubject(feature, id) {
+	return {
+		type: feature.type,
+		id
+	};
+}
+/** The block key, module and write that `section.write` names. */
+function findSectionWrite(feature, section, write) {
+	const found = findSection(feature.blocks, section);
+	const entry = found?.section.writes?.[write];
+	return found === void 0 || entry === void 0 ? void 0 : {
+		key: found.key,
+		module: found.module,
+		write: entry,
+		permission: entry.permission ?? found.section.permissions.write
+	};
+}
+function keyOf(feature, module, action) {
+	return action === void 0 ? void 0 : feature.permissions?.[module]?.[action];
+}
+/**
+* The permission keys a feature's sections check, for one
+* `access.permissions(keys)` call.
+*/
+function recordPermissionKeys(feature) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const name of feature.sections) {
+		const found = findSection(feature.blocks, name);
+		if (found === void 0) continue;
+		const { permissions, writes = {} } = found.section;
+		const actions = [permissions.read, ...Object.values(writes).map((write) => write.permission ?? permissions.write)];
+		for (const action of actions) {
+			const key = keyOf(feature, found.module, action);
+			if (key !== void 0) keys.add(key);
+		}
+	}
+	return [...keys];
+}
+/**
+* What the caller may do on each of a feature's sections, from its
+* `PermissionSet`. A section action with no key in `permissions` is allowed,
+* and so is everything when `set` is `undefined` (no access block): RLS and
+* each function's checks decide.
+*/
+function recordCan(feature, set) {
+	const allowed = (module, action) => {
+		if (set === void 0) return true;
+		const key = keyOf(feature, module, action);
+		return key === void 0 || can(set, key);
+	};
+	return Object.fromEntries(feature.sections.flatMap((name) => {
+		const found = findSection(feature.blocks, name);
+		if (found === void 0) return [];
+		const { permissions, writes = {} } = found.section;
+		return [[name, {
+			read: allowed(found.module, permissions.read),
+			...Object.fromEntries(Object.entries(writes).map(([write, entry]) => [write, allowed(found.module, entry.permission ?? permissions.write)]))
+		}]];
+	}));
+}
+/** The write names of each of a feature's sections. */
+function featureWrites(feature) {
+	return feature.sections.map((section) => [section, Object.keys(findSection(feature.blocks, section)?.section.writes ?? {})]);
+}
+/**
+* Runs `section.write` with the client its block's creator made, which
+* `clients` holds under the block's key.
+*/
+function runSectionWrite(feature, clients, section, write, subject, input) {
+	const found = findSectionWrite(feature, section, write);
+	const client = clients[found?.key ?? ""];
+	if (found === void 0 || client === void 0) return AsyncResult.err(dbError("invalid_request", `Section "${section}" has no write "${write}" with its block built`));
+	const run = found.write.run;
+	return run(client, subject, input);
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* A Standard Schema for `{ id, input }`: a non-empty record id and the input
+* `schema` validates, whose issues get the `input` path.
+*/
+function recordWriteInput(schema) {
+	const check = (inner, id) => inner.issues === void 0 ? { value: {
+		id,
+		input: inner.value
+	} } : { issues: inner.issues.map((issue) => ({
+		...issue,
+		path: ["input", ...issue.path ?? []]
+	})) };
+	return { "~standard": {
+		version: 1,
+		vendor: "better-supabase",
+		validate: (value) => {
+			if (!isObject(value)) return { issues: [{ message: "Expected an object" }] };
+			const { id, input } = value;
+			if (typeof id !== "string" || id === "") return { issues: [{
+				message: "Expected a record id",
+				path: ["id"]
+			}] };
+			const inner = schema["~standard"].validate(input ?? {});
+			return inner instanceof Promise ? inner.then((settled) => check(settled, id)) : check(inner, id);
+		}
+	} };
+}
+function isTemporal(value) {
+	return Object.prototype.toString.call(value).startsWith("[object Temporal.");
+}
+/**
+* `value` with every Temporal value replaced by its ISO 8601 string, for data
+* passed from a Server Component or returned from a Server Action.
+*/
+function plainData(value) {
+	const walk = (entry) => {
+		if (typeof entry !== "object" || entry === null) return entry;
+		if (isTemporal(entry)) return entry.toString();
+		if (Array.isArray(entry)) return entry.map(walk);
+		return Object.fromEntries(Object.entries(entry).map(([key, field]) => [key, walk(field)]));
+	};
+	return walk(value);
+}
+//#endregion
+export { recordCan as a, recordWriteInput as c, findSection as d, loadSections as f, plainData as i, runSectionWrite as l, featureWrites as n, recordPermissionKeys as o, sectionCan as p, findSectionWrite as r, recordSubject as s, defineRecordFeature as t, countSection as u };