@atscript/moost-db 0.1.148 → 0.1.150

package/dist/index.d.cts

@@ -6,6 +6,12 @@ import { Mate, Moost, TConsoleBase, TMateParamMeta, TMoostMetadata } from "moost
 import { parseUrl } from "@uniqu/url";
 import { EventContext } from "@wooksjs/event-core";
 
+//#region src/http-path.d.ts
+/** The published path of every model one app serves (`null`: mounted, published nowhere). */
+interface THttpPathScope {
+  readonly paths: ReadonlyMap<TAtscriptAnnotatedType, string | null>;
+}
+//#endregion
 //#region src/as-readable.controller.d.ts
 /**
  * Endpoint a {@link AsReadableController.prepareRequest} call serves. `/one`
@@ -89,8 +95,9 @@ interface TDbParsedRequest {
  * Abstract base class for read-only HTTP controllers over an Atscript interface.
  *
  * Shared responsibilities (implemented here):
- * - Stamps `@db.http.path` on the bound interface's metadata at registration
- *   with the final public path (leading slash + Moost `globalPrefix`).
+ * - Publishes `@db.http.path` (the model's value-help URL) per app after
+ *   `app.init()`, derived from each controller's own bound route (see
+ *   `docs/http/index.md`); the constructor only records which model it serves.
  * - Lazily serializes the bound interface for the `/meta` endpoint
  *   (see {@link getSerializeOptions}).
  * - Provides DTO-backed validators for the Uniquery controls DTOs and the
@@ -120,23 +127,44 @@ declare abstract class AsReadableController<T extends TAtscriptAnnotatedType = T
   protected app: Moost;
   /** Cached serialized type definition (lazy, computed on first access). */
   private _serializedType?;
+  /** App scope every cache below was built for; a different scope drops them all ({@link enterScope}). */
+  private _cacheScope?;
+  /** Scope of the synchronous build in flight — instance-local, cleared in `finally`. */
+  protected _buildScope?: THttpPathScope;
   /** Cached full meta response (computed lazily on first meta() call). */
   private _metaResponse?;
   /** {@link metaCacheKey} the cached response was built for. */
   private _metaResponseKey?;
   /** Cached serialized form schemas keyed by `FormType.name` — populated lazily by {@link metaForm}. */
   private _formSchemas;
-  constructor(boundType: T, controllerName: string, app: Moost, kindTag?: string);
+  /**
+   * @param opts.canonical Multi-mount models only: marks (`true`) or excludes
+   *   (`false`) this controller as the model's published value-help route
+   *   (since 0.1.150). Decorator-bound controllers use the decorator option.
+   */
+  constructor(boundType: T, controllerName: string, app: Moost, kindTag?: string, opts?: {
+    canonical?: boolean;
+  });
   /**
    * Subclass contract: return `true` if `path` addresses a field that exists
    * AND is visible to the current request — see the DB controller's override
    * for the full list of positions that consult it.
    */
   protected abstract hasField(path: string): boolean;
-  /** Sets @db.http.path on the type metadata from the controller's computed prefix. */
-  private _resolveHttpPath;
-  /** Lazily serializes the bound type (after all controllers have set @db.http.path). */
+  /**
+   * The app of the current event, through DI — never the one this
+   * (singleton) instance was constructed in, which may be gone (a re-booted
+   * app, a hot reload). Outside an event it is {@link app}.
+   *
+   * @since 0.1.150
+   */
+  protected currentApp(): Promise<Moost>;
+  /** Lazily serializes the bound type (dropped with the other caches on a scope change). */
   protected getSerializedType(): TSerializedAnnotatedType;
+  /** Drops every scope-dependent cache when `scope` is not the one they were built for. */
+  private enterScope;
+  /** Runs a synchronous build with `scope`'s `db.http.path` overrides applied. */
+  private buildScoped;
   /**
    * Serializes a type for the meta surfaces (`/meta`, `/meta/form/:name`)
    * with {@link getSerializeOptions}, then re-points every reference chain to
@@ -145,6 +173,11 @@ declare abstract class AsReadableController<T extends TAtscriptAnnotatedType = T
    * serialize exactly as before.
    */
   protected serializeForMeta(type: TAtscriptAnnotatedType): TSerializedAnnotatedType;
+  /**
+   * {@link getSerializeOptions} plus the current build's per-app `db.http.path`
+   * overrides (a subclass's own `annotationOverrides` entry wins for the same key).
+   */
+  private _effectiveSerializeOptions;
   /**
    * One-time initialization hook. Override to seed data, register watchers, etc.
    */
@@ -282,6 +315,14 @@ declare abstract class AsReadableController<T extends TAtscriptAnnotatedType = T
    * response by principal.
    */
   meta(): Promise<TMetaResponse>;
+  /**
+   * The root of a controller's own `/meta` carries its own mount as
+   * `db.http.path` (a secondary mount answers with its own route; references to
+   * the model elsewhere carry the canonical one). Left alone for parametric
+   * mounts and when the serialize options strip the key. Never mutates the
+   * cached envelope.
+   */
+  private _withOwnHttpPath;
   /**
    * The `/meta` payload for the current request — the cached envelope
    * through {@link applyMetaOverlay} — WITHOUT the `/meta` route's
@@ -385,6 +426,12 @@ type TDbQueryTargetOpts = boolean | {
  * registered symbol, like `ACTION_OVERLAY`).
  */
 declare const RESOLVE_TARGET: unique symbol;
+/**
+ * `q` of {@link AsDbReadableController.resolveQuery}: a `GET /query` string, or a
+ * query-target envelope without `dryRun`.
+ * @since 0.1.149
+ */
+type TDbResolveQueryInput = string | Omit<TDbActionQueryTarget, "dryRun">;
 /** What {@link RESOLVE_TARGET} resolves. */
 interface TTargetRequest {
   action: string;
@@ -400,6 +447,8 @@ interface TTargetRequest {
    * rows); `"read"` — `transformFilter` (a view resolving rows it delegates).
    */
   overlay: "action" | "read";
+  /** Identity fields to report the READ-visible subset of ({@link TResolvedTarget.visibleOf}). */
+  visibleOf?: readonly string[];
   /** Fields of the phase-1 read (sorted by the first identification's fields). */
   select: readonly string[];
   /** Key sets `exclude` entries may use besides the controller's identifications. */
@@ -414,6 +463,8 @@ interface TResolvedTarget {
   dryRun: boolean;
   /** The validated `exclude` entries (already applied to {@link rows}). */
   exclude: Record<string, unknown>[];
+  /** {@link TTargetRequest.visibleOf} filtered by the read's field visibility. */
+  visibleOf?: readonly string[];
   /**
    * The rows `ids` address that STILL match the target (filter, search,
    * overlay, `queryTargetScope`, `exclude`), aligned with `ids`; `select`
@@ -940,6 +991,15 @@ declare class FieldCapabilityIndex implements TQueryPathSource {
 }
 //#endregion
 //#region src/as-db-readable.controller.d.ts
+/** Options of {@link AsDbReadableController.resolveQuery}. @since 0.1.149 */
+interface TDbResolveQueryOpts<K extends string = string> {
+  /** Fields to return besides the identity. Gated like `/query` `$select` under `hasField`. */
+  select?: readonly K[];
+  /** Most rows (default 1000); `q.maxRows` can only lower it. */
+  cap?: number;
+  /** Server-side restriction, ANDed in. Trusted: not gated, not shown to `prepareRequest`. */
+  scope?: FilterExpr;
+}
 /** Read endpoint a {@link AsDbReadableController.decorateRows} call serves. */
 type TDbDecorateEndpoint = "query" | "pages" | "geo" | "one";
 /**
@@ -1168,7 +1228,9 @@ declare class AsDbReadableController<T extends TAtscriptAnnotatedType = TAtscrip
    * (`$vector`) or a geo index (`/geo`, `$index`) reading a hidden path
    * answers exactly like a nonexistent index (400); a hidden DEFAULT text
    * index falls back to the `@db.column.searchable` substring search over
-   * visible fields (or ignores the term when there are none). A
+   * visible fields (or ignores the term when there are none — on list
+   * endpoints; query targets, delegated targets and {@link resolveQuery}
+   * answer 400 `TARGET_INVALID` instead). A
    * `@db.column.derived` field is visible only while its source path is,
    * and one whose source is hidden is sealed out of every read projection
    * for the request, like a `@db.writeOnly` field. The same holds for a
@@ -1281,6 +1343,11 @@ declare class AsDbReadableController<T extends TAtscriptAnnotatedType = TAtscrip
   private _searchIndexFieldPaths;
   /** `@db.index.geo` indexes — their fields carry physical names, mapped back to logical paths. */
   private _geoIndexFieldPaths;
+  /**
+   * The index visibility gate applies: {@link hasField} is overridden, or the
+   * model has `@db.writeOnly` fields (never readable through a search hit).
+   */
+  private get _indexGateActive();
   /** Every path `entry` reads is visible to this request. */
   private _indexVisible;
   /**
@@ -1451,6 +1518,8 @@ declare class AsDbReadableController<T extends TAtscriptAnnotatedType = TAtscrip
    * {@link checkCapabilities}, {@link hasField}), where the client
    * predicates' {@link transformRelationFilter} also runs: a query target
    * never filters on, nor counts by, a field the caller can't read.
+   * {@link resolveQuery} does not call it (there is no action of this
+   * controller to scope).
    *
    * @since 0.1.147
    */
@@ -1567,12 +1636,55 @@ declare class AsDbReadableController<T extends TAtscriptAnnotatedType = TAtscrip
    * the first batch, which directly follows the snapshot.
    */
   [RESOLVE_TARGET](req: TTargetRequest): Promise<TResolvedTarget>;
+  /**
+   * The shared resolver behind query targets and {@link resolveQuery}: the
+   * query body validated, checked and run as a READ of this controller, then
+   * ONE read of `select` ordered by `sort` — `filter (+ $search) ∧ overlay ∧
+   * scope ∧ ¬exclude`, at most `cap + 1` rows. More than `cap` → 400
+   * `TARGET_TOO_LARGE`; a count other than `expectCount` → 409
+   * `TARGET_CHANGED`.
+   *
+   * Everything that depends on the read's visibility — the `$search`
+   * fallback, the native-search memo, the un-appliable-term refusal and the
+   * delegated identity — is computed INSIDE the read child, where the
+   * permission layer's per-request state is the read's.
+   */
+  private _resolveMatching;
+  /**
+   * Rows of THIS controller matching `q`, resolved as a READ of it for the
+   * current event's caller (since 0.1.149) — from your own command, e.g. to
+   * act on "every issue matching this search". `q` is a `GET /query` string
+   * (`$search` / `$index` and a filter only) or a query-target envelope
+   * `{ q, exclude?, expectCount?, maxRows? }` (no `dryRun`).
+   *
+   * The read runs under this controller's full read policy
+   * ({@link prepareRequest} with `endpoint: "query"`, {@link hasField},
+   * {@link validateControls}, the capability / index gate and the
+   * {@link transformFilter} overlay) with the current event's identity.
+   * Route interceptors and guards of the `query` route do not run; read
+   * authorization belongs in {@link prepareRequest}. {@link queryTargetScope}
+   * is not called. Hooks see no route params of the caller (only a call from
+   * the routed event's own controller instance keeps its params); pass route-derived
+   * restrictions as `opts.scope`. Joins the caller's open transaction.
+   *
+   * Rows are ordered by identity (`preferredId`, else the primary key) and
+   * carry the identity fields plus `opts.select` (gated like `/query`
+   * `$select`; `transformProjection` is not applied — hide fields with
+   * {@link hasField}; decoration keys and navigation paths are refused). An
+   * identity-less readable is ordered by `select` (each path sortable, else
+   * `TARGET_INVALID`). More than `opts.cap` (default 1000) rows → 400
+   * `TARGET_TOO_LARGE`; a count other than `expectCount` → 409
+   * `TARGET_CHANGED`; a `$search` that can't be applied → 400
+   * `TARGET_INVALID`. Must be awaited inside a running event handler.
+   */
+  resolveQuery<K extends string = never>(q: TDbResolveQueryInput, opts?: TDbResolveQueryOpts<K>): Promise<Array<Pick<DataType, K & keyof DataType> & Record<string, unknown>>>;
   /**
    * Runs `fn` as a READ of this controller (since 0.1.147): in a child of
    * the current event whose controller context is this controller's `query`
    * handler, after `prepareRequest({ endpoint: "query", controls, filter })` — the
    * request-scoped state a permission layer builds there (read grant, field
-   * visibility) is the read's and stays in the child.
+   * visibility) is the read's and stays in the child. `routeParams` (since
+   * 0.1.149) replaces the route params the child's hooks read.
    */
   private _asRead;
   /**
@@ -1598,7 +1710,18 @@ declare class AsDbReadableController<T extends TAtscriptAnnotatedType = TAtscrip
    * with the existing filter. Applies only when native search does not serve
    * the request (no native search, or — since 0.1.143 — its default index
    * reads a field {@link hasField} hides) and the request isn't a vector
-   * search (`$vector` consumes the term).
+   * search (`$vector` consumes the term). Lenient on list endpoints: a term
+   * nothing can apply is ignored. Resolvers (query targets, `resolveQuery`)
+   * refuse it — a subclass override that applies the term must return a new
+   * filter object.
+   *
+   * A string field matches when the term is a substring of its text; an
+   * INTEGER field (`number.int` and its sizes, `@expect.int`,
+   * `@db.default.increment`) when it is a substring of the number's decimal
+   * text — `2946` finds `29461277` (since 0.1.150). To search numeric IDs
+   * declare `@db.column.searchable` (fallback) or `@db.index.fulltext`
+   * (native, exact number) on the integer field — override this hook only for
+   * search rules the annotations cannot express.
    */
   protected applySearchFallback(filter: FilterExpr | undefined, controls: Record<string, unknown>): FilterExpr | undefined;
   /**
@@ -1621,6 +1744,21 @@ declare class AsDbReadableController<T extends TAtscriptAnnotatedType = TAtscrip
    * the same shape as the one this whole path exists to remove.
    */
   private _aggregateControls;
+  /**
+   * `$count` of a native text / vector search: the adapter's own count, so it
+   * agrees with `/query` and `/pages`. A text search counts every match (the
+   * single returned row is discarded); a vector search counts the nearest
+   * neighbours up to `$limit` (default 1000), as `/query` returns them.
+   */
+  private _countSearched;
+  /**
+   * The controls a native search / vector read is run with: the request's
+   * sealed controls (so every search control — `$fuzzy`, … — reaches the
+   * adapter) plus the select, the threshold and the caller's paging. ONE
+   * builder for `/query`, `/pages` and the native `$count`, so they can't
+   * disagree about what a search matches.
+   */
+  private _searchReadControls;
   private _resolveReadStrategy;
   /**
    * Post-read row decoration hook. Not implemented by
@@ -1669,12 +1807,6 @@ declare class AsDbReadableController<T extends TAtscriptAnnotatedType = TAtscrip
    * when implemented.
    */
   private _augmentAndDecorate;
-  /**
-   * The app of the current event, through DI — never the one this
-   * (singleton) instance was constructed in, which may be gone (a re-booted
-   * app, a hot reload).
-   */
-  private _currentApp;
   /** The class's `@DbActionsFrom` delegations, validated on first use (per app). */
   private _delegations;
   /**
@@ -2143,7 +2275,8 @@ declare class AsDbController<T extends TAtscriptAnnotatedType = TAtscriptAnnotat
    * Bulk auto-lift: each item carries its own `version` → `$cas`.
    * NOTE: per-item conflict disambiguation in the response body is deferred
    * (§6.4) — the aggregate `{ matchedCount, modifiedCount }` surfaces partial
-   * application; callers can detect mismatches via `modifiedCount < N`.
+   * application; callers can detect mismatches via `matchedCount < N` (`modifiedCount` may
+   * be lower for unchanged values, e.g. a version-exempt patch on MySQL / Mongo).
    */
   private _resolveBulkCas;
   /**
@@ -2275,7 +2408,9 @@ declare abstract class AsValueHelpController<T extends TAtscriptAnnotatedType =
   protected readonly searchableFields: readonly string[];
   /** The `@meta.id` field name on the bound interface, if any. */
   protected readonly primaryKey: string | undefined;
-  constructor(boundType: T, controllerName: string, app: Moost);
+  constructor(boundType: T, controllerName: string, app: Moost, opts?: {
+    canonical?: boolean;
+  });
   /** Executes a value-help query against the backing source. */
   protected abstract query(controls: ValueHelpQuery<DataType>): Promise<{
     data: DataType[];
@@ -2413,7 +2548,9 @@ declare abstract class AsValueHelpController<T extends TAtscriptAnnotatedType =
 declare class AsJsonValueHelpController<T extends TAtscriptAnnotatedType = TAtscriptAnnotatedType, DataType = TAtscriptDataType<T>> extends AsValueHelpController<T, DataType> {
   protected rows: DataType[];
   private _pkIndex?;
-  constructor(boundType: T, rows: DataType[], app: Moost, controllerName?: string);
+  constructor(boundType: T, rows: DataType[], app: Moost, controllerName?: string, opts?: {
+    canonical?: boolean;
+  });
   protected query(controls: ValueHelpQuery<DataType>): Promise<{
     data: DataType[];
     count: number;
@@ -2552,6 +2689,16 @@ interface TReadableBindingMeta {
   model?: TAtscriptAnnotatedType;
   /** Resolves the readable — lazily for token/factory, identity for instance. */
   resolve: () => AtscriptDbReadable<any>;
+  /** The route prefix the decorator derived (`options.prefix`, `@db.http.path`, table name, …). @since 0.1.150 */
+  prefix?: string;
+  /**
+   * Where {@link prefix} came from: the decorator's `prefix` option (or the
+   * factory form), the model's own `@db.http.path`, or its table / view name.
+   * @since 0.1.150
+   */
+  prefixSource?: "option" | "annotation" | "name";
+  /** The decorator's `canonical` option. @since 0.1.150 */
+  canonical?: boolean;
 }
 /**
  * Class- and method-level metadata written by `@atscript/moost-db`'s
@@ -2684,6 +2831,18 @@ interface TControllerBindingOptions {
    * annotation. Ignored for instance/factory bindings.
    */
   space?: string;
+  /**
+   * Marks (`true`) or excludes (`false`) this controller as the one whose route
+   * is published as the model's value-help path (`db.http.path`) when the same
+   * model is served by several controllers in one app. A single `canonical: true`
+   * mount wins; `canonical: false` mounts are never published; without a marker
+   * the model's own `@db.http.path`-derived mount breaks ties, and any remaining
+   * ambiguity leaves the path unset (with a boot warning). Parametric mounts
+   * (`:param` / `*` segments) are never published.
+   *
+   * @since 0.1.150
+   */
+  canonical?: boolean;
 }
 /**
  * Combines the boilerplate needed to turn an {@link AsDbController}
@@ -3419,4 +3578,4 @@ declare const REL_FILTER_CLIENT_MAX_DEPTH = 3;
  */
 declare const REL_FILTER_CLIENT_MAX_NODES = 8;
 //#endregion
-export { ActionDisabledError, type ActionDisabledErrorBody, ActionTargetError, type ActionTargetErrorBody, AsDbController, AsDbReadableController, AsJsonValueHelpController, AsReadableController, AsValueHelpController, type AtscriptDbMate, type AtscriptDbMeta, type AtscriptDbParamsMeta, DB_CRUD_HANDLERS, DEFAULT_DB_SPACE, DbAction, DbActionDefault, type DbActionEnvelope, DbActionID, DbActionIDs, type DbActionOpts, DbActionRow, DbActionRows, DbActionTarget, DbActions, DbActionsFrom, DbDecorations, DbRowActions, DbRowsActions, DbTableActions, FieldCapabilityIndex, type IdValidationSource, InputForm, ONE_CONTROLS, PAGES_CONTROLS, QUERY_CONTROLS, READABLE_DEF, REL_FILTER_CLIENT_MAX_DEPTH, REL_FILTER_CLIENT_MAX_NODES, ReadableController, TABLE_DEF, type TActionTargetErrorCode, TAssertExposedOptions, type TCapabilityReadable, type TCapabilityVerdict, TControllerBindingOptions, type TCrudOp, type TCrudPermissions, type TDbActionDisabledVerdict, type TDbActionEnvelope, type TDbActionInfo, type TDbActionInputFormMeta, type TDbActionIntent, type TDbActionLevel, type TDbActionMeta, type TDbActionParamKind, type TDbActionProcessor, type TDbActionQueryTarget, type TDbActionScopeContext, type TDbActionScopePurpose, type TDbActionTarget, type TDbActionTargetSummary, type TDbActionsEntry, type TDbActionsEntryUnpinned, type TDbActionsFromMeta, type TDbActionsFromOpts, type TDbAvailableActions, type TDbClassActionMeta, TDbControlsType, TDbDecorateContext, TDbDecorateEndpoint, type TDbDecorationsOpts, TDbFieldVisibility, TDbIndexFieldPaths, TDbParsedRequest, type TDbQueryTargetOpts, type TDbRemoveGuardContext, TDbRequestContext, TDbRequestEndpoint, type TDbRowIdInput, type TDbRowIdPurpose, type TDbRowIdsContext, type TDbWriteAction, type TDbWriteCheckContext, type TDbWriteGuardContext, type TFieldCapability, type TGateOp, type THttpErrorEntry, type TQueryPathOp, type TQueryPathRefs, TReadableBinding, type TReadableBindingMeta, type TTerminalRef, TableController, UseValidationErrorTransform, VALUE_HELP_CRUD_HANDLERS, ValueHelpQuery, ValueHelpSelect, ViewController, applyTerminalRefs, assertExposed, badRequest, clearDbSpaces, closeDbSpaces, collectQueryPaths, dbActionBodySlot, dbActionInputSlot, discoverActions, discoverRowLevelActions, errorEnvelope, findReadableBinding, getAtscriptDbMate, getControllerFormType, getDbEndpoint, hasActionDelegations, perRow, provideDbSpace, resolveBoundReadable, resolveDbSpace, resolveProp, resolveTerminalRef, unknownRelationError, useDbActionId, useDbActionIds, useDbActionInput, useDbActionRow, useDbActionRows, useDbActionTarget, validationErrorTransform };
+export { ActionDisabledError, type ActionDisabledErrorBody, ActionTargetError, type ActionTargetErrorBody, AsDbController, AsDbReadableController, AsJsonValueHelpController, AsReadableController, AsValueHelpController, type AtscriptDbMate, type AtscriptDbMeta, type AtscriptDbParamsMeta, DB_CRUD_HANDLERS, DEFAULT_DB_SPACE, DbAction, DbActionDefault, type DbActionEnvelope, DbActionID, DbActionIDs, type DbActionOpts, DbActionRow, DbActionRows, DbActionTarget, DbActions, DbActionsFrom, DbDecorations, DbRowActions, DbRowsActions, DbTableActions, FieldCapabilityIndex, type IdValidationSource, InputForm, ONE_CONTROLS, PAGES_CONTROLS, QUERY_CONTROLS, READABLE_DEF, REL_FILTER_CLIENT_MAX_DEPTH, REL_FILTER_CLIENT_MAX_NODES, ReadableController, TABLE_DEF, type TActionTargetErrorCode, TAssertExposedOptions, type TCapabilityReadable, type TCapabilityVerdict, TControllerBindingOptions, type TCrudOp, type TCrudPermissions, type TDbActionDisabledVerdict, type TDbActionEnvelope, type TDbActionInfo, type TDbActionInputFormMeta, type TDbActionIntent, type TDbActionLevel, type TDbActionMeta, type TDbActionParamKind, type TDbActionProcessor, type TDbActionQueryTarget, type TDbActionScopeContext, type TDbActionScopePurpose, type TDbActionTarget, type TDbActionTargetSummary, type TDbActionsEntry, type TDbActionsEntryUnpinned, type TDbActionsFromMeta, type TDbActionsFromOpts, type TDbAvailableActions, type TDbClassActionMeta, TDbControlsType, TDbDecorateContext, TDbDecorateEndpoint, type TDbDecorationsOpts, TDbFieldVisibility, TDbIndexFieldPaths, TDbParsedRequest, type TDbQueryTargetOpts, type TDbRemoveGuardContext, TDbRequestContext, TDbRequestEndpoint, type TDbResolveQueryInput, TDbResolveQueryOpts, type TDbRowIdInput, type TDbRowIdPurpose, type TDbRowIdsContext, type TDbWriteAction, type TDbWriteCheckContext, type TDbWriteGuardContext, type TFieldCapability, type TGateOp, type THttpErrorEntry, type TQueryPathOp, type TQueryPathRefs, TReadableBinding, type TReadableBindingMeta, type TTerminalRef, TableController, UseValidationErrorTransform, VALUE_HELP_CRUD_HANDLERS, ValueHelpQuery, ValueHelpSelect, ViewController, applyTerminalRefs, assertExposed, badRequest, clearDbSpaces, closeDbSpaces, collectQueryPaths, dbActionBodySlot, dbActionInputSlot, discoverActions, discoverRowLevelActions, errorEnvelope, findReadableBinding, getAtscriptDbMate, getControllerFormType, getDbEndpoint, hasActionDelegations, perRow, provideDbSpace, resolveBoundReadable, resolveDbSpace, resolveProp, resolveTerminalRef, unknownRelationError, useDbActionId, useDbActionIds, useDbActionInput, useDbActionRow, useDbActionRows, useDbActionTarget, validationErrorTransform };