better-supabase 0.12.0 → 0.13.0

package/dist/index-Dh5ZFCtu.d.ts

@@ -0,0 +1,61 @@
+import { A as AnyOpenApiDocument, H as RenderedOpenApi, R as OpenApiDocuments, V as OpenApiVersion, n as DefineApiOptions, u as ApiSource } from "./api-DwLhJS1j.js";
+import { c as SpecDiagnostic, r as DocumentFormat } from "./format-AYHceC2m.js";
+import { r as ResourceDescription } from "./resource-DxQOPkZ5.js";
+//#region src/openapi/format.d.ts
+/**
+ * OpenAPI as a `DocumentFormat`. 3.1 is the default; 3.0 is legacy (schemas
+ * lowered to the 3.0 Schema Object); 3.2 has native `$self`, nested tags,
+ * `itemSchema`, `oauth2MetadataUrl` and `query`; `3.3-preview` follows the
+ * v3.3-dev branch at `SPEC_PINS.openapi33Preview`, with Path Item `security`
+ * and the Security Profiles proposal. Below 3.2, the 3.2 fields travel as the
+ * registered `x-oai-*` extensions where one exists, and as the model's prefixed
+ * extensions otherwise.
+ */
+declare const openapiFormat: DocumentFormat<"openapi", OpenApiVersion, AnyOpenApiDocument, OpenApiDocuments>;
+//#endregion
+//#region src/openapi/schema30.d.ts
+type Json = Record<string, unknown>;
+/**
+ * Rewrites a JSON Schema 2020-12 schema into the OpenAPI 3.0 Schema Object:
+ * `null` in `type` or in an `anyOf`/`oneOf` becomes `nullable`, a type list
+ * becomes `anyOf`, `const` becomes a one-value `enum`, `examples` becomes
+ * `example`, numeric `exclusiveMinimum`/`exclusiveMaximum` become the boolean
+ * form, `contentEncoding: base64` becomes `format: byte`, and a `$ref` with
+ * siblings is wrapped in `allOf`. Keywords 3.0 does not have are left out. The
+ * input is not changed.
+ */
+declare function toOpenApi30Schema(schema: Readonly<Json>): Json;
+//#endregion
+//#region src/openapi/index.d.ts
+/** How one table is published; see `defineApi`'s `resources`. */
+type ResourceOptions<Ref = string> = ResourceDescription<Ref>;
+interface OpenApiOptions<V extends OpenApiVersion = "3.1", Ref = string> extends DefineApiOptions<Ref> {
+  /** Defaults to 3.1. `3.3-preview` follows a draft. */
+  readonly version?: V;
+  /** Last change to the document before overlays; see `RenderOptions.transform`. */
+  readonly transform?: (rendered: Extract<RenderedOpenApi, {
+    readonly version: V;
+  }>) => OpenApiDocuments[OpenApiVersion] | undefined;
+  readonly overlays?: readonly unknown[];
+  /** Hears every warning and info finding. Errors throw. */
+  readonly onDiagnostic?: (diagnostic: SpecDiagnostic) => void;
+}
+/**
+ * An OpenAPI document for REST resources over your tables, with schemas from
+ * the generated metadata, list-query parameters, Supabase security schemes and
+ * Problem Details errors. Throws when building or checking the document finds
+ * an error; use `defineApi` to read every finding instead.
+ *
+ * ```ts
+ * const doc = createOpenApi(betterSupabase, {
+ *   info: { title: "CRM API", version: "1.0.0" },
+ *   resources: {
+ *     customers: { list: customerList },
+ *     notes: { operations: ["list", "get"] },
+ *   },
+ * });
+ * ```
+ */
+declare function createOpenApi<V extends OpenApiVersion = "3.1", Ref = string>(betterSupabase: ApiSource, options: OpenApiOptions<V, Ref>): OpenApiDocuments[V];
+//#endregion
+export { openapiFormat as a, toOpenApi30Schema as i, ResourceOptions as n, createOpenApi as r, OpenApiOptions as t };

package/dist/index-NRMMhhEi.d.ts

@@ -0,0 +1,104 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { SupabaseEnv } from "@supabase/server";
+//#region src/env/index.d.ts
+/**
+ * Validated Supabase settings. Only `publicEnv()` of it is safe to ship to a
+ * browser.
+ */
+interface BetterSupabaseEnv {
+  readonly url: string;
+  readonly publishableKey: string;
+  readonly secretKey?: string;
+  /**
+   * Named secret keys from `SUPABASE_SECRET_KEYS`, including `default` when
+   * `secretKey` is set.
+   */
+  readonly secretKeys?: Readonly<Record<string, string>>;
+  /** `SUPABASE_JWKS_URL`, or `<url>/auth/v1/.well-known/jwks.json`. */
+  readonly jwksUrl: URL;
+  /** `SUPABASE_JWKS`: inline keys, used instead of fetching `jwksUrl`. */
+  readonly jwks?: InlineJwks;
+  /**
+   * Postgres connection string: `SUPABASE_DB_URL`, `DATABASE_URL`, then the
+   * Vercel integration's `POSTGRES_URL` (pooled) and
+   * `POSTGRES_URL_NON_POOLING`.
+   */
+  readonly dbUrl?: string;
+  /** Project ref for hosted projects (`<ref>.supabase.co`). */
+  readonly projectRef?: string;
+  /**
+   * `SUPABASE_READ_URL`: a read replica or the `<ref>-all` load balancer, for
+   * reads.
+   */
+  readonly readUrl?: string;
+  /**
+   * `SUPABASE_JWT_SECRET`: the shared HS256 secret Supabase Lite signs user
+   * tokens with (`auth.jwt_secret`). Server-only; read with `backend: "lite"`.
+   */
+  readonly jwtSecret?: string;
+}
+/** A JSON Web Key Set, as `@supabase/server` verifies with it. */
+type InlineJwks = Exclude<SupabaseEnv["jwks"], URL | null>;
+interface PublicEnv {
+  readonly url: string;
+  readonly publishableKey: string;
+}
+type EnvSource = Readonly<Record<string, string | undefined>>;
+interface EnvIssue {
+  /** The variable names that were checked, first one preferred. */
+  readonly variables: readonly string[];
+  readonly message: string;
+}
+interface EnvOptions {
+  /** Settings that must be present. `url` and `publishableKey` always are. */
+  readonly require?: readonly ("secretKey" | "dbUrl")[];
+}
+type EnvResult = {
+  readonly ok: true;
+  readonly env: BetterSupabaseEnv;
+  readonly issues?: undefined;
+} | {
+  readonly ok: false;
+  readonly env?: undefined;
+  readonly issues: readonly EnvIssue[];
+};
+declare const ENV_VARIABLES: {
+  readonly url: readonly string[];
+  readonly publishableKey: readonly string[];
+  readonly secretKey: readonly string[];
+  readonly dbUrl: readonly string[];
+  readonly jwksUrl: readonly string[];
+  readonly jwks: readonly string[];
+  readonly readUrl: readonly string[];
+  readonly jwtSecret: readonly string[];
+};
+declare class EnvValidationError extends Error {
+  override readonly name = "EnvValidationError";
+  readonly issues: readonly EnvIssue[];
+  constructor(issues: readonly EnvIssue[]);
+}
+/**
+ * Reads and validates Supabase settings. Accepts the `SUPABASE_`,
+ * `NEXT_PUBLIC_`, `VITE_`, `PUBLIC_`, `EXPO_PUBLIC_` and `NUXT_PUBLIC_`
+ * spellings. Issues name variables, never values.
+ */
+declare function parseEnv(source: EnvSource, options?: EnvOptions): EnvResult;
+/**
+ * Like `parseEnv`, but throws `EnvValidationError`. Reads `process.env` by
+ * default.
+ */
+declare function loadEnv(source?: EnvSource, options?: EnvOptions): BetterSupabaseEnv;
+/**
+ * The env validator as a Standard Schema, for t3-env, framework config or any
+ * validator slot.
+ */
+declare function envSchema(options?: EnvOptions): StandardSchemaV1<EnvSource, BetterSupabaseEnv>;
+/** The parts that are safe in client bundles. */
+declare function publicEnv(env: BetterSupabaseEnv): PublicEnv;
+/**
+ * Converts to `@supabase/server`'s `SupabaseEnv` (the `env` option of
+ * `withSupabase`).
+ */
+declare function toServerEnv(env: BetterSupabaseEnv): SupabaseEnv;
+//#endregion
+export { EnvResult as a, InlineJwks as c, loadEnv as d, parseEnv as f, EnvOptions as i, PublicEnv as l, toServerEnv as m, ENV_VARIABLES as n, EnvSource as o, publicEnv as p, EnvIssue as r, EnvValidationError as s, BetterSupabaseEnv as t, envSchema as u };

package/dist/index-PADpaDku.d.ts

@@ -0,0 +1,447 @@
+import { d as AccessBlockConfig, p as AnyBlocksConfig } from "./authorization-CB69cvnA.js";
+import { i as BlockCategory } from "./define-block-MyM4lH42.js";
+import { i as PortName } from "./ports-BltcWsHf.js";
+import { In as AppTablesConfig, at as Preset, ht as PresetTenantName, jn as AppTableConfig, mt as PresetScope, ot as PresetAccess, st as PresetCodeField, ut as PresetFieldKey, y as BetterSupabaseConfig } from "./codegen-DGtOsqz9.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/preset/blocks.d.ts
+/**
+ * Every block a preset code can select, by bit position. Append-only: a new
+ * block goes at the end, and a removed block becomes `null` (a tombstone) so
+ * the blocks after it keep their bits. A test checks that it lists every SQL
+ * module.
+ */
+declare const PRESET_BLOCKS: readonly (string | null)[];
+//#endregion
+//#region src/preset/catalog-types.d.ts
+/** One SQL module in the preset catalog: a key of `blocks` in the config. */
+interface PresetCatalogBlock {
+  readonly name: string;
+  readonly title: string;
+  readonly category: BlockCategory;
+  /** The modules it needs with the default options. */
+  readonly requires: readonly string[];
+  /** What it needs instead under an access model, where that differs. */
+  readonly requiresByAccess?: Partial<Readonly<Record<PresetAccess, readonly string[]>>>;
+  /** The scopes it runs in; unset, every scope. */
+  readonly scopes?: readonly PresetScope[];
+  /** Tenant names that would rename a table or column to a name it already uses. */
+  readonly tenantNameClashes?: readonly PresetTenantName[];
+  /**
+   * The logical table `options.extraColumns` adds columns to, when it takes
+   * them.
+   */
+  readonly extraColumns?: string;
+  /** Modules it works with when installed; `*` is every module. */
+  readonly integrates: readonly string[];
+  /** The manifest that installs it, a key of `manifests`. */
+  readonly manifest: string;
+}
+/** One block manifest (ADR 0029): what `lib/blocks.ts` wires. */
+interface PresetCatalogManifest {
+  readonly name: string;
+  /** The SQL modules it installs. */
+  readonly sql: readonly string[];
+  readonly category: BlockCategory;
+  /** Its export and subpath, when it has a TypeScript client. */
+  readonly client: {
+    readonly export: string;
+    readonly subpath: string;
+  } | null;
+  readonly consumes: Partial<Readonly<Record<PortName, "optional" | "required">>>;
+  readonly provides: readonly PortName[];
+}
+/**
+ * One item of the `@better-supabase` shadcn registry: glue the app copies (`npx
+ * shadcn add @better-supabase/<name>`), for some blocks, frameworks and
+ * platforms.
+ */
+interface PresetGlueItem {
+  readonly name: string;
+  readonly title: string;
+  /** The SQL modules the item needs. */
+  readonly blocks: readonly string[];
+  readonly frameworks: readonly string[];
+  readonly platforms: readonly ("web" | "native")[];
+  /** Where its files go, as shadcn targets (`@lib/blocks.ts`, `~/app/...`). */
+  readonly targets: readonly string[];
+  /** The named preset a bundle item (`registry:item`) installs the glue of. */
+  readonly preset?: string;
+}
+/** What `scripts/build-catalog.ts` writes to `catalog.generated.ts`. */
+interface PresetCatalog {
+  readonly blocks: readonly PresetCatalogBlock[];
+  readonly manifests: readonly PresetCatalogManifest[];
+  readonly glue: readonly PresetGlueItem[];
+}
+//#endregion
+//#region src/preset/catalog.generated.d.ts
+declare const PRESET_CATALOG: PresetCatalog;
+//#endregion
+//#region src/preset/code.d.ts
+/** What `decodePreset` returns. */
+interface DecodedPreset {
+  readonly preset: Preset;
+  /** The code version the code was written with. */
+  readonly version: number;
+  /** Fields the code's version predates, set to their defaults. */
+  readonly derived: readonly PresetFieldKey[];
+}
+/** The fields and blocks a code is read against; tests pass their own. */
+interface PresetLayout {
+  readonly fields: readonly PresetCodeField[];
+  readonly blocks: readonly (string | null)[];
+  readonly version: number;
+}
+/**
+ * The preset as a code: a version character, then base62 of one BigInt that
+ * holds each field's value index and a bit per selected block.
+ */
+declare function encodePreset(preset: Partial<Preset>, layout?: PresetLayout): string;
+/**
+ * The preset with one convention set to `value`, checked against the field: a
+ * value the field doesn't list throws. For a field that takes several values
+ * (`integrations`), `value` switches that one on or off.
+ */
+declare function withPresetField(preset: Preset, key: PresetFieldKey, value: string): Preset;
+/**
+ * Reads a code from `encodePreset`. A code from an older version decodes with
+ * the fields it predates at their defaults, listed in `derived`. A code from a
+ * newer release throws, naming the upgrade.
+ */
+declare function decodePreset(code: string, layout?: PresetLayout): DecodedPreset;
+/**
+ * Whether `value` reads as a preset code rather than a preset name: a version
+ * character (`1` to `9`, then `A` to `Z`) and base62 digits.
+ */
+declare function isPresetCode(value: string): boolean;
+//#endregion
+//#region src/preset/resolve.d.ts
+/** One block in a resolved preset, with why it is there. */
+interface ResolvedPresetBlock {
+  readonly name: string;
+  readonly title: string;
+  readonly category: BlockCategory;
+  /** Whether the preset names it, rather than another block requiring it. */
+  readonly selected: boolean;
+  /** The blocks in the set that require it. */
+  readonly requiredBy: readonly string[];
+  /** "selected", or "required by comments and tags". */
+  readonly reason: string;
+}
+/** A soft integration between two blocks that are both in the set. */
+interface PresetIntegration {
+  /** The block that works with `to`. */
+  readonly from: string;
+  readonly to: string;
+}
+/** Something in the preset that can't install, and why. */
+interface PresetConflict {
+  readonly block?: string;
+  readonly field?: PresetFieldKey;
+  readonly reason: string;
+}
+/** What `resolvePreset` returns. */
+interface ResolvedPreset {
+  readonly preset: Preset;
+  /** Every block to install, in install order; conflicting blocks are left out. */
+  readonly blocks: readonly ResolvedPresetBlock[];
+  /** The soft integrations active between blocks in the set. */
+  readonly integrations: readonly PresetIntegration[];
+  readonly conflicts: readonly PresetConflict[];
+  /** The manifests that cover `blocks`, for `lib/blocks.ts`. */
+  readonly manifests: readonly PresetCatalogManifest[];
+}
+/** "a", "a and b", "a, b and c". */
+declare function listNames(names: readonly string[]): string;
+/**
+ * Why `name` can't install with the preset's conventions, or undefined.
+ * `/create` disables a block with this reason before it is selected.
+ */
+declare function presetBlockConflict(preset: Pick<Preset, "access" | "scope">, name: string, catalog?: PresetCatalog): string | undefined;
+/**
+ * The full block set for a preset: the selected blocks and what they require, a
+ * reason per block, the soft integrations active between them, and what can't
+ * install. It reads the generated catalog, never the SQL renderers, so it runs
+ * in the browser.
+ */
+declare function resolvePreset(preset: Preset, catalog?: PresetCatalog): ResolvedPreset;
+//#endregion
+//#region src/preset/config.d.ts
+/** A named preset, a code, a `/create?preset=` URL, or a preset object. */
+type PresetInput = string | (Partial<Preset> & {
+  readonly blocks?: readonly string[];
+});
+/** Reads a named preset, a code or a `/create?preset=` URL into a `Preset`. */
+declare function presetOf(input: PresetInput): Preset;
+/**
+ * The conventions that map onto config keys; `tenantName` takes any name
+ * `sql.naming.tenant` allows.
+ */
+type ConfigConventions = Pick<Preset, "casing" | "idType" | "scope" | "access" | "api"> & {
+  readonly tenantName: string;
+};
+/**
+ * The config keys conventions set without a preset: `casing`, `sql`, and
+ * `blocks.access` when the access model or id type differ from the defaults.
+ */
+declare function conventionConfig(conventions: ConfigConventions): Pick<BetterSupabaseConfig, "casing" | "sql"> & {
+  readonly blocks?: {
+    readonly access: AccessBlockConfig;
+  };
+};
+/**
+ * The config keys a resolved preset sets: its blocks and the conventions that
+ * differ from the defaults.
+ */
+declare function presetConfig(resolved: ResolvedPreset): Pick<BetterSupabaseConfig, "casing" | "sql" | "integrations"> & {
+  readonly blocks: AnyBlocksConfig;
+};
+/**
+ * `config` with its `preset` expanded: the preset's blocks (and what they
+ * require) and conventions first, then the config's own keys over them, so
+ * explicit config wins. A block in both keeps the preset's settings that the
+ * config's entry leaves unset. Expanding twice gives the same config.
+ */
+declare function expandPreset(config: BetterSupabaseConfig): BetterSupabaseConfig;
+//#endregion
+//#region src/preset/design.d.ts
+/**
+ * What the `/create` canvas adds to a preset (ADR 0040): tables the app owns,
+ * extra columns on block tables, and where each table sits on the canvas. It
+ * travels in the `&design=` parameter of a `/create` URL.
+ */
+interface CreateDesign {
+  /** `config.appTables`. */
+  readonly appTables?: Readonly<Record<string, AppTableConfig>>;
+  /**
+   * `blocks.<module>.options.extraColumns`: column name to SQL type, per
+   * module.
+   */
+  readonly extraColumns?: Readonly<Record<string, Readonly<Record<string, string>>>>;
+  /** Canvas positions by `schema.table`, as `[x, y]`; the config ignores them. */
+  readonly positions?: Readonly<Record<string, readonly [number, number]>>;
+}
+/**
+ * The newest format of the design JSON, in its `version` key (ADR 0042). A code
+ * carries the lowest format that reads it, and none for format 0, so a design
+ * without format 1 keys still opens in an older release. Format 1 adds column
+ * `format`, `options`, `min`, `max`, `comment` and `identity`, and table `id`,
+ * `unique`, `indexes` and `comment`. Format 2 adds table `subject` (ADR 0043).
+ * Format 3 adds table `rollups` and `lookups` (ADR 0044). Format 4 adds table
+ * `events` (ADR 0048) and subject `versions`. Format 5 adds column `access`
+ * (ADR 0051).
+ */
+declare const DESIGN_FORMAT = 5;
+/** The lowest design format that reads `design`. */
+declare function designFormat(design: CreateDesign): number;
+/** The longest design code, so a `/create` URL stays under common limits. */
+declare const MAX_DESIGN_CODE_LENGTH = 6e3;
+/** The name Create gives the design file it downloads. */
+declare const DESIGN_FILE = "better-supabase.design.json";
+/**
+ * Why a design, a design code or a design file was rejected. The codes are
+ * stable; the messages may change.
+ */
+type DesignErrorCode = "invalid_design" | "unknown_key" | "unsupported_format" | "too_large" | "unknown_block" | "no_extra_columns" | "block_not_installed" | "invalid_name" | "invalid_type" | "invalid_position" | "invalid_app_table" | "invalid_code" | "too_long" | "invalid_file" | "invalid_preset";
+/** One problem with a design, as `safeParseDesign` reports it. */
+interface DesignParseIssue {
+  readonly code: DesignErrorCode;
+  /**
+   * A JSON Pointer (RFC 6901) to the key at fault in the value that was read,
+   * such as `/appTables/tasks/columns/title`. `""` is the value itself. When
+   * the key is missing, it points to the nearest parent.
+   */
+  readonly path: string;
+  readonly message: string;
+}
+/**
+ * What `parseDesign`, `decodeDesign`, `designFileSource` and `readDesignFile`
+ * throw.
+ */
+declare class DesignParseError extends TypeError implements DesignParseIssue {
+  readonly code: DesignErrorCode;
+  readonly path: string;
+  constructor(code: DesignErrorCode, path: string, message: string, options?: ErrorOptions);
+  /** The issue as a plain, serializable object. */
+  toJSON(): DesignParseIssue;
+}
+/**
+ * What `encodeDesign` throws when a valid design is too long for a URL, so a
+ * caller can offer the config download instead of a fix.
+ */
+declare class DesignTooLongError extends DesignParseError {
+  /** The length the code would have. */
+  readonly length: number;
+  constructor(length: number);
+}
+/** Whether `value` has the shape of a design code. It may still fail to decode. */
+declare function isDesignCode(value: string): boolean;
+/**
+ * Checks a design object, such as one from storage or a request body, and drops
+ * its empty parts. It runs the same checks as `decodeDesign`, without the code.
+ * Throws a `DesignParseError` naming the first problem; `safeParseDesign`
+ * returns it instead.
+ */
+declare function parseDesign(value: unknown): CreateDesign;
+/** What `safeParseDesign` and `safeDesignFileSource` return. */
+type DesignParseResult<T> = ({
+  readonly ok: true;
+} & T) | {
+  readonly ok: false;
+  readonly issues: readonly DesignParseIssue[];
+};
+/**
+ * `parseDesign` without the throw: the design, or the issue that stopped it,
+ * with a stable `code` and a JSON Pointer `path`.
+ */
+declare function safeParseDesign(value: unknown): DesignParseResult<{
+  readonly design: CreateDesign;
+}>;
+/**
+ * A Standard Schema (v1) for a design, so a form library, a router or an AI SDK
+ * tool can validate one with the same rules as `parseDesign`. The output drops
+ * the empty parts; each issue's `path` lists the keys of its JSON Pointer.
+ * `schemas/design-v1.json` is the JSON Schema of its shape.
+ */
+declare const designSchema: StandardSchemaV1<unknown, CreateDesign>;
+/**
+ * The design as a code for the `&design=` parameter: `0`, then its JSON (with
+ * `version` set to `designFormat` when it is above 0) compressed with
+ * deflate-raw, in base64url. An empty design is `""`. Throws a
+ * `DesignParseError` when the design is invalid, and a `DesignTooLongError`
+ * when the code would be longer than `MAX_DESIGN_CODE_LENGTH`.
+ */
+declare function encodeDesign(design: CreateDesign): Promise<string>;
+/** Reads a design code. Throws a `DesignParseError` when it isn't a valid one. */
+declare function decodeDesign(code: string): Promise<CreateDesign>;
+/**
+ * The design in a `/create` URL's `&design=` parameter, or in a bare design
+ * code; `undefined` when `input` has neither.
+ */
+declare function designOf(input: string): Promise<CreateDesign | undefined>;
+/**
+ * The config keys a preset with a design sets: `presetConfig`, with each
+ * block's `options.extraColumns` and `appTables`. Throws a `DesignParseError`
+ * when the design adds columns to a block the preset doesn't install.
+ */
+declare function designConfig(resolved: ResolvedPreset, design: CreateDesign): ReturnType<typeof presetConfig> & {
+  readonly appTables?: AppTablesConfig;
+};
+/**
+ * `better-supabase.config.ts` for a preset with a design. `designCode`, the
+ * design's `encodeDesign`, goes into the `/create` URL in the comment, so the
+ * canvas reopens with its positions.
+ */
+declare function designConfigSource(resolved: ResolvedPreset, design: CreateDesign, designCode?: string): string;
+/**
+ * The command that starts a project from the preset and design: `init` with the
+ * quoted `/create` URL, or `presetInstallCommand` when `designCode` is empty.
+ */
+declare function designInstallCommand(resolved: ResolvedPreset, designCode: string): string;
+/**
+ * A preset and its design as one JSON file, for a design too long for a URL
+ * (ADR 0058). `init --preset` and `apply --preset` read it from a path.
+ */
+interface DesignFile {
+  /** The preset code. */
+  readonly preset: string;
+  /** The design, with `version` set to `designFormat` when it is above 0. */
+  readonly design: CreateDesign & {
+    readonly version?: number;
+  };
+}
+/**
+ * The design file for a preset and design, as JSON text. Throws a
+ * `DesignParseError` when the design is invalid; `safeDesignFileSource` returns
+ * it instead. It has no length limit.
+ */
+declare function designFileSource(resolved: ResolvedPreset, design: CreateDesign): string;
+/**
+ * `designFileSource` without the throw: the file text, or the issue that
+ * stopped it. Each `path` points into the design.
+ */
+declare function safeDesignFileSource(resolved: ResolvedPreset, design: CreateDesign): DesignParseResult<{
+  readonly source: string;
+}>;
+/**
+ * Reads a design file's text. Each `DesignParseError` path points into the
+ * file, so a design problem starts with `/design`. Throws one naming the first
+ * problem: text that isn't JSON, a missing or invalid preset, or an invalid
+ * design.
+ */
+declare function readDesignFile(text: string): {
+  readonly preset: Preset;
+  readonly design: CreateDesign;
+};
+/** The command that applies the preset and design to an existing project. */
+declare function designApplyCommand(resolved: ResolvedPreset, designCode: string): string;
+//#endregion
+//#region src/preset/design-diff.d.ts
+/** What changed between two sets of app tables. */
+type DesignChangeKind = "table.added" | "table.dropped" | "table.renamed" | "table.id" | "table.scope" | "table.unique" | "table.columns" | "table.changed" | "table.computed" | "table.events" | "table.versions" | "column.added" | "column.dropped" | "column.renamed" | "column.type" | "column.required" | "column.unique" | "column.options" | "column.bounds" | "column.format" | "column.reference" | "column.access" | "column.changed";
+interface DesignChange {
+  readonly kind: DesignChangeKind;
+  readonly table: string;
+  readonly column?: string;
+  /** The old name of a renamed table or column, or the old type. */
+  readonly from?: string;
+  /** The new type of a type change. */
+  readonly to?: string;
+  /**
+   * True when existing rows or app code can break: a dropped or renamed table
+   * or column, a type change, a column made required without a default, a new
+   * or tighter constraint (unique, options, bounds, format, a reference
+   * target), tighter column access, a new scope, or removed generated columns.
+   */
+  readonly breaking: boolean;
+  readonly summary: string;
+  /** The expand-and-contract steps that make a breaking change safe. */
+  readonly steps: readonly string[];
+}
+interface DiffOptions {
+  /**
+   * Leave out tables that `after` doesn't have, as `apply` does: it writes the
+   * tables of a design and keeps the others.
+   */
+  readonly keepMissing?: boolean;
+}
+/**
+ * What changes from `before` to `after`: each added, dropped, renamed or
+ * changed table and column, with the breaking ones marked and their
+ * expand-and-contract steps. A rename is a dropped name and an added one with
+ * the same definition.
+ */
+declare function diffAppTables(before: AppTablesConfig, after: AppTablesConfig, options?: DiffOptions): readonly DesignChange[];
+/** `diffAppTables` over the app tables of two `/create` designs. */
+declare function diffDesigns(before: CreateDesign, after: CreateDesign): readonly DesignChange[];
+//#endregion
+//#region src/preset/render.d.ts
+/** The comment a config with the provider access model gets above `blocks`. */
+declare const PROVIDER_COMMENT: readonly string[];
+/**
+ * `better-supabase.config.ts` for a resolved preset: every block with its
+ * reason, and the conventions that differ from the defaults.
+ */
+declare function presetConfigSource(resolved: ResolvedPreset): string;
+/**
+ * `lib/blocks.ts`: the blocks with a TypeScript client, wired with
+ * `defineBlocks` over the Data API as the caller. Each block's schema (the API
+ * schema when `sql.api` is set) and shared options come from `blockConfig`,
+ * which `better-supabase gen` writes to `blocks.generated.ts`;
+ * `blockConfigImport` is its import path.
+ */
+declare function presetBlocksSource(resolved: ResolvedPreset, blockConfigImport?: string): string;
+/**
+ * The registry glue for the preset's framework and platforms: each item whose
+ * blocks are all installed, except bundles and items that write
+ * `lib/blocks.ts`, which the preset writes itself.
+ */
+declare function presetGlue(resolved: ResolvedPreset, catalog?: PresetCatalog): readonly PresetGlueItem[];
+/** The shadcn command that copies glue items into the app. */
+declare function glueCommand(items: readonly PresetGlueItem[]): string;
+/** The command that starts a project from the preset. */
+declare function presetInstallCommand(resolved: ResolvedPreset): string;
+/** The command that applies the preset to an existing project. */
+declare function presetApplyCommand(resolved: ResolvedPreset): string;
+//#endregion
+export { encodePreset as $, designOf as A, conventionConfig as B, decodeDesign as C, designFileSource as D, designConfigSource as E, readDesignFile as F, PresetIntegration as G, presetConfig as H, safeDesignFileSource as I, listNames as J, ResolvedPreset as K, safeParseDesign as L, encodeDesign as M, isDesignCode as N, designFormat as O, parseDesign as P, decodePreset as Q, ConfigConventions as R, MAX_DESIGN_CODE_LENGTH as S, designConfig as T, presetOf as U, expandPreset as V, PresetConflict as W, resolvePreset as X, presetBlockConflict as Y, DecodedPreset as Z, DesignFile as _, presetConfigSource as a, PresetCatalogManifest as at, DesignParseResult as b, DesignChange as c, diffAppTables as d, isPresetCode as et, diffDesigns as f, DesignErrorCode as g, DESIGN_FORMAT as h, presetBlocksSource as i, PresetCatalogBlock as it, designSchema as j, designInstallCommand as k, DesignChangeKind as l, DESIGN_FILE as m, glueCommand as n, PRESET_CATALOG as nt, presetGlue as o, PresetGlueItem as ot, CreateDesign as p, ResolvedPresetBlock as q, presetApplyCommand as r, PresetCatalog as rt, presetInstallCommand as s, PRESET_BLOCKS as st, PROVIDER_COMMENT as t, withPresetField as tt, DiffOptions as u, DesignParseError as v, designApplyCommand as w, DesignTooLongError as x, DesignParseIssue as y, PresetInput as z };

package/dist/index-X2fkPUwb.d.ts

@@ -0,0 +1,51 @@
+//#region src/create/oauth/index.d.ts
+/**
+ * OAuth helpers for any provider: PKCE, sealed cookies and a session shape, on
+ * WebCrypto only. `better-supabase/create/supabase` builds the Supabase flow on
+ * them; another provider, such as a deploy target, can reuse them.
+ */
+/**
+ * The HKDF info `seal` and `unseal` use when none is given; cookies sealed with
+ * it keep opening.
+ */
+declare const DEFAULT_SEAL_INFO = "better-supabase create session";
+/** An access token, an optional refresh token and when the access token expires. */
+interface OAuthSession {
+  readonly accessToken: string;
+  readonly refreshToken?: string | undefined;
+  /** Epoch milliseconds. */
+  readonly expiresAt: number;
+}
+declare function isOAuthSession(value: unknown): value is OAuthSession;
+/** What a flow cookie holds between the redirect and the callback. */
+interface OAuthFlow {
+  readonly state: string;
+  readonly verifier: string;
+  readonly returnTo: string;
+}
+declare function isFlow(value: unknown): value is OAuthFlow;
+declare class OAuthError extends Error {
+  override readonly name = "OAuthError";
+}
+/** Whether the access token expires within a minute. */
+declare function needsRefresh(session: OAuthSession, now: number): boolean;
+/** `length` random bytes as base64url. */
+declare function randomToken(length?: number): string;
+/** A PKCE verifier and its S256 challenge (RFC 7636). */
+declare function pkcePair(): Promise<{
+  verifier: string;
+  challenge: string;
+}>;
+/**
+ * Encrypts `value` as JSON with AES-GCM: base64url of the IV, then the
+ * ciphertext. The key comes from `secret` through HKDF with `info`; give each
+ * cookie its own `info` so one can't be swapped for another.
+ */
+declare function seal(value: object, secret: string, info?: string): Promise<string>;
+/**
+ * The value `seal` wrote with the same `secret` and `info`, or `undefined` when
+ * it is missing, tampered with or another shape.
+ */
+declare function unseal<TValue>(sealed: string | undefined, secret: string, guard: (value: unknown) => value is TValue, info?: string): Promise<TValue | undefined>;
+//#endregion
+export { isFlow as a, pkcePair as c, unseal as d, OAuthSession as i, randomToken as l, OAuthError as n, isOAuthSession as o, OAuthFlow as r, needsRefresh as s, DEFAULT_SEAL_INFO as t, seal as u };