@mintplayer/ng-spark 22.3.0 → 22.5.0

package/types/mintplayer-ng-spark-po-detail.d.ts

@@ -2,10 +2,7 @@ import * as _angular_core from '@angular/core';
 import { TemplateRef, Type } from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
 import { SparkLanguageService } from '@mintplayer/ng-spark/services';
-import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
-import { PersistentObject, EntityType, CustomActionDefinition, LookupReference, EntityAttributeDefinition, AttributeTab, AttributeGroup, SparkQuery } from '@mintplayer/ng-spark/models';
-import { HttpErrorResponse } from '@angular/common/http';
-import { DatatableSettings, BsDatatableFetch } from '@mintplayer/ng-bootstrap/datatable';
+import { PersistentObject, EntityType, CustomActionDefinition, LookupReference, EntityAttributeDefinition, AttributeTab, AttributeGroup } from '@mintplayer/ng-spark/models';
 
 declare class SparkPoDetailComponent {
     private readonly route;
@@ -20,6 +17,21 @@ declare class SparkPoDetailComponent {
         $implicit: PersistentObject;
         entityType: EntityType;
     }> | null>;
+    /**
+     * Header slots forwarded to every sub-query card on this page.
+     *
+     * A structural directive cannot cross a component boundary, and this component is created by
+     * the router — in a default app there is no `<spark-po-detail>` tag to project content into.
+     * So an app that wants slotted chrome on its sub-queries substitutes its own route component
+     * via `SparkRouteConfig.poDetail` and forwards the templates through here. Forwarding a
+     * `TemplateRef` as an input is already this component's idiom; see the two above.
+     *
+     * Each slot may target one query by alias, so a single forwarded set serves a page rendering
+     * several sub-queries.
+     */
+    queryIconTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    queryCaptionTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    queryActionsTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
     edited: _angular_core.OutputEmitterRef<void>;
     deleted: _angular_core.OutputEmitterRef<void>;
     customActionExecuted: _angular_core.OutputEmitterRef<{
@@ -59,140 +71,7 @@ declare class SparkPoDetailComponent {
     onDelete(): Promise<void>;
     onBack(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkPoDetailComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoDetailComponent, "spark-po-detail", never, { "showCustomActions": { "alias": "showCustomActions"; "required": false; "isSignal": true; }; "extraActionsTemplate": { "alias": "extraActionsTemplate"; "required": false; "isSignal": true; }; "extraContentTemplate": { "alias": "extraContentTemplate"; "required": false; "isSignal": true; }; }, { "edited": "edited"; "deleted": "deleted"; "customActionExecuted": "customActionExecuted"; }, never, never, true, never>;
-}
-
-declare class SparkSubQueryComponent {
-    private readonly sparkService;
-    private readonly gridRenderers;
-    readonly lang: SparkLanguageService;
-    queryId: _angular_core.InputSignal<string>;
-    /**
-     * The parent persistent object this query is scoped to, when it has one.
-     *
-     * Optional, because not every query is a detail of something: a page can host
-     * a grid that stands on its own — "my accounts", a dashboard list — and the
-     * server already treats an absent parent as "no parent" rather than as an
-     * error. Leaving these required made that shape impossible to express: the
-     * component simply never loaded, with no request, no error and no log.
-     *
-     * Pass both or neither. One without the other is ignored, matching
-     * `SparkService.executeQuery`, which omits either param when it is falsy, and
-     * the execute endpoint, which resolves a parent only when both are present.
-     */
-    parentId: _angular_core.InputSignal<string>;
-    parentType: _angular_core.InputSignal<string>;
-    /**
-     * Change this to re-run the query. Any value works; only its identity matters.
-     *
-     * A declarative token rather than only a `reload()` method, because calling a
-     * method means holding a component handle, and hosts wrap this grid in `@if`,
-     * where a `viewChild` is intermittently undefined. Nothing else in ng-spark
-     * uses `viewChild` either — the house idiom is to re-seed a signal.
-     *
-     * This drives the CHEAP refresh (see {@link reload}). It deliberately does not
-     * feed the main effect: re-running `loadData` would re-resolve the query, the
-     * entity types, the permissions and the lookups, and reset the user's page and
-     * sort on every button press.
-     */
-    reloadToken: _angular_core.InputSignal<unknown>;
-    /**
-     * Render without the surrounding card, for a host that owns its own chrome — a tab
-     * body, a modal, a dashboard tile.
-     *
-     * This is the escape hatch for a genuinely chromeless embed. It only serves a host
-     * that instantiated this component by hand — where the component is auto-rendered
-     * from `EntityTypeDefinition.Queries` there is no host to pass it.
-     */
-    showCard: _angular_core.InputSignal<boolean>;
-    /**
-     * Replace the header for one hand-instantiated usage.
-     *
-     * A `TemplateRef` rather than `<ng-content>` deliberately: it matches
-     * `spark-po-detail`'s `extraActionsTemplate`/`extraContentTemplate`, and unlike
-     * projection it can be forwarded by a host that is itself several layers up.
-     *
-     * Precedence is headerTemplate -> caption + query actions.
-     */
-    headerTemplate: _angular_core.InputSignal<TemplateRef<{
-        $implicit: SparkQuery;
-    }> | null>;
-    colors: typeof Color;
-    query: _angular_core.WritableSignal<SparkQuery | null>;
-    entityType: _angular_core.WritableSignal<EntityType | null>;
-    allEntityTypes: _angular_core.WritableSignal<EntityType[]>;
-    /**
-     * Why the component renders its own failure instead of only reporting one.
-     *
-     * `SparkService` is a bare `firstValueFrom` passthrough with no interceptor, so
-     * every failure surfaces here and nowhere else. A host embedding this grid cannot
-     * surface what it never sees, and the default has to be visible with no host
-     * cooperation — hence a rendered alert, not just an output.
-     *
-     * A 404 is deliberately vague. `Endpoints/Queries/Get.cs` answers 404 for BOTH
-     * "no such query" and "you may not see it", with byte-identical bodies, so that
-     * existence is not disclosed (security audit M-3). This component therefore
-     * genuinely cannot tell the two apart, and any message claiming otherwise would
-     * either leak or mislead.
-     */
-    errorMessage: _angular_core.WritableSignal<string | null>;
-    /**
-     * Actions the query declares, rendered in this component's own header.
-     *
-     * This is what makes a query's chrome work with no host: a sub-query is rendered
-     * automatically from `EntityTypeDefinition.Queries`, so there is nobody to project
-     * a toolbar in. The query says what belongs in its header, and it follows the query
-     * wherever it is rendered.
-     */
-    customActions: _angular_core.WritableSignal<CustomActionDefinition[]>;
-    /** Emitted whenever a load or a page fetch fails, for a host in bespoke chrome. */
-    error: _angular_core.OutputEmitterRef<HttpErrorResponse>;
-    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
-    loading: _angular_core.WritableSignal<boolean>;
-    canRead: _angular_core.WritableSignal<boolean>;
-    settings: _angular_core.WritableSignal<DatatableSettings>;
-    fetchFn: _angular_core.WritableSignal<BsDatatableFetch<PersistentObject> | null>;
-    /**
-     * Rows the user has ticked. Lives here rather than in the datatable so the action bar can
-     * read it, and MUST be cleared whenever the source changes — otherwise route A's selection
-     * is POSTed as ids of route B's type.
-     */
-    selection: _angular_core.WritableSignal<PersistentObject[]>;
-    private readonly queryRefresh;
-    /** 'none' unless an action is selection-gated, so unaffected grids gain no checkbox column. */
-    selectionMode: _angular_core.Signal<_mintplayer_ng_spark_models.SparkSelectionMode>;
-    /** Whether an action's selection rule is satisfied right now. The server checks it again. */
-    isActionEnabled(action: CustomActionDefinition): boolean;
-    isVirtualScrolling: _angular_core.Signal<boolean>;
-    visibleAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
-    constructor();
-    /**
-     * Re-run the query, keeping the current page, sort and scroll position.
-     *
-     * Data-level on purpose: it re-seeds the fetch closure and nothing else, mirroring
-     * `SparkQueryListComponent.reload()`. Use it after something mutates server-side
-     * state the query reads from. For a definition change — new columns, a renamed
-     * query — the inputs themselves must change; that is the expensive path.
-     */
-    onCustomAction(action: CustomActionDefinition): Promise<void>;
-    private reportError;
-    /**
-     * A 404 is deliberately generic.
-     *
-     * `Endpoints/Queries/Get.cs` answers 404 with byte-identical bodies for "no such
-     * query" and "you may not see it", so existence is not disclosed (audit M-3). The
-     * component therefore cannot tell them apart, and both "Not found" and "Access
-     * denied" would be a guess — one of them leaking, the other misleading.
-     */
-    private describe;
-    reload(): void;
-    private loadData;
-    private makeFetch;
-    private loadLookupReferenceOptions;
-    getColumnRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
-    getColumnRendererInputs(component: Type<any>, item: PersistentObject, attr: EntityAttributeDefinition): Record<string, any>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkSubQueryComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkSubQueryComponent, "spark-sub-query", never, { "queryId": { "alias": "queryId"; "required": true; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; "parentType": { "alias": "parentType"; "required": false; "isSignal": true; }; "reloadToken": { "alias": "reloadToken"; "required": false; "isSignal": true; }; "showCard": { "alias": "showCard"; "required": false; "isSignal": true; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; "isSignal": true; }; }, { "error": "error"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoDetailComponent, "spark-po-detail", never, { "showCustomActions": { "alias": "showCustomActions"; "required": false; "isSignal": true; }; "extraActionsTemplate": { "alias": "extraActionsTemplate"; "required": false; "isSignal": true; }; "extraContentTemplate": { "alias": "extraContentTemplate"; "required": false; "isSignal": true; }; "queryIconTemplate": { "alias": "queryIconTemplate"; "required": false; "isSignal": true; }; "queryCaptionTemplate": { "alias": "queryCaptionTemplate"; "required": false; "isSignal": true; }; "queryActionsTemplate": { "alias": "queryActionsTemplate"; "required": false; "isSignal": true; }; }, { "edited": "edited"; "deleted": "deleted"; "customActionExecuted": "customActionExecuted"; }, never, never, true, never>;
 }
 
-export { SparkPoDetailComponent, SparkSubQueryComponent };
+export { SparkPoDetailComponent };

package/types/mintplayer-ng-spark-po-form.d.ts

@@ -4,10 +4,58 @@ import { CdkDragDrop } from '@angular/cdk/drag-drop';
 import { Color } from '@mintplayer/ng-bootstrap';
 import { InMemoryTreeSelectProvider, TreeNode } from '@mintplayer/ng-bootstrap/tree-select';
 import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
-import { EntityType, ValidationError, PersistentObject, LookupReference, EntityAttributeDefinition, EntityPermissions, ELookupDisplayType, EReferenceDisplayType, AttributeTab, AttributeGroup, LookupReferenceValue } from '@mintplayer/ng-spark/models';
+import { PersistentObject, EntityType, ValidationError, RefreshOverlay, LookupReference, EntityAttributeDefinition, EntityPermissions, ELookupDisplayType, EReferenceDisplayType, AttributeTab, AttributeGroup, LookupReferenceValue, RuleFailure } from '@mintplayer/ng-spark/models';
 import { DatatableSettings } from '@mintplayer/ng-bootstrap/datatable';
 import { PaginationResponse } from '@mintplayer/pagination';
 
+/** What the coordinator needs from its host, so it can be tested without mounting a form. */
+interface RefreshCoordinatorHost {
+    /** POSTs the object and resolves with the reshaped one. */
+    send(triggeredBy: string): Promise<PersistentObject>;
+    /** Values as they are right now — read at dispatch time to snapshot what is being sent. */
+    currentValues(): Record<string, any>;
+    /** Applies a settled response. Not called for a superseded one. */
+    apply(response: PersistentObject, sent: Record<string, any>): void;
+    /** Surfaced so the host can show a busy affordance. Never used to disable fields. */
+    setBusy(busy: boolean): void;
+}
+/**
+ * Serializes refreshes for **one** form instance and drops superseded ones.
+ *
+ * Per-instance rather than a service, deliberately. The retry-action modal renders its own
+ * `spark-po-form`, and a refresh can carry a retry operation — so a refresh can open a modal
+ * containing a form whose own attributes may trigger refreshes. A shared coordinator would let the
+ * nested form resolve or supersede the outer form's pending request. The same applies to the
+ * recursive `spark-po-form` used for modal AsDetail editing.
+ *
+ * Cancellation is not available: the service layer is promise-based (`firstValueFrom`), so a stale
+ * response *will* arrive. It is discarded by sequence number rather than prevented.
+ */
+declare class RefreshCoordinator {
+    private readonly host;
+    private queue;
+    private sequence;
+    private settled;
+    private pending;
+    constructor(host: RefreshCoordinatorHost);
+    /** Whether a refresh is in flight. */
+    get isRefreshing(): boolean;
+    /**
+     * Marks `attributeName` as needing a refresh without sending one — for free-text editors, which
+     * would otherwise issue a request per keystroke. Flushed by {@link blur} or {@link flush}.
+     */
+    markPending(attributeName: string): void;
+    /** Sends a pending refresh for `attributeName`, if one was marked. */
+    blur(attributeName: string): Promise<void>;
+    /**
+     * Sends every refresh still marked pending. Called before save, so a value typed and never blurred
+     * — the user tabbing straight to the save button — is still reflected before the object goes.
+     */
+    flush(): Promise<void>;
+    /** Sends a refresh immediately — discrete editors, where every change is a committed one. */
+    trigger(attributeName: string): Promise<void>;
+}
+
 declare class SparkPoFormComponent {
     private readonly sparkService;
     private readonly translations;
@@ -21,6 +69,23 @@ declare class SparkPoFormComponent {
     parentType: _angular_core.InputSignal<string | undefined>;
     save: _angular_core.OutputEmitterRef<void>;
     cancel: _angular_core.OutputEmitterRef<void>;
+    /**
+     * The type id to refresh against. Absent means refresh is unavailable — the form still renders and
+     * edits normally, so a host that has not opted in loses nothing.
+     */
+    objectTypeId: _angular_core.InputSignal<string | undefined>;
+    /** The id of the object being edited; absent for a create. */
+    objectId: _angular_core.InputSignal<string | undefined>;
+    /**
+     * What the last refresh changed about each attribute's presentation, keyed by attribute name.
+     *
+     * Deliberately NOT folded back into `entityType`. All option loading hangs off one effect keyed on
+     * `entityType` identity and `SparkService` caches nothing, so re-setting it would re-issue every
+     * reference query and lookup fetch on every refresh; mutating it in place would not re-render at
+     * all.
+     */
+    refreshOverlay: _angular_core.WritableSignal<RefreshOverlay>;
+    isRefreshing: _angular_core.WritableSignal<boolean>;
     colors: typeof Color;
     referenceOptions: _angular_core.WritableSignal<Record<string, PersistentObject[]>>;
     referenceProviders: _angular_core.WritableSignal<Record<string, InMemoryTreeSelectProvider>>;
@@ -35,6 +100,15 @@ declare class SparkPoFormComponent {
     asDetailReferenceOptions: _angular_core.WritableSignal<Record<string, Record<string, PersistentObject[]>>>;
     ELookupDisplayType: typeof ELookupDisplayType;
     EReferenceDisplayType: typeof EReferenceDisplayType;
+    /**
+     * Every attribute this form could ever need option data for — including ones the model hides,
+     * because a refresh may reveal them.
+     *
+     * Read by the option-loading effect, and deliberately independent of `refreshOverlay`: the loaders
+     * read this synchronously, so an overlay dependency here would make every refresh re-issue every
+     * reference query and lookup fetch. That is the whole reason the overlay is a separate signal.
+     */
+    optionSourceAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
     editableAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
     private static readonly DEFAULT_TAB;
     ungroupedAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
@@ -66,12 +140,66 @@ declare class SparkPoFormComponent {
     /** Edit-renderer for an inline AsDetail cell (so inline editing honors `col.renderer`, not just display). */
     getAsDetailCellEditRenderer(col: EntityAttributeDefinition): Type<any> | null;
     getAsDetailCellEditRendererInputs(component: Type<any>, row: Record<string, any>, col: EntityAttributeDefinition): Record<string, any>;
+    /**
+     * Rules evaluated in the browser, against the *effective* metadata — so a rule a refresh hook
+     * imposed is visible before the round-trip rather than only after the server rejects the save.
+     */
+    clientRuleFailures: _angular_core.Signal<RuleFailure[]>;
     hasError(attrName: string): boolean;
     private inlineErrorPath;
     hasInlineError(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): boolean;
     inlineErrorMessage(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): string | null;
-    onFieldChange(): void;
-    onSave(): void;
+    /**
+     * The single funnel every scalar / boolean / inline-cell edit passes through.
+     *
+     * `attr` is optional only so the AsDetail modal's recursive form, which has no trigger context,
+     * can still call it. A caller that knows which attribute changed should always say so — without it
+     * no refresh can fire.
+     */
+    onFieldChange(attr?: EntityAttributeDefinition): void;
+    /**
+     * A trigger inside an AsDetail row. Addressed by the same `{attr}[{index}].{col}` path the inline
+     * validation errors already use, so the server can tell which row asked without a second
+     * addressing scheme being invented for it.
+     */
+    onInlineCellChange(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): void;
+    /** Which detail row the in-flight refresh belongs to, if any. */
+    private pendingNestedTrigger;
+    /**
+     * Applies a refresh that ran against a detail row: the row's own values, and the column metadata
+     * for the grid it lives in.
+     *
+     * The column metadata comes from `asDetailTypes` — a different signal from `entityType` — which is
+     * why a nested response cannot go through the top-level overlay.
+     *
+     * ⚠️ The row array is mutated in place rather than replaced. Rows are tracked by index, so handing
+     * the template a new array destroys and rebuilds every row's DOM and takes focus with it, mid-edit.
+     */
+    private applyNestedResponse;
+    onInlineCellBlur(attr: EntityAttributeDefinition, rowIndex: number, col: EntityAttributeDefinition): void;
+    /** Blur handler for free-text editors — sends the refresh their keystrokes only marked pending. */
+    onFieldBlur(attr: EntityAttributeDefinition): void;
+    private noteChange;
+    private canRefresh;
+    /**
+     * Per-instance, never a service: the retry-action modal renders its own `spark-po-form`, and a
+     * refresh may carry a retry operation — so a refresh can open a modal containing a form that
+     * refreshes. A shared coordinator would let the nested form supersede this one's request.
+     */
+    protected readonly refreshCoordinator: RefreshCoordinator;
+    private buildRefreshPayload;
+    /**
+     * Folds replaced option lists into the signals the editors already read, so a refreshed dropdown
+     * renders through the same path as a loaded one.
+     *
+     * `undefined` means the hook did not touch this attribute's options and the loaded set stands; an
+     * empty array means it deliberately left none. Collapsing the two would blank every dropdown the
+     * hook never mentioned.
+     */
+    private applyRefreshedOptions;
+    /** Sends anything still pending, so a typed-but-never-blurred trigger is reflected before save. */
+    flushPendingRefresh(): Promise<void>;
+    onSave(): Promise<void>;
     onCancel(): void;
     openAsDetailEditor(attr: EntityAttributeDefinition): void;
     saveAsDetailObject(): void;
@@ -82,7 +210,7 @@ declare class SparkPoFormComponent {
     removeArrayItem(attr: EntityAttributeDefinition, index: number): void;
     onAsDetailReorder(attr: EntityAttributeDefinition, event: CdkDragDrop<Record<string, any>[]>): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkPoFormComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoFormComponent, "spark-po-form", never, { "entityType": { "alias": "entityType"; "required": false; "isSignal": true; }; "formData": { "alias": "formData"; "required": false; "isSignal": true; }; "validationErrors": { "alias": "validationErrors"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "isSaving": { "alias": "isSaving"; "required": false; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; "parentType": { "alias": "parentType"; "required": false; "isSignal": true; }; }, { "formData": "formDataChange"; "save": "save"; "cancel": "cancel"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoFormComponent, "spark-po-form", never, { "entityType": { "alias": "entityType"; "required": false; "isSignal": true; }; "formData": { "alias": "formData"; "required": false; "isSignal": true; }; "validationErrors": { "alias": "validationErrors"; "required": false; "isSignal": true; }; "showButtons": { "alias": "showButtons"; "required": false; "isSignal": true; }; "isSaving": { "alias": "isSaving"; "required": false; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; "parentType": { "alias": "parentType"; "required": false; "isSignal": true; }; "objectTypeId": { "alias": "objectTypeId"; "required": false; "isSignal": true; }; "objectId": { "alias": "objectId"; "required": false; "isSignal": true; }; }, { "formData": "formDataChange"; "save": "save"; "cancel": "cancel"; }, never, never, true, never>;
 }
 
 /**

package/types/mintplayer-ng-spark-query-list.d.ts

@@ -1,19 +1,34 @@
 import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
-import { PersistentObject, CustomActionDefinition, SparkQuery, EntityType, LookupReference, EntityAttributeDefinition } from '@mintplayer/ng-spark/models';
+import { PersistentObject, CustomActionDefinition } from '@mintplayer/ng-spark/models';
 import * as _angular_core from '@angular/core';
-import { TemplateRef, Type } from '@angular/core';
+import { TemplateRef } from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
-import { BsDatatableFetch, DatatableSettings } from '@mintplayer/ng-bootstrap/datatable';
 import { SparkLanguageService } from '@mintplayer/ng-spark/services';
 
+/**
+ * The routed query page: chrome around one {@link SparkQueryGridComponent}.
+ *
+ * It owns what is genuinely page-shaped and route-shaped, and nothing else:
+ *
+ *  - **Route resolution.** It has no `queryId` input; it reads `paramMap`, and it serves two
+ *    routes — `query/:queryId`, and `po/:type`, which resolves an entity type to a query. That
+ *    second one is type-to-query resolution, not query rendering, and is why this component still
+ *    exists rather than the router pointing at the grid.
+ *  - **Streaming.** The websocket lives here so it stays out of every PO detail page's bundle;
+ *    the snapshot is filtered and sorted client-side and handed to the grid as `[data]`.
+ *  - The action bar, the caption, the LIVE badge, the search box and the New button.
+ *
+ * The grid itself — columns, cells, paging, the row link, selection, custom-action execution —
+ * is the shared component. This page previously wrote out `<bs-datatable>` twice, once per
+ * transport, with a shared row template between them; both are gone.
+ */
 declare class SparkQueryListComponent {
     private readonly route;
     private readonly router;
     private readonly sparkService;
     private readonly streamingService;
-    protected readonly lang: SparkLanguageService;
-    private readonly gridRenderers;
     private readonly destroyRef;
+    protected readonly lang: SparkLanguageService;
     extraActionsTemplate: _angular_core.InputSignal<TemplateRef<void> | null>;
     showCustomActions: _angular_core.InputSignal<boolean>;
     rowClicked: _angular_core.OutputEmitterRef<PersistentObject>;
@@ -22,76 +37,48 @@ declare class SparkQueryListComponent {
         action: CustomActionDefinition;
     }>;
     colors: typeof Color;
+    /** The query the grid should render, resolved from the route. Null until it is known. */
+    queryId: _angular_core.WritableSignal<string | null>;
     errorMessage: _angular_core.WritableSignal<string | null>;
-    query: _angular_core.WritableSignal<SparkQuery | null>;
-    entityType: _angular_core.WritableSignal<EntityType | null>;
-    allEntityTypes: _angular_core.WritableSignal<EntityType[]>;
-    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
-    resultCount: _angular_core.WritableSignal<number | null>;
-    searchTerm: string;
-    canRead: _angular_core.WritableSignal<boolean>;
-    canCreate: _angular_core.WritableSignal<boolean>;
-    customActions: _angular_core.WritableSignal<CustomActionDefinition[]>;
-    isStreaming: _angular_core.WritableSignal<boolean>;
-    private streamingSub;
-    private allItems;
-    streamItems: _angular_core.WritableSignal<PersistentObject[]>;
-    fetchFn: _angular_core.WritableSignal<BsDatatableFetch<PersistentObject> | null>;
-    settings: _angular_core.WritableSignal<DatatableSettings>;
-    constructor();
-    private onParamsChange;
-    /**
-     * A load failure has to render, not just be swallowed: a denied query answers 404
-     * (audit M-3, so existence is not leaked), which is indistinguishable from a missing
-     * one -- hence a deliberately generic message rather than a guess at which it was.
-     */
-    private reportLoadFailure;
-    onCustomAction(action: CustomActionDefinition): Promise<void>;
-    private resolveEntityTypeForQuery;
-    private extractSourceName;
-    private singularize;
-    /**
-     * Builds the server-side fetch callback the datatable invokes per page/sort.
-     * Reads `searchTerm` live, so a settings change (or a new fetchFn identity)
-     * refetches with the current search term.
-     */
-    private makeFetch;
+    searchTerm: _angular_core.WritableSignal<string>;
+    private readonly grid;
     /**
-     * Force a refetch (e.g. after a custom action) without changing page/sort.
+     * Grid state, surfaced for this page's chrome.
      *
-     * Public so a host can drive it, and named to match
-     * `SparkSubQueryComponent.reload()` — the two grids had drifted into having the
-     * same mechanism under different names, one of them unreachable.
+     * Optional `viewChild`, read defensively: the action bar and caption render above the grid, so
+     * on the first change-detection pass the query has not resolved yet.
      */
-    reload(): void;
-    onSearchChange(): void;
-    clearSearch(): void;
+    protected readonly query: _angular_core.Signal<_mintplayer_ng_spark_models.SparkQuery | null>;
+    protected readonly entityType: _angular_core.Signal<_mintplayer_ng_spark_models.EntityType | null>;
+    protected readonly customActions: _angular_core.Signal<CustomActionDefinition[]>;
+    protected readonly canCreate: _angular_core.Signal<boolean>;
+    protected readonly resultCount: _angular_core.Signal<number | null>;
+    protected readonly isVirtualScrolling: _angular_core.Signal<boolean>;
+    protected readonly gridError: _angular_core.Signal<string | null>;
+    /** Whether an action's selection rule is satisfied. Delegated: the grid holds the selection. */
+    protected isActionEnabled(action: CustomActionDefinition): boolean;
+    isStreaming: _angular_core.WritableSignal<boolean>;
+    private streamingSub;
+    private readonly allItems;
+    private readonly streamItems;
     /**
-     * Whether the first column links to a detail page.
+     * Rows handed to the grid, or `null` to let it fetch for itself.
      *
-     * Declared by the query, because the framework cannot derive it: `Database.*` rows
-     * are always real documents, but a `Custom.*` query may return loadable documents
-     * (Fleet's Stolen_Cars) or rows fabricated in memory (StreamItems). Absent means
-     * navigable -- defaulting Custom.* to false would strip the working links off every
-     * custom query that does return documents.
+     * Null for a normal query — an empty array would read as "here are no rows" and suppress the
+     * fetch entirely.
      */
+    protected readonly gridData: _angular_core.Signal<PersistentObject[] | null>;
+    constructor();
+    private onParamsChange;
     /**
-     * Rows the user has ticked. Lives here rather than in the datatable so the action bar can
-     * read it, and MUST be cleared whenever the source changes — otherwise route A's selection
-     * is POSTed as ids of route B's type.
+     * A load failure has to render, not just be swallowed: a denied query answers 404 (audit M-3, so
+     * existence is not leaked), which is indistinguishable from a missing one — hence a deliberately
+     * generic message rather than a guess at which it was.
      */
-    selection: _angular_core.WritableSignal<PersistentObject[]>;
-    private readonly queryRefresh;
-    /** 'none' unless an action is selection-gated, so unaffected grids gain no checkbox column. */
-    selectionMode: _angular_core.Signal<_mintplayer_ng_spark_models.SparkSelectionMode>;
-    /** Whether an action's selection rule is satisfied right now. The server checks it again. */
-    isActionEnabled(action: CustomActionDefinition): boolean;
-    isVirtualScrolling: _angular_core.Signal<boolean>;
-    visibleAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
-    getColumnRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
-    getColumnRendererInputs(component: Type<any>, item: PersistentObject, attr: EntityAttributeDefinition): Record<string, any>;
-    private loadLookupReferenceOptions;
-    onCreate(): void;
+    private reportLoadFailure;
+    protected onCustomAction(action: CustomActionDefinition): Promise<void>;
+    protected onCreate(): void;
+    protected clearSearch(): void;
     private connectStreaming;
     private disconnectStreaming;
     private handleStreamingMessage;

package/types/mintplayer-ng-spark-services.d.ts

@@ -71,6 +71,16 @@ declare class SparkService {
     get(type: string, id: string): Promise<PersistentObject>;
     create(type: string, data: Partial<PersistentObject>): Promise<PersistentObject>;
     update(type: string, id: string, data: Partial<PersistentObject>): Promise<PersistentObject>;
+    /**
+     * Asks the server to reshape an in-progress object after `triggeredBy`'s value changed.
+     *
+     * Writes nothing, but goes through the envelope like every other mutating call: a refresh may
+     * legitimately emit notifications, and may open the retry-action prompt.
+     *
+     * `triggeredBy` is the attribute's name. For a trigger inside an AsDetail row it is the same
+     * path form the inline validation errors use — `Jobs[2].ProfessionId`.
+     */
+    refresh(type: string, data: Partial<PersistentObject>, triggeredBy: string): Promise<PersistentObject>;
     delete(type: string, id: string): Promise<void>;
     getCustomActions(objectTypeId: string): Promise<CustomActionDefinition[]>;
     executeCustomAction(objectTypeId: string, actionName: string, parent?: PersistentObject, selectedItems?: PersistentObject[]): Promise<void>;