@atscript/moost-db 0.1.116 → 0.1.118

package/dist/index.d.cts

@@ -1,3 +1,4 @@
+import { i as resolveDbSpace, n as clearDbSpaces, r as provideDbSpace, t as DEFAULT_DB_SPACE } from "./db-space-registry-CWpYwZ4R.cjs";
 import { TAtscriptAnnotatedType, TAtscriptDataType, TSerializeOptions, TSerializedAnnotatedType, Validator } from "@atscript/typescript/utils";
 import { AtscriptDbReadable, AtscriptDbTable, FilterExpr, FlatOf, TCrudOp, TCrudPermissions, TCrudPermissions as TCrudPermissions$1, TDbActionInfo, TDbActionInfo as TDbActionInfo$1, TDbActionIntent, TDbActionIntent as TDbActionIntent$1, TDbActionLevel, TDbActionLevel as TDbActionLevel$1, TDbActionProcessor, TDbFieldMeta, TIdentification, TMetaResponse, Uniquery, UniqueryControls } from "@atscript/db";
 import { HttpError } from "@moostjs/event-http";
@@ -180,7 +181,7 @@ declare class AsDbReadableController<T extends TAtscriptAnnotatedType = TAtscrip
   private readonly _quantityRefByPath;
   /** Paths the adapter vetoes for filtering (e.g. JSON storage on SQL). Symmetric with `/meta` `filterable: false`. */
   private readonly _adapterNonFilterable;
-  constructor(readable: AtscriptDbReadable<T>, app: Moost);
+  constructor(readable: AtscriptDbReadable<T> | undefined, app: Moost);
   private _collectAdapterNonFilterable;
   private _collectQuantityRefs;
   private _buildGates;
@@ -322,7 +323,7 @@ declare class AsDbReadableController<T extends TAtscriptAnnotatedType = TAtscrip
 declare class AsDbController<T extends TAtscriptAnnotatedType = TAtscriptAnnotatedType, DataType = TAtscriptDataType<T>> extends AsDbReadableController<T, DataType> {
   /** Reference to the underlying table (typed for write access). */
   protected get table(): AtscriptDbTable<T>;
-  constructor(table: AtscriptDbTable<T>, app: Moost);
+  constructor(table: AtscriptDbTable<T> | undefined, app: Moost);
   protected buildCrud(): TCrudPermissions$1;
   /**
    * Intercepts write operations. Return `undefined` to abort.
@@ -536,68 +537,6 @@ declare class AsJsonValueHelpController<T extends TAtscriptAnnotatedType = TAtsc
   private normalizeSelect;
 }
 //#endregion
-//#region src/decorators.d.ts
-/**
- * DI token under which the {@link AtscriptDbReadable} instance
- * is exposed to the readable controller's constructor via `@Inject`.
- */
-declare const READABLE_DEF = "__atscript_db_readable_def";
-/**
- * DI token under which the {@link AtscriptDbTable} instance
- * is exposed to the controller's constructor via `@Inject`.
- * Points to the same token as READABLE_DEF for backward compatibility.
- */
-declare const TABLE_DEF = "__atscript_db_readable_def";
-/**
- * Combines the boilerplate needed to turn an {@link AsDbController}
- * subclass into a fully wired HTTP controller for a given `@db.table` model.
- *
- * Internally applies three decorators:
- * 1. **Provide** — registers the table instance under {@link TABLE_DEF}.
- * 2. **Controller** — registers the class as a Moost HTTP controller
- *    with an optional route prefix. Defaults to `table.tableName`.
- * 3. **Inherit** — copies metadata (routes, guards, etc.) from the
- *    parent class so they stay active in the derived controller.
- *
- * @param table  The {@link AtscriptDbTable} instance for this controller.
- * @param prefix Optional route prefix. Defaults to `table.tableName`.
- *
- * @example
- * ```ts
- * ‎@TableController(usersTable)
- * export class UsersController extends AsDbController<typeof UserModel> {}
- * ```
- */
-declare const TableController: <Table extends AtscriptDbTable<any, any, any, any, any, any, any>>(table: Table, prefix?: string) => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-/**
- * Combines the boilerplate needed to turn an {@link AsDbReadableController}
- * subclass into a fully wired HTTP controller for a given `@db.view` or `@db.table` model.
- *
- * @param readable  The {@link AtscriptDbReadable} instance (table or view).
- * @param prefix    Optional route prefix. Defaults to `readable.tableName`.
- *
- * @example
- * ```ts
- * ‎@ReadableController(activeTasksView)
- * export class ActiveTasksController extends AsDbReadableController<typeof ActiveTasks> {}
- * ```
- */
-declare const ReadableController: <Readable extends AtscriptDbReadable<any, any, any, any, any, any, any>>(readable: Readable, prefix?: string) => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-/**
- * Alias for {@link ReadableController} — use with view-backed controllers.
- *
- * @example
- * ```ts
- * ‎@ViewController(activeTasksView)
- * export class ActiveTasksController extends AsDbReadableController<typeof ActiveTasks> {}
- * ```
- */
-declare const ViewController: <Readable extends AtscriptDbReadable<any, any, any, any, any, any, any>>(readable: Readable, prefix?: string) => MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-//#endregion
-//#region src/validation-interceptor.d.ts
-declare const validationErrorTransform: () => import("moost").TInterceptorDef;
-declare const UseValidationErrorTransform: () => ClassDecorator & MethodDecorator;
-//#endregion
 //#region src/actions/types.d.ts
 /** `'rows'`-level batch policy — controls whether failing rows reject or are filtered out. */
 type TOnDisabledRows = "reject" | "skip";
@@ -719,6 +658,287 @@ type EntryRequiredFields<E, TRow> = E extends {
 type ValidatedDict<TRow, D extends DbActionsDictBase> = { [K in keyof D]: TDbActionsEntry<TRow, EntryRequiredFields<D[K], TRow>> };
 type ValidatedUnpinnedDict<TRow, D extends DbActionsDictBase> = { [K in keyof D]: TDbActionsEntryUnpinned<TRow, EntryRequiredFields<D[K], TRow>> };
 //#endregion
+//#region src/actions/keys.d.ts
+type TDbActionRowMarker = true;
+/** Stamped by `@InputForm(FormType)` — the compiled `.as` class + the wire name (`FormType.name`). */
+interface TDbActionInputFormMeta {
+  type: TAtscriptAnnotatedType;
+  name: string;
+}
+/** Method-level action metadata written by `@DbAction(name, opts)`. */
+interface TDbActionMeta {
+  name: string;
+  opts: DbActionOpts;
+}
+/** Class-level entry — a `TDbActionsEntry` plus its dictionary key. */
+interface TDbClassActionMeta {
+  name: string;
+  entry: TDbActionsEntry;
+}
+/** Param marker kind — informs level inference and ID-resolution shape. */
+type TDbActionParamKind = "id" | "ids";
+declare module "moost" {
+  interface TMoostMetadata {
+    atscript_db_action?: TDbActionMeta;
+    atscript_db_actions?: TDbClassActionMeta[];
+    atscript_db_action_param?: TDbActionParamKind;
+    atscript_db_action_row?: TDbActionRowMarker;
+    atscript_db_action_rows?: TDbActionRowMarker;
+  }
+  interface TMoostParamsMetadata {
+    atscript_db_action_param?: TDbActionParamKind;
+    atscript_db_action_row?: TDbActionRowMarker;
+    atscript_db_action_rows?: TDbActionRowMarker;
+    atscript_db_action_input_form?: TDbActionInputFormMeta;
+    atscript_type?: TAtscriptAnnotatedType;
+  }
+}
+//#endregion
+//#region src/mate.d.ts
+/**
+ * Class-level readable-binding descriptor written by `@TableController` /
+ * `@ReadableController` / `@ViewController`. One uniform `resolve()` backs
+ * both the DI provide factory and the base controller's
+ * `super(undefined, app)` fallback; `model` additionally feeds
+ * `assertExposed()`.
+ */
+interface TReadableBindingMeta {
+  /**
+   * The bound model token. Present for the token form (the token itself) and
+   * the instance form (`readable.type`); unknown for lazy factories until
+   * resolved.
+   */
+  model?: TAtscriptAnnotatedType;
+  /** Resolves the readable — lazily for token/factory, identity for instance. */
+  resolve: () => AtscriptDbReadable<any>;
+}
+/**
+ * Class- and method-level metadata written by `@atscript/moost-db`'s
+ * decorators (`@DbAction`, `@DbActionDefault`, `@DbActions`,
+ * `@DbTableActions`, `@DbRowActions`, `@DbRowsActions`).
+ *
+ * The keys are intentionally kept identical to the underlying
+ * mate-storage keys (`atscript_db_*`) so the same shape applies whether
+ * the consumer reads via {@link getAtscriptDbMate} or pokes the raw
+ * `getMoostMate()` instance directly. End-users never need to type the
+ * magic strings — `mate.read(...)?.atscript_db_action` is fully typed.
+ */
+interface AtscriptDbMeta {
+  /** Method-level — written by `@DbAction(name, opts)` / `@DbActionDefault()`. */
+  atscript_db_action?: TDbActionMeta;
+  /** Class-level — written by `@DbActions` and the level-pinned shortcuts. Decorators accumulate into the array. */
+  atscript_db_actions?: TDbClassActionMeta[];
+  /** Param-level marker — written by `@DbActionID()` / `@DbActionIDs()`. Drives action-level inference. */
+  atscript_db_action_param?: TDbActionParamKind;
+  /** Param-level marker — written by `@DbActionRow()`. */
+  atscript_db_action_row?: true;
+  /** Param-level marker — written by `@DbActionRows()`. */
+  atscript_db_action_rows?: true;
+  /** Class-level — written by `@TableController` / `@ReadableController` / `@ViewController`. */
+  atscript_db_readable_binding?: TReadableBindingMeta;
+}
+/**
+ * Param-level metadata written by `@atscript/moost-db`'s param
+ * decorators. A superset of {@link AtscriptDbMeta}'s param-level keys
+ * plus the `@InputForm()`-specific entries.
+ */
+interface AtscriptDbParamsMeta {
+  /** Param-level — written by `@DbActionID()` / `@DbActionIDs()`. */
+  atscript_db_action_param?: TDbActionParamKind;
+  /** Param-level marker — written by `@DbActionRow()`. */
+  atscript_db_action_row?: true;
+  /** Param-level marker — written by `@DbActionRows()`. */
+  atscript_db_action_rows?: true;
+  /**
+   * Param-level — written by `@InputForm(FormType)`. Carries the
+   * compiled `.as` class plus its `.name` so `discoverActions` can both
+   * emit `inputForm` on `/meta` and register the type in the controller's
+   * form registry for `GET /meta/form/:name`.
+   */
+  atscript_db_action_input_form?: TDbActionInputFormMeta;
+  /**
+   * Param-level — written by `@InputForm(FormType)` alongside
+   * `atscript_db_action_input_form`. Holds just the type ref so a generic
+   * atscript-aware Moost pipe (installed globally via
+   * `app.applyGlobalPipes(...)` or scoped via `@Pipe(...)`) can validate
+   * the resolved value without knowing about the moost-db-specific key.
+   */
+  atscript_type?: TAtscriptAnnotatedType;
+}
+/**
+ * The fully-typed {@link Mate} instance shared across the moost
+ * metadata workspace, narrowed to the keys that
+ * `@atscript/moost-db` writes.
+ *
+ * Class- and prop-meta storage mirror the same shape; param-meta
+ * storage uses {@link AtscriptDbParamsMeta}.
+ */
+type AtscriptDbMate = Mate<TMoostMetadata & AtscriptDbMeta & {
+  params: (TMateParamMeta & AtscriptDbParamsMeta)[];
+}, TMoostMetadata & AtscriptDbMeta & {
+  params: (TMateParamMeta & AtscriptDbParamsMeta)[];
+}>;
+/**
+ * Returns the shared moost-mate instance, typed against every key that
+ * `@atscript/moost-db` writes (see {@link AtscriptDbMeta} +
+ * {@link AtscriptDbParamsMeta}).
+ *
+ * Prefer this over `getMoostMate()` from `moost` whenever you need to
+ * read moost-db metadata — callers no longer have to retype the
+ * `atscript_db_*` magic strings or hand-cast the result.
+ *
+ * @example
+ * ```ts
+ * import { getAtscriptDbMate } from "@atscript/moost-db";
+ *
+ * const mate = getAtscriptDbMate();
+ * const meta = mate.read(controllerCtor.prototype, methodName);
+ * const dbAction = meta?.atscript_db_action;       // TDbActionMeta | undefined
+ * const inputForm = meta?.params?.[0]?.atscript_db_action_input_form;
+ * ```
+ */
+declare function getAtscriptDbMate(): AtscriptDbMate;
+//#endregion
+//#region src/decorators.d.ts
+/**
+ * DI token under which the {@link AtscriptDbReadable} instance
+ * is exposed to the readable controller's constructor via `@Inject`.
+ */
+declare const READABLE_DEF = "__atscript_db_readable_def";
+/**
+ * DI token under which the {@link AtscriptDbTable} instance
+ * is exposed to the controller's constructor via `@Inject`.
+ * Points to the same token as READABLE_DEF for backward compatibility.
+ */
+declare const TABLE_DEF = "__atscript_db_readable_def";
+/**
+ * Accepted binding forms for the controller decorators:
+ * - a readable **instance** (`db.getTable(Model)`) — resolved eagerly, legacy form;
+ * - a **lazy factory** (`() => db.getTable(Model)`) — resolved at first
+ *   controller instantiation (during `app.init()`), so the space may be
+ *   created after the controller module is imported;
+ * - a **model token** (the compiled `.as` class) — resolved at instantiation
+ *   against the ambient space registry (see `provideDbSpace`), honoring the
+ *   model's `@db.space` annotation unless overridden via `options.space`.
+ */
+type TReadableBinding<Readable> = Readable | (() => Readable) | TAtscriptAnnotatedType;
+/** Options bag accepted as the decorators' second argument (or a plain prefix string). */
+interface TControllerBindingOptions {
+  /** Route prefix override. Same meaning as the legacy string second argument. */
+  prefix?: string;
+  /**
+   * Space name for the model-token form — overrides the model's `@db.space`
+   * annotation. Ignored for instance/factory bindings.
+   */
+  space?: string;
+}
+/**
+ * Combines the boilerplate needed to turn an {@link AsDbController}
+ * subclass into a fully wired HTTP controller for a given `@db.table` model.
+ *
+ * Internally applies three decorators:
+ * 1. **Provide** — registers the readable resolver under {@link TABLE_DEF}.
+ * 2. **Controller** — registers the class as a Moost HTTP controller
+ *    with an optional route prefix (defaults to `@db.http.path`, then the
+ *    table name).
+ * 3. **Inherit** — copies metadata (routes, guards, etc.) from the
+ *    parent class so they stay active in the derived controller.
+ *
+ * All three binding forms are supported (see {@link TReadableBinding}):
+ *
+ * ```ts
+ * ‎@TableController(User)                      // model token (preferred)
+ * ‎@TableController(User, { space: "analytics" })
+ * ‎@TableController(() => db.getTable(User), "users") // lazy factory
+ * ‎@TableController(usersTable)                // instance (legacy)
+ * export class UsersController extends AsDbController<typeof User> {}
+ * ```
+ *
+ * Token and factory forms resolve lazily at first controller instantiation
+ * (during `app.init()`), so the `DbSpace` does not have to exist when the
+ * controller module is imported. For the token form, register the space with
+ * `provideDbSpace(db)` before `app.init()`.
+ *
+ * @param binding Model token, lazy factory, or {@link AtscriptDbTable} instance.
+ * @param prefixOrOptions Route prefix string, or {@link TControllerBindingOptions}.
+ */
+declare const TableController: <Table extends AtscriptDbTable<any, any, any, any, any, any, any>>(binding: TReadableBinding<Table>, prefixOrOptions?: string | TControllerBindingOptions) => ClassDecorator;
+/**
+ * Combines the boilerplate needed to turn an {@link AsDbReadableController}
+ * subclass into a fully wired HTTP controller for a given `@db.view` or `@db.table` model.
+ *
+ * Accepts the same three binding forms as {@link TableController}.
+ *
+ * @param binding Model token, lazy factory, or {@link AtscriptDbReadable} instance.
+ * @param prefixOrOptions Route prefix string, or {@link TControllerBindingOptions}.
+ *
+ * @example
+ * ```ts
+ * ‎@ReadableController(ActiveTasks)
+ * export class ActiveTasksController extends AsDbReadableController<typeof ActiveTasks> {}
+ * ```
+ */
+declare const ReadableController: <Readable extends AtscriptDbReadable<any, any, any, any, any, any, any>>(binding: TReadableBinding<Readable>, prefixOrOptions?: string | TControllerBindingOptions) => ClassDecorator;
+/**
+ * Alias for {@link ReadableController} — use with view-backed controllers.
+ *
+ * @example
+ * ```ts
+ * ‎@ViewController(ActiveTasks)
+ * export class ActiveTasksController extends AsDbReadableController<typeof ActiveTasks> {}
+ * ```
+ */
+declare const ViewController: <Readable extends AtscriptDbReadable<any, any, any, any, any, any, any>>(binding: TReadableBinding<Readable>, prefixOrOptions?: string | TControllerBindingOptions) => ClassDecorator;
+/**
+ * Finds the readable binding written by `@TableController` /
+ * `@ReadableController` / `@ViewController` on a controller class, walking the
+ * prototype chain so intermediate undecorated classes don't hide the binding
+ * (nearest decorated ancestor wins).
+ */
+declare function findReadableBinding(ctor: Function | undefined): TReadableBindingMeta | undefined;
+/**
+ * Resolves the readable bound to a controller class via
+ * {@link findReadableBinding}, throwing with wiring guidance when none is
+ * found.
+ *
+ * Used by {@link AsDbReadableController}'s constructor when `readable` is
+ * `undefined` — i.e. a subclass with its own constructor called
+ * `super(undefined, app)` instead of forwarding an injected instance.
+ */
+declare function resolveBoundReadable(ctor: Function | undefined): AtscriptDbReadable<any>;
+//#endregion
+//#region src/assert-exposed.d.ts
+/** Minimal logger surface for {@link assertExposed}. */
+interface TAssertExposedOptions {
+  logger?: {
+    warn: (...args: unknown[]) => void;
+  };
+}
+/**
+ * Dev-mode wiring assertion: warns for every model annotated with
+ * `@db.http.path` that has no registered db controller.
+ *
+ * Call AFTER `await app.init()` (controller bindings are collected during
+ * init). Detection reads the binding metadata written by `@TableController` /
+ * `@ReadableController` / `@ViewController`, so it covers the model-token and
+ * instance forms; lazy-factory bindings can't name their model until resolved
+ * and are ignored.
+ *
+ * Returns the list of unexposed models so callers can escalate (e.g. throw in
+ * CI):
+ *
+ * ```ts
+ * await app.init()
+ * const missing = assertExposed(app, atscriptModels)
+ * if (missing.length && process.env.CI) throw new Error("unexposed models")
+ * ```
+ */
+declare function assertExposed(app: Moost, models: readonly TAtscriptAnnotatedType[], options?: TAssertExposedOptions): TAtscriptAnnotatedType[];
+//#endregion
+//#region src/validation-interceptor.d.ts
+declare const validationErrorTransform: () => import("moost").TInterceptorDef;
+declare const UseValidationErrorTransform: () => ClassDecorator & MethodDecorator;
+//#endregion
 //#region src/actions/db-action.decorator.d.ts
 /**
  * Mark a controller method as a database action surfaced via `/meta`. Writes
@@ -931,42 +1151,6 @@ declare const useDbActionInput: import("@wooksjs/event-core").WookComposable<{
   load: () => Promise<unknown>;
 }>;
 //#endregion
-//#region src/actions/keys.d.ts
-type TDbActionRowMarker = true;
-/** Stamped by `@InputForm(FormType)` — the compiled `.as` class + the wire name (`FormType.name`). */
-interface TDbActionInputFormMeta {
-  type: TAtscriptAnnotatedType;
-  name: string;
-}
-/** Method-level action metadata written by `@DbAction(name, opts)`. */
-interface TDbActionMeta {
-  name: string;
-  opts: DbActionOpts;
-}
-/** Class-level entry — a `TDbActionsEntry` plus its dictionary key. */
-interface TDbClassActionMeta {
-  name: string;
-  entry: TDbActionsEntry;
-}
-/** Param marker kind — informs level inference and ID-resolution shape. */
-type TDbActionParamKind = "id" | "ids";
-declare module "moost" {
-  interface TMoostMetadata {
-    atscript_db_action?: TDbActionMeta;
-    atscript_db_actions?: TDbClassActionMeta[];
-    atscript_db_action_param?: TDbActionParamKind;
-    atscript_db_action_row?: TDbActionRowMarker;
-    atscript_db_action_rows?: TDbActionRowMarker;
-  }
-  interface TMoostParamsMetadata {
-    atscript_db_action_param?: TDbActionParamKind;
-    atscript_db_action_row?: TDbActionRowMarker;
-    atscript_db_action_rows?: TDbActionRowMarker;
-    atscript_db_action_input_form?: TDbActionInputFormMeta;
-    atscript_type?: TAtscriptAnnotatedType;
-  }
-}
-//#endregion
 //#region src/actions/action-disabled-error.d.ts
 /**
  * Wire-body shape for server-side gate rejections. The `name` discriminator
@@ -1022,95 +1206,9 @@ declare class ActionDisabledError extends HttpError<ActionDisabledErrorBody> {
  */
 declare const perRow: <TRow>(fn: (row: TRow) => boolean) => (rows: TRow[]) => boolean[];
 //#endregion
-//#region src/mate.d.ts
-/**
- * Class- and method-level metadata written by `@atscript/moost-db`'s
- * decorators (`@DbAction`, `@DbActionDefault`, `@DbActions`,
- * `@DbTableActions`, `@DbRowActions`, `@DbRowsActions`).
- *
- * The keys are intentionally kept identical to the underlying
- * mate-storage keys (`atscript_db_*`) so the same shape applies whether
- * the consumer reads via {@link getAtscriptDbMate} or pokes the raw
- * `getMoostMate()` instance directly. End-users never need to type the
- * magic strings — `mate.read(...)?.atscript_db_action` is fully typed.
- */
-interface AtscriptDbMeta {
-  /** Method-level — written by `@DbAction(name, opts)` / `@DbActionDefault()`. */
-  atscript_db_action?: TDbActionMeta;
-  /** Class-level — written by `@DbActions` and the level-pinned shortcuts. Decorators accumulate into the array. */
-  atscript_db_actions?: TDbClassActionMeta[];
-  /** Param-level marker — written by `@DbActionID()` / `@DbActionIDs()`. Drives action-level inference. */
-  atscript_db_action_param?: TDbActionParamKind;
-  /** Param-level marker — written by `@DbActionRow()`. */
-  atscript_db_action_row?: true;
-  /** Param-level marker — written by `@DbActionRows()`. */
-  atscript_db_action_rows?: true;
-}
-/**
- * Param-level metadata written by `@atscript/moost-db`'s param
- * decorators. A superset of {@link AtscriptDbMeta}'s param-level keys
- * plus the `@InputForm()`-specific entries.
- */
-interface AtscriptDbParamsMeta {
-  /** Param-level — written by `@DbActionID()` / `@DbActionIDs()`. */
-  atscript_db_action_param?: TDbActionParamKind;
-  /** Param-level marker — written by `@DbActionRow()`. */
-  atscript_db_action_row?: true;
-  /** Param-level marker — written by `@DbActionRows()`. */
-  atscript_db_action_rows?: true;
-  /**
-   * Param-level — written by `@InputForm(FormType)`. Carries the
-   * compiled `.as` class plus its `.name` so `discoverActions` can both
-   * emit `inputForm` on `/meta` and register the type in the controller's
-   * form registry for `GET /meta/form/:name`.
-   */
-  atscript_db_action_input_form?: TDbActionInputFormMeta;
-  /**
-   * Param-level — written by `@InputForm(FormType)` alongside
-   * `atscript_db_action_input_form`. Holds just the type ref so a generic
-   * atscript-aware Moost pipe (installed globally via
-   * `app.applyGlobalPipes(...)` or scoped via `@Pipe(...)`) can validate
-   * the resolved value without knowing about the moost-db-specific key.
-   */
-  atscript_type?: TAtscriptAnnotatedType;
-}
-/**
- * The fully-typed {@link Mate} instance shared across the moost
- * metadata workspace, narrowed to the keys that
- * `@atscript/moost-db` writes.
- *
- * Class- and prop-meta storage mirror the same shape; param-meta
- * storage uses {@link AtscriptDbParamsMeta}.
- */
-type AtscriptDbMate = Mate<TMoostMetadata & AtscriptDbMeta & {
-  params: (TMateParamMeta & AtscriptDbParamsMeta)[];
-}, TMoostMetadata & AtscriptDbMeta & {
-  params: (TMateParamMeta & AtscriptDbParamsMeta)[];
-}>;
-/**
- * Returns the shared moost-mate instance, typed against every key that
- * `@atscript/moost-db` writes (see {@link AtscriptDbMeta} +
- * {@link AtscriptDbParamsMeta}).
- *
- * Prefer this over `getMoostMate()` from `moost` whenever you need to
- * read moost-db metadata — callers no longer have to retype the
- * `atscript_db_*` magic strings or hand-cast the result.
- *
- * @example
- * ```ts
- * import { getAtscriptDbMate } from "@atscript/moost-db";
- *
- * const mate = getAtscriptDbMate();
- * const meta = mate.read(controllerCtor.prototype, methodName);
- * const dbAction = meta?.atscript_db_action;       // TDbActionMeta | undefined
- * const inputForm = meta?.params?.[0]?.atscript_db_action_input_form;
- * ```
- */
-declare function getAtscriptDbMate(): AtscriptDbMate;
-//#endregion
 //#region src/permissions/crud-controls.d.ts
 declare const QUERY_CONTROLS: readonly string[];
 declare const PAGES_CONTROLS: readonly string[];
 declare const ONE_CONTROLS: readonly string[];
 //#endregion
-export { ActionDisabledError, type ActionDisabledErrorBody, AsDbController, AsDbReadableController, AsJsonValueHelpController, AsReadableController, AsValueHelpController, type AtscriptDbMate, type AtscriptDbMeta, type AtscriptDbParamsMeta, DbAction, DbActionDefault, type DbActionEnvelope, DbActionID, DbActionIDs, type DbActionOpts, DbActionRow, DbActionRows, DbActions, DbRowActions, DbRowsActions, DbTableActions, type IdValidationSource, InputForm, ONE_CONTROLS, PAGES_CONTROLS, QUERY_CONTROLS, READABLE_DEF, ReadableController, ReadableGates, TABLE_DEF, type TCrudOp, type TCrudPermissions, type TDbActionInfo, type TDbActionInputFormMeta, type TDbActionIntent, type TDbActionLevel, type TDbActionMeta, type TDbActionParamKind, type TDbActionProcessor, type TDbActionsEntry, type TDbActionsEntryUnpinned, type TDbClassActionMeta, TableController, UseValidationErrorTransform, ValueHelpQuery, ViewController, dbActionBodySlot, dbActionInputSlot, discoverActions, getAtscriptDbMate, getControllerFormType, perRow, useDbActionId, useDbActionIds, useDbActionInput, useDbActionRow, useDbActionRows, validationErrorTransform };
+export { ActionDisabledError, type ActionDisabledErrorBody, AsDbController, AsDbReadableController, AsJsonValueHelpController, AsReadableController, AsValueHelpController, type AtscriptDbMate, type AtscriptDbMeta, type AtscriptDbParamsMeta, DEFAULT_DB_SPACE, DbAction, DbActionDefault, type DbActionEnvelope, DbActionID, DbActionIDs, type DbActionOpts, DbActionRow, DbActionRows, DbActions, DbRowActions, DbRowsActions, DbTableActions, type IdValidationSource, InputForm, ONE_CONTROLS, PAGES_CONTROLS, QUERY_CONTROLS, READABLE_DEF, ReadableController, ReadableGates, TABLE_DEF, TAssertExposedOptions, TControllerBindingOptions, type TCrudOp, type TCrudPermissions, type TDbActionInfo, type TDbActionInputFormMeta, type TDbActionIntent, type TDbActionLevel, type TDbActionMeta, type TDbActionParamKind, type TDbActionProcessor, type TDbActionsEntry, type TDbActionsEntryUnpinned, type TDbClassActionMeta, TReadableBinding, type TReadableBindingMeta, TableController, UseValidationErrorTransform, ValueHelpQuery, ViewController, assertExposed, clearDbSpaces, dbActionBodySlot, dbActionInputSlot, discoverActions, findReadableBinding, getAtscriptDbMate, getControllerFormType, perRow, provideDbSpace, resolveBoundReadable, resolveDbSpace, useDbActionId, useDbActionIds, useDbActionInput, useDbActionRow, useDbActionRows, validationErrorTransform };