@firestitch/report 18.0.10 → 18.0.11

package/app/reports/data/report.data.d.ts

@@ -49,6 +49,10 @@ export declare class ReportData<T = any> {
     semanticBuildStatus(config?: RequestConfig): Observable<T>;
     semanticBuildStop(config?: RequestConfig): Observable<T>;
     semanticEntityFunctions(entity: string, config?: RequestConfig): Observable<T>;
+    settings(config?: RequestConfig): Observable<T>;
+    saveSettings(settings: {
+        semanticBuildConcurrency: number;
+    }, config?: RequestConfig): Observable<T>;
     updateFilterGroup(reportId: number, groupId: number, changes: {
         level?: ReportFilterLevel;
         default?: FilterGroupDefault | null;

package/app/reports/dialogs/global-settings/components/general/general.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class GeneralComponent {
+    readonly concurrency: import("@angular/core").ModelSignal<number>;
+    readonly min: import("@angular/core").InputSignal<number>;
+    readonly max: import("@angular/core").InputSignal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GeneralComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GeneralComponent, "fs-ai-report-global-settings-general", never, { "concurrency": { "alias": "concurrency"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": true; "isSignal": true; }; "max": { "alias": "max"; "required": true; "isSignal": true; }; }, { "concurrency": "concurrencyChange"; }, never, never, true, never>;
+}

package/app/reports/dialogs/global-settings/components/semantic-database/semantic-database.component.d.ts

@@ -14,6 +14,7 @@ export declare class SemanticDatabaseComponent {
     readonly buildActive: import("@angular/core").Signal<boolean>;
     readonly buildStateLabel: import("@angular/core").Signal<string>;
     private readonly _entityFunctions;
+    private _buildFinalized;
     private readonly _reportData;
     private readonly _process;
     private readonly _prompt;
@@ -23,6 +24,20 @@ export declare class SemanticDatabaseComponent {
     build(): void;
     stopBuild(): void;
     private _runBuild;
+    /**
+     * Wrap up one build run exactly once. On a hard stream error there is no
+     * status to read, so say so directly; otherwise refresh the status and
+     * announce how the build actually ended — a build that failed (e.g. the AI
+     * couldn't be reached) reports 'Failed' with a reason, and that must surface
+     * instead of the run silently doing nothing.
+     */
+    private _finalizeBuild;
+    /**
+     * Tell the operator how the build ended: a failed/stopped build surfaces its
+     * reason (so an AI connection problem is never silent), a completed one
+     * confirms success.
+     */
+    private _announceOutcome;
     stageColor(stage: SemanticBuildStage): string;
     stageTooltip(stage: SemanticBuildStage): string;
     kindColor(kind: string): string;

package/app/reports/dialogs/global-settings/global-settings.component.d.ts

@@ -1,5 +1,5 @@
 import { FsMarkdownEditorConfig } from '@firestitch/markdown-editor';
-import { ReportInstruction, ReportInstructions } from '../../interfaces/report.interface';
+import { ReportInstruction, ReportInstructions, ReportSettings } from '../../interfaces/report.interface';
 import { SemanticDatabaseComponent } from './components/semantic-database/semantic-database.component';
 import * as i0 from "@angular/core";
 export declare class GlobalSettingsComponent {
@@ -8,16 +8,20 @@ export declare class GlobalSettingsComponent {
     readonly content: import("@angular/core").WritableSignal<string>;
     readonly editorConfig: FsMarkdownEditorConfig;
     readonly instructions: import("@angular/core").WritableSignal<ReportInstructions>;
+    readonly settings: import("@angular/core").WritableSignal<ReportSettings>;
+    readonly concurrency: import("@angular/core").WritableSignal<number>;
+    readonly loaded: import("@angular/core").Signal<boolean>;
     private readonly _dialogRef;
     private readonly _reportData;
     private readonly _message;
     private readonly _prompt;
     private readonly _destroyRef;
     constructor();
-    save: () => import("rxjs").Observable<ReportInstructions>;
+    save: () => import("rxjs").Observable<ReportSettings> | import("rxjs").Observable<ReportInstructions>;
     restore(version: ReportInstruction): void;
     private _init;
     private _applyInstructions;
+    private _applySettings;
     static ɵfac: i0.ɵɵFactoryDeclaration<GlobalSettingsComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<GlobalSettingsComponent, "ng-component", never, {}, {}, never, never, true, never>;
 }

package/app/reports/interfaces/report.interface.d.ts

@@ -236,3 +236,8 @@ export interface SemanticBuildStatus {
     build: SemanticBuild | null;
     detail: SemanticBuildDetail;
 }
+export interface ReportSettings {
+    semanticBuildConcurrency: number;
+    semanticBuildConcurrencyMin: number;
+    semanticBuildConcurrencyMax: number;
+}

package/esm2022/app/reports/data/report.data.mjs

@@ -185,6 +185,20 @@ export class ReportData {
             ...config,
         });
     }
+    // The report module's General settings (semantic-build concurrency + its bounds).
+    settings(config = {}) {
+        return this._api.get(this._path('settings'), {}, {
+            key: 'settings',
+            ...config,
+        });
+    }
+    // Save the General settings; resolves to the same { settings } shape.
+    saveSettings(settings, config = {}) {
+        return this._api.put(this._path('settings'), settings, {
+            key: 'settings',
+            ...config,
+        });
+    }
     // Update a filter group — its exposure level ('component' | 'report' | 'both')
     // and/or its default value (the value seeding the report bar on open). Send
     // `default: null` (or an empty default) to clear it. Only the keys provided
@@ -204,4 +218,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report.data.js","sourceRoot":"","sources":["../../../../../src/app/reports/data/report.data.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\n\nimport { FsApi, RequestConfig } from '@firestitch/api';\n\nimport { Observable } from 'rxjs';\n\nimport {\n  ComponentDataState,\n  FilterGroupDefault,\n  ReportFilterLevel,\n  ResolvedFilterValue,\n} from '../interfaces/report.interface';\n\n\n// API gateway for the Reports module. Every endpoint hangs off [basePath],\n// which defaults to \"reports\" (the framework reports backend at /api/reports)\n// and can be repointed by the host so the package stays self-contained and portable.\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReportData<T = any> {\n  private _api = inject(FsApi);\n\n  // The API root for every reports endpoint. Defaults to the framework reports\n  // context; set it once (e.g. from the host's report page) to mount elsewhere.\n  public basePath = 'reports';\n\n  // Build an endpoint path under the configured base, e.g. _path() => \"ai/reports\",\n  // _path(`${id}/pages`) => \"ai/reports/123/pages\".\n  private _path(suffix = ''): string {\n    return suffix ? `${this.basePath}/${suffix}` : this.basePath;\n  }\n\n  public reports(query: any = {}, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(),\n      query,\n      {\n        key: 'reports',\n        ...config,\n      },\n    );\n  }\n\n  public create(name: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(),\n      { name },\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  public rename(reportId: number, name: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}`),\n      { name },\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Report settings: any subset of { name, pageSize, pageOrientation, layout,\n  // styles } — styles carry the report's typographic config (e.g. heading size).\n  public update(reportId: number, settings: Record<string, unknown>, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}`),\n      settings,\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Append a blank page to the report; resolves to the new page.\n  public addPage(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/pages`),\n      {},\n      {\n        key: 'page',\n        ...config,\n      },\n    );\n  }\n\n  // Component settings: any subset of { title, padding } — the human-facing\n  // dialog edits; geometry (x/y/w/h/flowWidth) is persisted via savePositions\n  // from the canvas instead.\n  public updateComponent(\n    reportId: number,\n    componentId: number,\n    settings: Record<string, unknown>,\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/components/${componentId}/settings`),\n      settings,\n      {\n        key: 'component',\n        ...config,\n      },\n    );\n  }\n\n  public delete(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.delete(\n      this._path(`${reportId}`),\n      {},\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // The assembled structure: pages → components (+ their filters) and the\n  // report's filter groups.\n  public get(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}`),\n      {},\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Persist geometry for the moved components only — any subset of\n  // { x, y, w, h } (inches), flowWidth (percent) and order (flow position).\n  public savePositions(\n    reportId: number,\n    positions: ({ componentId: number } & Partial<{ x: number; y: number; w: number; h: number; flowWidth: number; order: number }>)[],\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/components/positions`),\n      { positions },\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // One component's data. The body carries everything session-scoped: the\n  // resolved filter values and the component's own interaction state.\n  public componentData(\n    reportId: number,\n    componentId: number,\n    filters: ResolvedFilterValue[] = [],\n    state: ComponentDataState = {},\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/data`),\n      { filters, state },\n      {\n        key: 'data',\n        ...config,\n      },\n    );\n  }\n\n  // Exports the component's FULL filtered dataset to CSV server-side and\n  // resolves to a presigned download URL. The backend streams percentage\n  // progress while chunking; consume through FsProcess.download.\n  public exportComponent(\n    reportId: number,\n    componentId: number,\n    filters: ResolvedFilterValue[] = [],\n    state: ComponentDataState = {},\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/export`),\n      { filters, state },\n      {\n        key: 'url',\n        ...config,\n      },\n    );\n  }\n\n  // Distinct options for a select filter (drives multiselect controls).\n  public filterOptions(reportId: number, filterId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}/filters/${filterId}/options`),\n      {},\n      {\n        key: 'options',\n        ...config,\n      },\n    );\n  }\n\n  // The component SQL's filterable output columns — drives the column picker\n  // in the filter UI so a column name is never typed by hand.\n  public componentColumns(reportId: number, componentId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}/components/${componentId}/columns`),\n      {},\n      {\n        key: 'columns',\n        ...config,\n      },\n    );\n  }\n\n  // Make one column filterable. `level` (component | report) places a new\n  // group; `groupId` instead links into an existing group. A select filter's\n  // options are derived from the component SQL when optionsSql is omitted.\n  public addFilter(\n    reportId: number,\n    componentId: number,\n    filter: { filterColumn: string; type?: string; label?: string; level?: string; optionsSql?: string; groupId?: number },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/filters`),\n      filter,\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // Update a filter — any subset of { label, optionsSql, enabled }.\n  public updateFilter(\n    reportId: number,\n    filterId: number,\n    changes: { label?: string; optionsSql?: string; enabled?: boolean },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/filters/${filterId}`),\n      changes,\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // Remove a filter (its group goes too when nothing else uses it).\n  public deleteFilter(reportId: number, filterId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.delete(\n      this._path(`${reportId}/filters/${filterId}`),\n      {},\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // The global AI knowledge document (operator-authored agent instructions)\n  // and its full version history: { instructions, versions }.\n  public instructions(config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path('instructions'),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Save a new version of the document (append-only; an unchanged save is a\n  // no-op server-side). Resolves to the same { instructions, versions } shape.\n  public saveInstructions(content: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path('instructions'),\n      { content },\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Make an earlier version of the document current (no new row is created).\n  public restoreInstruction(instructionId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(`instructions/${instructionId}/restore`),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Run a semantic-database build, streamed: emits an event per NDJSON frame\n  // ({ kind: 'log', line, percent } feed lines and { kind: 'section' } phase\n  // markers) and completes when the build ends. Feed the lines into FsProcess.\n  public semanticBuild(config: RequestConfig = {}): Observable<any> {\n    return this._api.stream(\n      'POST',\n      this._path('semantic/build'),\n      { stream: true },\n      config,\n    );\n  }\n\n  // Latest build status + entity scoreboard: { build, detail }.\n  public semanticBuildStatus(config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path('semantic/build'),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Stop the running build (the current semantic database stays in place).\n  public semanticBuildStop(config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path('semantic/build/stop'),\n      {},\n      {\n        key: 'build',\n        ...config,\n      },\n    );\n  }\n\n  // One entity's cached AI-classified code functions — loaded on expand, one\n  // entity at a time, because the full set across all entities is far too big\n  // to ship inside the scoreboard call.\n  public semanticEntityFunctions(entity: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`semantic/entities/${entity}/functions`),\n      {},\n      {\n        key: 'entityFunctions',\n        ...config,\n      },\n    );\n  }\n\n  // Update a filter group — its exposure level ('component' | 'report' | 'both')\n  // and/or its default value (the value seeding the report bar on open). Send\n  // `default: null` (or an empty default) to clear it. Only the keys provided\n  // are changed.\n  public updateFilterGroup(\n    reportId: number,\n    groupId: number,\n    changes: { level?: ReportFilterLevel; default?: FilterGroupDefault | null },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/filtergroups/${groupId}`),\n      changes,\n      {\n        key: 'filterGroup',\n        ...config,\n      },\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report.data.js","sourceRoot":"","sources":["../../../../../src/app/reports/data/report.data.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\n\nimport { FsApi, RequestConfig } from '@firestitch/api';\n\nimport { Observable } from 'rxjs';\n\nimport {\n  ComponentDataState,\n  FilterGroupDefault,\n  ReportFilterLevel,\n  ResolvedFilterValue,\n} from '../interfaces/report.interface';\n\n\n// API gateway for the Reports module. Every endpoint hangs off [basePath],\n// which defaults to \"reports\" (the framework reports backend at /api/reports)\n// and can be repointed by the host so the package stays self-contained and portable.\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReportData<T = any> {\n  private _api = inject(FsApi);\n\n  // The API root for every reports endpoint. Defaults to the framework reports\n  // context; set it once (e.g. from the host's report page) to mount elsewhere.\n  public basePath = 'reports';\n\n  // Build an endpoint path under the configured base, e.g. _path() => \"ai/reports\",\n  // _path(`${id}/pages`) => \"ai/reports/123/pages\".\n  private _path(suffix = ''): string {\n    return suffix ? `${this.basePath}/${suffix}` : this.basePath;\n  }\n\n  public reports(query: any = {}, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(),\n      query,\n      {\n        key: 'reports',\n        ...config,\n      },\n    );\n  }\n\n  public create(name: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(),\n      { name },\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  public rename(reportId: number, name: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}`),\n      { name },\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Report settings: any subset of { name, pageSize, pageOrientation, layout,\n  // styles } — styles carry the report's typographic config (e.g. heading size).\n  public update(reportId: number, settings: Record<string, unknown>, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}`),\n      settings,\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Append a blank page to the report; resolves to the new page.\n  public addPage(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/pages`),\n      {},\n      {\n        key: 'page',\n        ...config,\n      },\n    );\n  }\n\n  // Component settings: any subset of { title, padding } — the human-facing\n  // dialog edits; geometry (x/y/w/h/flowWidth) is persisted via savePositions\n  // from the canvas instead.\n  public updateComponent(\n    reportId: number,\n    componentId: number,\n    settings: Record<string, unknown>,\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/components/${componentId}/settings`),\n      settings,\n      {\n        key: 'component',\n        ...config,\n      },\n    );\n  }\n\n  public delete(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.delete(\n      this._path(`${reportId}`),\n      {},\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // The assembled structure: pages → components (+ their filters) and the\n  // report's filter groups.\n  public get(reportId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}`),\n      {},\n      {\n        key: 'report',\n        ...config,\n      },\n    );\n  }\n\n  // Persist geometry for the moved components only — any subset of\n  // { x, y, w, h } (inches), flowWidth (percent) and order (flow position).\n  public savePositions(\n    reportId: number,\n    positions: ({ componentId: number } & Partial<{ x: number; y: number; w: number; h: number; flowWidth: number; order: number }>)[],\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/components/positions`),\n      { positions },\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // One component's data. The body carries everything session-scoped: the\n  // resolved filter values and the component's own interaction state.\n  public componentData(\n    reportId: number,\n    componentId: number,\n    filters: ResolvedFilterValue[] = [],\n    state: ComponentDataState = {},\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/data`),\n      { filters, state },\n      {\n        key: 'data',\n        ...config,\n      },\n    );\n  }\n\n  // Exports the component's FULL filtered dataset to CSV server-side and\n  // resolves to a presigned download URL. The backend streams percentage\n  // progress while chunking; consume through FsProcess.download.\n  public exportComponent(\n    reportId: number,\n    componentId: number,\n    filters: ResolvedFilterValue[] = [],\n    state: ComponentDataState = {},\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/export`),\n      { filters, state },\n      {\n        key: 'url',\n        ...config,\n      },\n    );\n  }\n\n  // Distinct options for a select filter (drives multiselect controls).\n  public filterOptions(reportId: number, filterId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}/filters/${filterId}/options`),\n      {},\n      {\n        key: 'options',\n        ...config,\n      },\n    );\n  }\n\n  // The component SQL's filterable output columns — drives the column picker\n  // in the filter UI so a column name is never typed by hand.\n  public componentColumns(reportId: number, componentId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`${reportId}/components/${componentId}/columns`),\n      {},\n      {\n        key: 'columns',\n        ...config,\n      },\n    );\n  }\n\n  // Make one column filterable. `level` (component | report) places a new\n  // group; `groupId` instead links into an existing group. A select filter's\n  // options are derived from the component SQL when optionsSql is omitted.\n  public addFilter(\n    reportId: number,\n    componentId: number,\n    filter: { filterColumn: string; type?: string; label?: string; level?: string; optionsSql?: string; groupId?: number },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.post(\n      this._path(`${reportId}/components/${componentId}/filters`),\n      filter,\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // Update a filter — any subset of { label, optionsSql, enabled }.\n  public updateFilter(\n    reportId: number,\n    filterId: number,\n    changes: { label?: string; optionsSql?: string; enabled?: boolean },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/filters/${filterId}`),\n      changes,\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // Remove a filter (its group goes too when nothing else uses it).\n  public deleteFilter(reportId: number, filterId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.delete(\n      this._path(`${reportId}/filters/${filterId}`),\n      {},\n      {\n        key: 'filter',\n        ...config,\n      },\n    );\n  }\n\n  // The global AI knowledge document (operator-authored agent instructions)\n  // and its full version history: { instructions, versions }.\n  public instructions(config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path('instructions'),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Save a new version of the document (append-only; an unchanged save is a\n  // no-op server-side). Resolves to the same { instructions, versions } shape.\n  public saveInstructions(content: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path('instructions'),\n      { content },\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Make an earlier version of the document current (no new row is created).\n  public restoreInstruction(instructionId: number, config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path(`instructions/${instructionId}/restore`),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Run a semantic-database build, streamed: emits an event per NDJSON frame\n  // ({ kind: 'log', line, percent } feed lines and { kind: 'section' } phase\n  // markers) and completes when the build ends. Feed the lines into FsProcess.\n  public semanticBuild(config: RequestConfig = {}): Observable<any> {\n    return this._api.stream(\n      'POST',\n      this._path('semantic/build'),\n      { stream: true },\n      config,\n    );\n  }\n\n  // Latest build status + entity scoreboard: { build, detail }.\n  public semanticBuildStatus(config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path('semantic/build'),\n      {},\n      {\n        key: null,\n        ...config,\n      },\n    );\n  }\n\n  // Stop the running build (the current semantic database stays in place).\n  public semanticBuildStop(config: RequestConfig = {}): Observable<T> {\n    return this._api.post(\n      this._path('semantic/build/stop'),\n      {},\n      {\n        key: 'build',\n        ...config,\n      },\n    );\n  }\n\n  // One entity's cached AI-classified code functions — loaded on expand, one\n  // entity at a time, because the full set across all entities is far too big\n  // to ship inside the scoreboard call.\n  public semanticEntityFunctions(entity: string, config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path(`semantic/entities/${entity}/functions`),\n      {},\n      {\n        key: 'entityFunctions',\n        ...config,\n      },\n    );\n  }\n\n  // The report module's General settings (semantic-build concurrency + its bounds).\n  public settings(config: RequestConfig = {}): Observable<T> {\n    return this._api.get(\n      this._path('settings'),\n      {},\n      {\n        key: 'settings',\n        ...config,\n      },\n    );\n  }\n\n  // Save the General settings; resolves to the same { settings } shape.\n  public saveSettings(settings: { semanticBuildConcurrency: number }, config: RequestConfig = {}): Observable<T> {\n    return this._api.put(\n      this._path('settings'),\n      settings,\n      {\n        key: 'settings',\n        ...config,\n      },\n    );\n  }\n\n  // Update a filter group — its exposure level ('component' | 'report' | 'both')\n  // and/or its default value (the value seeding the report bar on open). Send\n  // `default: null` (or an empty default) to clear it. Only the keys provided\n  // are changed.\n  public updateFilterGroup(\n    reportId: number,\n    groupId: number,\n    changes: { level?: ReportFilterLevel; default?: FilterGroupDefault | null },\n    config: RequestConfig = {},\n  ): Observable<T> {\n    return this._api.put(\n      this._path(`${reportId}/filtergroups/${groupId}`),\n      changes,\n      {\n        key: 'filterGroup',\n        ...config,\n      },\n    );\n  }\n}\n"]}

package/esm2022/app/reports/dialogs/global-settings/components/general/general.component.mjs

@@ -0,0 +1,34 @@
+import { ChangeDetectionStrategy, Component, input, model } from '@angular/core';
+import { ControlContainer, FormsModule, NgForm } from '@angular/forms';
+import { MatFormField, MatHint, MatLabel } from '@angular/material/form-field';
+import { MatInput } from '@angular/material/input';
+import { FsFormModule } from '@firestitch/form';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@firestitch/form";
+// The General tab: report-module settings that aren't the AI knowledge document.
+// Currently just the semantic-build concurrency — how many summary calls the
+// build runs at once. A field-level child of the settings dialog form (its input
+// registers with the parent <form fsForm> via the ControlContainer view
+// provider), so the dialog's Save button submits and validates it. The value
+// itself is held on the shell (bound through `concurrency`), and the safe band
+// (`min`/`max`) comes from the backend so the field can't be set out of range.
+export class GeneralComponent {
+    concurrency = model(0);
+    min = input.required();
+    max = input.required();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GeneralComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.14", type: GeneralComponent, isStandalone: true, selector: "fs-ai-report-global-settings-general", inputs: { concurrency: { classPropertyName: "concurrency", publicName: "concurrency", isSignal: true, isRequired: false, transformFunction: null }, min: { classPropertyName: "min", publicName: "min", isSignal: true, isRequired: true, transformFunction: null }, max: { classPropertyName: "max", publicName: "max", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { concurrency: "concurrencyChange" }, ngImport: i0, template: "<div class=\"fs-column tab-body\">\n  <mat-form-field>\n    <mat-label>Semantic build concurrency</mat-label>\n    <input\n        matInput\n        type=\"number\"\n        [ngModel]=\"concurrency()\"\n        (ngModelChange)=\"concurrency.set($event)\"\n        name=\"semanticBuildConcurrency\"\n        [fsFormRequired]=\"true\"\n        [fsFormInteger]=\"true\"\n        [fsFormMin]=\"min()\"\n        [fsFormMax]=\"max()\">\n    <mat-hint>\n      How many AI calls the semantic-database build runs at once ({{ min() }}\u2013{{ max() }}).\n      Higher is faster but more likely to hit the AI provider's rate limit. Default is 8.\n    </mat-hint>\n  </mat-form-field>\n</div>\n", styles: [".tab-body{padding-top:16px}mat-form-field{display:block;max-width:340px}\n"], dependencies: [{ kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1.NumberValueAccessor, selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]" }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: FsFormModule }, { kind: "directive", type: i2.FsFormRequiredDirective, selector: "[fsFormRequired],[ngModel][required]", inputs: ["fsFormRequired", "required", "fsFormRequiredMessage"] }, { kind: "directive", type: i2.FsFormMinDirective, selector: "[fsFormMin]", inputs: ["fsFormMin", "fsFormMinMessage"] }, { kind: "directive", type: i2.FsFormMaxDirective, selector: "[fsFormMax]", inputs: ["fsFormMax", "fsFormMaxMessage"] }, { kind: "directive", type: i2.FsFormIntegerDirective, selector: "[fsFormInteger]", inputs: ["fsFormInteger", "fsFormIntegerMessage"] }, { kind: "component", type: MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: MatLabel, selector: "mat-label" }, { kind: "directive", type: MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { kind: "directive", type: MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }], viewProviders: [{ provide: ControlContainer, useExisting: NgForm }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: GeneralComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'fs-ai-report-global-settings-general', viewProviders: [{ provide: ControlContainer, useExisting: NgForm }], changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        FormsModule,
+                        FsFormModule,
+                        MatFormField,
+                        MatLabel,
+                        MatHint,
+                        MatInput,
+                    ], template: "<div class=\"fs-column tab-body\">\n  <mat-form-field>\n    <mat-label>Semantic build concurrency</mat-label>\n    <input\n        matInput\n        type=\"number\"\n        [ngModel]=\"concurrency()\"\n        (ngModelChange)=\"concurrency.set($event)\"\n        name=\"semanticBuildConcurrency\"\n        [fsFormRequired]=\"true\"\n        [fsFormInteger]=\"true\"\n        [fsFormMin]=\"min()\"\n        [fsFormMax]=\"max()\">\n    <mat-hint>\n      How many AI calls the semantic-database build runs at once ({{ min() }}\u2013{{ max() }}).\n      Higher is faster but more likely to hit the AI provider's rate limit. Default is 8.\n    </mat-hint>\n  </mat-form-field>\n</div>\n", styles: [".tab-body{padding-top:16px}mat-form-field{display:block;max-width:340px}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/reports/dialogs/global-settings/components/semantic-database/semantic-database.component.mjs

@@ -9,7 +9,7 @@ import { FsMessage, FsMessageModule } from '@firestitch/message';
 import { FsProcess } from '@firestitch/process';
 import { FsPrompt } from '@firestitch/prompt';
 import { FsSkeletonModule } from '@firestitch/skeleton';
-import { filter, map, switchMap, take } from 'rxjs/operators';
+import { filter, map, switchMap, take, tap } from 'rxjs/operators';
 import { ReportData } from '../../../../data/report.data';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/material/expansion";
@@ -70,6 +70,9 @@ export class SemanticDatabaseComponent {
     // Per-entity function caches, loaded on first expand. undefined = not
     // requested yet, null = request in flight (the skeleton window), object = loaded.
     _entityFunctions = signal({});
+    // Guards the outcome message to fire exactly once per run — whether the stream
+    // completes (build finished, possibly failed) or errors outright.
+    _buildFinalized = false;
     _reportData = inject(ReportData);
     _process = inject(FsProcess);
     _prompt = inject(FsPrompt);
@@ -110,22 +113,62 @@ export class SemanticDatabaseComponent {
     // dismissing the dialog never interrupts a running build.
     _runBuild() {
         this.building.set(true);
+        this._buildFinalized = false;
         const target$ = this._reportData.semanticBuild()
-            .pipe(filter((event) => event?.type === StreamEventType.Data
+            .pipe(
+        // A hard stream/transport failure (the build couldn't even start)
+        // finalizes here — completed$ won't fire in that case.
+        tap({ error: (error) => this._finalizeBuild(error) }), filter((event) => event?.type === StreamEventType.Data
             && event.data?.kind === 'log'
             && typeof event.data.line === 'string'), map((event) => event.data.line));
         this._process
             .run('Semantic database build', target$)
             .completed$
             .pipe(take(1), takeUntilDestroyed(this._destroyRef))
-            .subscribe(() => {
-            this.building.set(false);
-            // The build rewrote every entity's function cache — drop the loaded
-            // copies so the next expand refetches fresh data.
-            this._entityFunctions.set({});
+            .subscribe(() => this._finalizeBuild(null));
+    }
+    /**
+     * Wrap up one build run exactly once. On a hard stream error there is no
+     * status to read, so say so directly; otherwise refresh the status and
+     * announce how the build actually ended — a build that failed (e.g. the AI
+     * couldn't be reached) reports 'Failed' with a reason, and that must surface
+     * instead of the run silently doing nothing.
+     */
+    _finalizeBuild(streamError) {
+        if (this._buildFinalized) {
+            return;
+        }
+        this._buildFinalized = true;
+        this.building.set(false);
+        // The build rewrote every entity's function cache — drop the loaded copies
+        // so the next expand refetches fresh data.
+        this._entityFunctions.set({});
+        if (streamError) {
+            this._message.error('The semantic database build could not run — check the AI connection and try again.');
             this._refreshStatus();
+            return;
+        }
+        this._reportData.semanticBuildStatus()
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe((status) => {
+            this.status.set(status);
+            this._announceOutcome(status);
         });
     }
+    /**
+     * Tell the operator how the build ended: a failed/stopped build surfaces its
+     * reason (so an AI connection problem is never silent), a completed one
+     * confirms success.
+     */
+    _announceOutcome(status) {
+        const build = status?.build;
+        if (build?.state === 'F' || build?.state === 'K') {
+            this._message.error(build.message || 'The semantic database build did not finish.');
+        }
+        else if (build?.state === 'C') {
+            this._message.success('Semantic database build complete.');
+        }
+    }
     stageColor(stage) {
         return stage === 'done'
             ? SemanticDatabaseComponent.DONE_COLOR
@@ -204,4 +247,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
                         FsSkeletonModule,
                     ], template: "<div class=\"fs-column tab-body\">\n  <p class=\"hint\">\n    The semantic database is what the report AI uses to understand your data \u2014\n    tables, relationships and the calculations in code. Rebuild it after\n    significant application updates. The build runs in the background; progress\n    appears in the dock at the bottom right and this dialog can be closed while\n    it runs.\n  </p>\n\n  <div *fsSkeleton=\"status()\">\n    @if (status(); as buildStatus) {\n      <div class=\"build-status\">\n        @if (buildStatus.detail.generatedAt) {\n          <div class=\"stat\">\n            <span class=\"label\">Last built</span>\n            <fs-date\n                [date]=\"buildStatus.detail.generatedAt\"\n                format=\"date-time\">\n            </fs-date>\n          </div>\n          <div class=\"stat\">\n            <span class=\"label\">Coverage</span>\n            <span>\n              {{ buildStatus.detail.entityCount }} entities \u00B7\n              {{ buildStatus.detail.functionCount }} code functions\n            </span>\n          </div>\n        } @else {\n          <fs-message-warning>\n            The semantic database has not been built yet \u2014 the report AI can't\n            answer data questions until it is. Run the first build.\n          </fs-message-warning>\n        }\n        @if (buildStatus.build) {\n          <div class=\"stat\">\n            <span class=\"label\">Last build run</span>\n            <span>\n              {{ buildStateLabel() }}\n              @if (buildStatus.build.message) {\n                \u2014 {{ buildStatus.build.message }}\n              }\n            </span>\n          </div>\n        }\n      </div>\n\n      <!-- The model scoreboard: every entity the AI knows about, its\n           built-vs-needs-building stages, and a drill-down into its shape, enum\n           values, computed fields and AI-classified code functions. -->\n      @if (buildStatus.detail.entities?.length) {\n        <mat-accordion class=\"entities\">\n          @for (entity of buildStatus.detail.entities; track entity.key) {\n            <mat-expansion-panel (opened)=\"entityOpened(entity)\">\n              <mat-expansion-panel-header>\n                <mat-panel-title>{{ entity.key }}</mat-panel-title>\n                <mat-panel-description>\n                  <div class=\"stage-chips\">\n                    @for (stage of stageKeys; track stage) {\n                      <fs-chip\n                          size=\"tiny\"\n                          [backgroundColor]=\"stageColor(entity.stages[stage])\"\n                          color=\"#ffffff\"\n                          [matTooltip]=\"stageTooltip(entity.stages[stage])\">\n                        {{ stageLabels[stage] }}\n                      </fs-chip>\n                    }\n                  </div>\n                </mat-panel-description>\n              </mat-expansion-panel-header>\n\n              <!-- Deferred: the body (and its functions request) only exists\n                   once expanded. -->\n              <ng-template matExpansionPanelContent>\n                <div class=\"entity-detail\">\n                  <div><strong>Table:</strong> {{ entity.table }}</div>\n                  <div><strong>Columns:</strong> {{ entity.columns }}</div>\n                  <div><strong>Relationships:</strong> {{ entity.relationships }}</div>\n                  @if (entity.enums.length) {\n                    <div class=\"enum-list\">\n                      <strong>Enum values:</strong>\n                      @for (enumColumn of entity.enums; track enumColumn.column) {\n                        <div class=\"enum-row\">\n                          <span class=\"enum-column\">{{ enumColumn.column }}</span>\n                          <span class=\"enum-values\">{{ enumColumn.values.join(', ') }}</span>\n                        </div>\n                      }\n                    </div>\n                  }\n                  @if (entity.computedFields.length) {\n                    <div><strong>Computed fields:</strong> {{ entity.computedFields.join(', ') }}</div>\n                  }\n\n                  <div class=\"functions-section\">\n                    <h3 class=\"functions-heading\">\n                      Code functions\n                      @if (entity.functionCount) {\n                        <span class=\"functions-count\">({{ entity.functionCount }})</span>\n                      }\n                    </h3>\n\n                    <div class=\"functions-body\" *fsSkeleton=\"entityFunctions(entity.key)\">\n                      @if (entityFunctions(entity.key); as fns) {\n                        @if (fns.functions.length) {\n                          @if (fns.generatedAt) {\n                            <div class=\"hint functions-generated\">\n                              Discovered from {{ fns.class }} &middot;\n                              <fs-date\n                                  [date]=\"fns.generatedAt\"\n                                  format=\"date-time\">\n                              </fs-date>\n                            </div>\n                          }\n                          <div class=\"functions-list\">\n                            @for (fn of fns.functions; track fn.method) {\n                              <div class=\"function-row\">\n                                <div class=\"function-head\">\n                                  <fs-chip\n                                      size=\"tiny\"\n                                      [backgroundColor]=\"kindColor(fn.kind)\"\n                                      color=\"#ffffff\">\n                                    {{ fn.kind }}\n                                  </fs-chip>\n                                  <code class=\"function-method\">{{ fn.method }}</code>\n                                </div>\n                                <div class=\"function-summary\">{{ fn.summary }}</div>\n                                @if (fn.produces) {\n                                  <div class=\"function-produces hint\">Produces: {{ fn.produces }}</div>\n                                }\n                              </div>\n                            }\n                          </div>\n                        } @else {\n                          <div class=\"hint\">\n                            No functions cached for this entity yet \u2014 run a build to discover its code.\n                          </div>\n                        }\n                      }\n                    </div>\n                  </div>\n                </div>\n              </ng-template>\n            </mat-expansion-panel>\n          }\n        </mat-accordion>\n      }\n    }\n  </div>\n</div>\n", styles: [".tab-body{padding-top:16px}.hint{margin:0 0 12px;color:#0009;font-size:13px;line-height:1.5}.build-status{display:flex;flex-direction:column;gap:8px}.build-status .stat{display:flex;gap:8px}.build-status .stat .label{min-width:110px;color:#0009}.entities{display:block;padding:3px}.entities .stage-chips{display:flex;flex-wrap:wrap;gap:4px}.entities .entity-detail{display:flex;flex-direction:column;gap:5px}.entities .entity-detail .enum-list{display:flex;flex-direction:column;gap:3px}.entities .entity-detail .enum-list .enum-row{display:flex;gap:10px;padding-left:10px}.entities .entity-detail .enum-list .enum-row .enum-column{min-width:140px;font-weight:600}.entities .entity-detail .enum-list .enum-row .enum-values{color:#0009}.entities .entity-detail .functions-section{margin-top:10px}.entities .entity-detail .functions-section .functions-heading{margin:0 0 5px;font-size:15px}.entities .entity-detail .functions-section .functions-heading .functions-count{font-weight:400;color:#0009}.entities .entity-detail .functions-section .functions-generated{margin-bottom:10px}.entities .entity-detail .functions-section .functions-list{display:flex;flex-direction:column}.entities .entity-detail .functions-section .functions-list .function-row{display:flex;flex-direction:column;gap:3px;padding:10px 0}.entities .entity-detail .functions-section .functions-list .function-row+.function-row{border-top:1px solid rgba(0,0,0,.08)}.entities .entity-detail .functions-section .functions-list .function-row .function-head{display:flex;align-items:center;gap:8px}.entities .entity-detail .functions-section .functions-list .function-row .function-method{font-family:monospace;font-size:13px;font-weight:600}.entities .entity-detail .functions-section .functions-list .function-row .function-summary{color:#000000bf}.entities .entity-detail .functions-section .functions-list .function-row .function-produces{padding-left:10px}\n"] }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"semantic-database.component.js","sourceRoot":"","sources":["../../../../../../../../src/app/reports/dialogs/global-settings/components/semantic-database/semantic-database.component.ts","../../../../../../../../src/app/reports/dialogs/global-settings/components/semantic-database/semantic-database.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, DestroyRef, computed, inject, signal } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\nimport { MatExpansionModule } from '@angular/material/expansion';\nimport { MatTooltipModule } from '@angular/material/tooltip';\n\nimport { StreamEventType } from '@firestitch/api';\nimport { FsChipModule } from '@firestitch/chip';\nimport { FsDateModule } from '@firestitch/date';\nimport { FsMessage, FsMessageModule } from '@firestitch/message';\nimport { FsProcess } from '@firestitch/process';\nimport { FsPrompt } from '@firestitch/prompt';\nimport { FsSkeletonModule } from '@firestitch/skeleton';\n\nimport { filter, map, switchMap, take } from 'rxjs/operators';\n\nimport { ReportData } from '../../../../data/report.data';\nimport {\n  SemanticBuildEntity,\n  SemanticBuildStage,\n  SemanticBuildStatus,\n  SemanticEntityFunctions,\n} from '../../../../interfaces/report.interface';\n\n\n// The Semantic Database tab: the model scoreboard the report AI is built from.\n// Shows the last build's status, runs (or stops) a build — streamed into the\n// FsProcess dock so it survives the dialog closing — and drills into every\n// entity to reveal its shape, inlined enum values, computed fields and the\n// AI-classified code functions cached from its model class. Each entity's\n// functions load lazily on first expand, because the full set across all\n// entities is far too big to ship with the scoreboard.\n@Component({\n  selector: 'fs-ai-report-global-settings-semantic-database',\n  templateUrl: './semantic-database.component.html',\n  styleUrls: ['./semantic-database.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    MatExpansionModule,\n    MatTooltipModule,\n    FsChipModule,\n    FsDateModule,\n    FsMessageModule,\n    FsSkeletonModule,\n  ],\n})\nexport class SemanticDatabaseComponent {\n\n  // The build-in-flight states of the ff_processes row (queued/running/stopping).\n  private static readonly ACTIVE_STATES = ['Q', 'R', 'X'];\n\n  private static readonly STATE_LABELS: Record<string, string> = {\n    Q: 'Queued',\n    R: 'Running',\n    X: 'Stopping',\n    C: 'Completed',\n    K: 'Stopped',\n    F: 'Failed',\n  };\n\n  // Scoreboard completion palette: built = green, everything else (needs\n  // building) = grey. No error red — a missing stage is unbuilt content, not a\n  // failure.\n  private static readonly DONE_COLOR = '#2e7d32';\n  private static readonly PENDING_COLOR = '#9e9e9e';\n\n  // One color per AI classification kind, so a function's nature reads at a glance.\n  private static readonly KIND_COLORS: Record<string, string> = {\n    'calculation': '#1565c0',\n    'business-rule': '#6a1b9a',\n    'query': '#00695c',\n    'mutation': '#e65100',\n    'accessor': '#546e7a',\n    'other': '#757575',\n  };\n\n  // Interesting logic first: derived values and rules, then data access, then the rest.\n  private static readonly KIND_ORDER = ['calculation', 'business-rule', 'query', 'mutation', 'accessor', 'other'];\n\n  // The scoreboard's per-entity stage chips, left to right.\n  public readonly stageKeys = ['introspected', 'enumsInlined', 'computed', 'functions'];\n\n  public readonly stageLabels: Record<string, string> = {\n    introspected: 'Introspected',\n    enumsInlined: 'Enum cases',\n    computed: 'Computed',\n    functions: 'Functions',\n  };\n\n  // null until loaded — gates the tab behind the skeleton.\n  public readonly status = signal<SemanticBuildStatus | null>(null);\n\n  // True while a build started from this tab is streaming into the dock.\n  public readonly building = signal(false);\n\n  public readonly buildActive = computed<boolean>(() =>\n    this.building()\n      || SemanticDatabaseComponent.ACTIVE_STATES.includes(this.status()?.build?.state),\n  );\n\n  public readonly buildStateLabel = computed<string>(() =>\n    SemanticDatabaseComponent.STATE_LABELS[this.status()?.build?.state] ?? '',\n  );\n\n  // Per-entity function caches, loaded on first expand. undefined = not\n  // requested yet, null = request in flight (the skeleton window), object = loaded.\n  private readonly _entityFunctions = signal<Record<string, SemanticEntityFunctions | null>>({});\n\n  private readonly _reportData = inject(ReportData);\n  private readonly _process = inject(FsProcess);\n  private readonly _prompt = inject(FsPrompt);\n  private readonly _message = inject(FsMessage);\n  private readonly _destroyRef = inject(DestroyRef);\n\n  constructor() {\n    this._init();\n  }\n\n  // Confirm before kicking off a build — a rebuild replaces the current\n  // semantic database, so it should never fire on a stray click.\n  public build(): void {\n    const rebuild = !!this.status()?.detail?.generatedAt;\n\n    this._prompt.confirm({\n      title: rebuild ? 'Rebuild semantic database' : 'Build semantic database',\n      template: rebuild\n        ? 'Rebuild the semantic database? It runs in the background and replaces the current one when it finishes.'\n        : 'Build the semantic database? It runs in the background.',\n      commitLabel: rebuild ? 'Rebuild' : 'Build',\n    })\n      .pipe(takeUntilDestroyed(this._destroyRef))\n      .subscribe(() => this._runBuild());\n  }\n\n  public stopBuild(): void {\n    this._prompt.confirm({\n      title: 'Stop build',\n      template: 'Stop the running build? The current semantic database stays in place until a build finishes.',\n      commitLabel: 'Stop',\n    })\n      .pipe(\n        switchMap(() => this._reportData.semanticBuildStop()),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(() => {\n        this.building.set(false);\n        this._message.success('Stopping the build…');\n        this._refreshStatus();\n      });\n  }\n\n  // Run the semantic-database build. The live feed streams into the FsProcess\n  // dock (bottom-right), whose subscription survives this dialog closing — so\n  // dismissing the dialog never interrupts a running build.\n  private _runBuild(): void {\n    this.building.set(true);\n\n    const target$ = this._reportData.semanticBuild()\n      .pipe(\n        filter((event) =>\n          event?.type === StreamEventType.Data\n          && event.data?.kind === 'log'\n          && typeof event.data.line === 'string'),\n        map((event) => event.data.line as string),\n      );\n\n    this._process\n      .run('Semantic database build', target$)\n      .completed$\n      .pipe(\n        take(1),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(() => {\n        this.building.set(false);\n        // The build rewrote every entity's function cache — drop the loaded\n        // copies so the next expand refetches fresh data.\n        this._entityFunctions.set({});\n        this._refreshStatus();\n      });\n  }\n\n  public stageColor(stage: SemanticBuildStage): string {\n    return stage === 'done'\n      ? SemanticDatabaseComponent.DONE_COLOR\n      : SemanticDatabaseComponent.PENDING_COLOR;\n  }\n\n  public stageTooltip(stage: SemanticBuildStage): string {\n    return stage === 'done' ? 'Built' : 'Needs building';\n  }\n\n  public kindColor(kind: string): string {\n    return SemanticDatabaseComponent.KIND_COLORS[kind] ?? SemanticDatabaseComponent.KIND_COLORS.other;\n  }\n\n  /**\n   * The loaded function cache for an entity: undefined until the panel is first\n   * expanded, null while the request is in flight (the skeleton window), then\n   * the loaded cache.\n   */\n  public entityFunctions(key: string): SemanticEntityFunctions | null | undefined {\n    return this._entityFunctions()[key];\n  }\n\n  /**\n   * First expand of an entity: fetch its cached functions through the per-entity\n   * endpoint. Subsequent expands reuse the loaded copy (a finished build clears\n   * the copies so a re-expand refetches fresh data).\n   */\n  public entityOpened(entity: SemanticBuildEntity): void {\n    if (this._entityFunctions()[entity.key] !== undefined) {\n      return;\n    }\n\n    this._entityFunctions.update((loaded) => ({ ...loaded, [entity.key]: null }));\n\n    this._reportData.semanticEntityFunctions(entity.key)\n      .pipe(takeUntilDestroyed(this._destroyRef))\n      .subscribe((entityFunctions: SemanticEntityFunctions) => {\n        this._entityFunctions.update((loaded) => ({\n          ...loaded,\n          [entity.key]: {\n            ...entityFunctions,\n            functions: this._sortFunctions(entityFunctions),\n          },\n        }));\n      });\n  }\n\n  private _init(): void {\n    this._refreshStatus();\n  }\n\n  private _refreshStatus(): void {\n    this._reportData.semanticBuildStatus()\n      .pipe(takeUntilDestroyed(this._destroyRef))\n      .subscribe((status: SemanticBuildStatus) => this.status.set(status));\n  }\n\n  /**\n   * Order once at load time (kind priority, then method name) so the template\n   * renders the list as-is.\n   */\n  private _sortFunctions(entityFunctions: SemanticEntityFunctions): SemanticEntityFunctions['functions'] {\n    return [...entityFunctions.functions]\n      .sort((a, b) => {\n        const kindDiff = this._kindRank(a.kind) - this._kindRank(b.kind);\n\n        return kindDiff !== 0 ? kindDiff : a.method.localeCompare(b.method);\n      });\n  }\n\n  private _kindRank(kind: string): number {\n    const rank = SemanticDatabaseComponent.KIND_ORDER.indexOf(kind);\n\n    return rank === -1 ? SemanticDatabaseComponent.KIND_ORDER.length : rank;\n  }\n}\n","<div class=\"fs-column tab-body\">\n  <p class=\"hint\">\n    The semantic database is what the report AI uses to understand your data —\n    tables, relationships and the calculations in code. Rebuild it after\n    significant application updates. The build runs in the background; progress\n    appears in the dock at the bottom right and this dialog can be closed while\n    it runs.\n  </p>\n\n  <div *fsSkeleton=\"status()\">\n    @if (status(); as buildStatus) {\n      <div class=\"build-status\">\n        @if (buildStatus.detail.generatedAt) {\n          <div class=\"stat\">\n            <span class=\"label\">Last built</span>\n            <fs-date\n                [date]=\"buildStatus.detail.generatedAt\"\n                format=\"date-time\">\n            </fs-date>\n          </div>\n          <div class=\"stat\">\n            <span class=\"label\">Coverage</span>\n            <span>\n              {{ buildStatus.detail.entityCount }} entities ·\n              {{ buildStatus.detail.functionCount }} code functions\n            </span>\n          </div>\n        } @else {\n          <fs-message-warning>\n            The semantic database has not been built yet — the report AI can't\n            answer data questions until it is. Run the first build.\n          </fs-message-warning>\n        }\n        @if (buildStatus.build) {\n          <div class=\"stat\">\n            <span class=\"label\">Last build run</span>\n            <span>\n              {{ buildStateLabel() }}\n              @if (buildStatus.build.message) {\n                — {{ buildStatus.build.message }}\n              }\n            </span>\n          </div>\n        }\n      </div>\n\n      <!-- The model scoreboard: every entity the AI knows about, its\n           built-vs-needs-building stages, and a drill-down into its shape, enum\n           values, computed fields and AI-classified code functions. -->\n      @if (buildStatus.detail.entities?.length) {\n        <mat-accordion class=\"entities\">\n          @for (entity of buildStatus.detail.entities; track entity.key) {\n            <mat-expansion-panel (opened)=\"entityOpened(entity)\">\n              <mat-expansion-panel-header>\n                <mat-panel-title>{{ entity.key }}</mat-panel-title>\n                <mat-panel-description>\n                  <div class=\"stage-chips\">\n                    @for (stage of stageKeys; track stage) {\n                      <fs-chip\n                          size=\"tiny\"\n                          [backgroundColor]=\"stageColor(entity.stages[stage])\"\n                          color=\"#ffffff\"\n                          [matTooltip]=\"stageTooltip(entity.stages[stage])\">\n                        {{ stageLabels[stage] }}\n                      </fs-chip>\n                    }\n                  </div>\n                </mat-panel-description>\n              </mat-expansion-panel-header>\n\n              <!-- Deferred: the body (and its functions request) only exists\n                   once expanded. -->\n              <ng-template matExpansionPanelContent>\n                <div class=\"entity-detail\">\n                  <div><strong>Table:</strong> {{ entity.table }}</div>\n                  <div><strong>Columns:</strong> {{ entity.columns }}</div>\n                  <div><strong>Relationships:</strong> {{ entity.relationships }}</div>\n                  @if (entity.enums.length) {\n                    <div class=\"enum-list\">\n                      <strong>Enum values:</strong>\n                      @for (enumColumn of entity.enums; track enumColumn.column) {\n                        <div class=\"enum-row\">\n                          <span class=\"enum-column\">{{ enumColumn.column }}</span>\n                          <span class=\"enum-values\">{{ enumColumn.values.join(', ') }}</span>\n                        </div>\n                      }\n                    </div>\n                  }\n                  @if (entity.computedFields.length) {\n                    <div><strong>Computed fields:</strong> {{ entity.computedFields.join(', ') }}</div>\n                  }\n\n                  <div class=\"functions-section\">\n                    <h3 class=\"functions-heading\">\n                      Code functions\n                      @if (entity.functionCount) {\n                        <span class=\"functions-count\">({{ entity.functionCount }})</span>\n                      }\n                    </h3>\n\n                    <div class=\"functions-body\" *fsSkeleton=\"entityFunctions(entity.key)\">\n                      @if (entityFunctions(entity.key); as fns) {\n                        @if (fns.functions.length) {\n                          @if (fns.generatedAt) {\n                            <div class=\"hint functions-generated\">\n                              Discovered from {{ fns.class }} &middot;\n                              <fs-date\n                                  [date]=\"fns.generatedAt\"\n                                  format=\"date-time\">\n                              </fs-date>\n                            </div>\n                          }\n                          <div class=\"functions-list\">\n                            @for (fn of fns.functions; track fn.method) {\n                              <div class=\"function-row\">\n                                <div class=\"function-head\">\n                                  <fs-chip\n                                      size=\"tiny\"\n                                      [backgroundColor]=\"kindColor(fn.kind)\"\n                                      color=\"#ffffff\">\n                                    {{ fn.kind }}\n                                  </fs-chip>\n                                  <code class=\"function-method\">{{ fn.method }}</code>\n                                </div>\n                                <div class=\"function-summary\">{{ fn.summary }}</div>\n                                @if (fn.produces) {\n                                  <div class=\"function-produces hint\">Produces: {{ fn.produces }}</div>\n                                }\n                              </div>\n                            }\n                          </div>\n                        } @else {\n                          <div class=\"hint\">\n                            No functions cached for this entity yet — run a build to discover its code.\n                          </div>\n                        }\n                      }\n                    </div>\n                  </div>\n                </div>\n              </ng-template>\n            </mat-expansion-panel>\n          }\n        </mat-accordion>\n      }\n    }\n  </div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"semantic-database.component.js","sourceRoot":"","sources":["../../../../../../../../src/app/reports/dialogs/global-settings/components/semantic-database/semantic-database.component.ts","../../../../../../../../src/app/reports/dialogs/global-settings/components/semantic-database/semantic-database.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, DestroyRef, computed, inject, signal } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\nimport { MatExpansionModule } from '@angular/material/expansion';\nimport { MatTooltipModule } from '@angular/material/tooltip';\n\nimport { StreamEventType } from '@firestitch/api';\nimport { FsChipModule } from '@firestitch/chip';\nimport { FsDateModule } from '@firestitch/date';\nimport { FsMessage, FsMessageModule } from '@firestitch/message';\nimport { FsProcess } from '@firestitch/process';\nimport { FsPrompt } from '@firestitch/prompt';\nimport { FsSkeletonModule } from '@firestitch/skeleton';\n\nimport { filter, map, switchMap, take, tap } from 'rxjs/operators';\n\nimport { ReportData } from '../../../../data/report.data';\nimport {\n  SemanticBuildEntity,\n  SemanticBuildStage,\n  SemanticBuildStatus,\n  SemanticEntityFunctions,\n} from '../../../../interfaces/report.interface';\n\n\n// The Semantic Database tab: the model scoreboard the report AI is built from.\n// Shows the last build's status, runs (or stops) a build — streamed into the\n// FsProcess dock so it survives the dialog closing — and drills into every\n// entity to reveal its shape, inlined enum values, computed fields and the\n// AI-classified code functions cached from its model class. Each entity's\n// functions load lazily on first expand, because the full set across all\n// entities is far too big to ship with the scoreboard.\n@Component({\n  selector: 'fs-ai-report-global-settings-semantic-database',\n  templateUrl: './semantic-database.component.html',\n  styleUrls: ['./semantic-database.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  standalone: true,\n  imports: [\n    MatExpansionModule,\n    MatTooltipModule,\n    FsChipModule,\n    FsDateModule,\n    FsMessageModule,\n    FsSkeletonModule,\n  ],\n})\nexport class SemanticDatabaseComponent {\n\n  // The build-in-flight states of the ff_processes row (queued/running/stopping).\n  private static readonly ACTIVE_STATES = ['Q', 'R', 'X'];\n\n  private static readonly STATE_LABELS: Record<string, string> = {\n    Q: 'Queued',\n    R: 'Running',\n    X: 'Stopping',\n    C: 'Completed',\n    K: 'Stopped',\n    F: 'Failed',\n  };\n\n  // Scoreboard completion palette: built = green, everything else (needs\n  // building) = grey. No error red — a missing stage is unbuilt content, not a\n  // failure.\n  private static readonly DONE_COLOR = '#2e7d32';\n  private static readonly PENDING_COLOR = '#9e9e9e';\n\n  // One color per AI classification kind, so a function's nature reads at a glance.\n  private static readonly KIND_COLORS: Record<string, string> = {\n    'calculation': '#1565c0',\n    'business-rule': '#6a1b9a',\n    'query': '#00695c',\n    'mutation': '#e65100',\n    'accessor': '#546e7a',\n    'other': '#757575',\n  };\n\n  // Interesting logic first: derived values and rules, then data access, then the rest.\n  private static readonly KIND_ORDER = ['calculation', 'business-rule', 'query', 'mutation', 'accessor', 'other'];\n\n  // The scoreboard's per-entity stage chips, left to right.\n  public readonly stageKeys = ['introspected', 'enumsInlined', 'computed', 'functions'];\n\n  public readonly stageLabels: Record<string, string> = {\n    introspected: 'Introspected',\n    enumsInlined: 'Enum cases',\n    computed: 'Computed',\n    functions: 'Functions',\n  };\n\n  // null until loaded — gates the tab behind the skeleton.\n  public readonly status = signal<SemanticBuildStatus | null>(null);\n\n  // True while a build started from this tab is streaming into the dock.\n  public readonly building = signal(false);\n\n  public readonly buildActive = computed<boolean>(() =>\n    this.building()\n      || SemanticDatabaseComponent.ACTIVE_STATES.includes(this.status()?.build?.state),\n  );\n\n  public readonly buildStateLabel = computed<string>(() =>\n    SemanticDatabaseComponent.STATE_LABELS[this.status()?.build?.state] ?? '',\n  );\n\n  // Per-entity function caches, loaded on first expand. undefined = not\n  // requested yet, null = request in flight (the skeleton window), object = loaded.\n  private readonly _entityFunctions = signal<Record<string, SemanticEntityFunctions | null>>({});\n\n  // Guards the outcome message to fire exactly once per run — whether the stream\n  // completes (build finished, possibly failed) or errors outright.\n  private _buildFinalized = false;\n\n  private readonly _reportData = inject(ReportData);\n  private readonly _process = inject(FsProcess);\n  private readonly _prompt = inject(FsPrompt);\n  private readonly _message = inject(FsMessage);\n  private readonly _destroyRef = inject(DestroyRef);\n\n  constructor() {\n    this._init();\n  }\n\n  // Confirm before kicking off a build — a rebuild replaces the current\n  // semantic database, so it should never fire on a stray click.\n  public build(): void {\n    const rebuild = !!this.status()?.detail?.generatedAt;\n\n    this._prompt.confirm({\n      title: rebuild ? 'Rebuild semantic database' : 'Build semantic database',\n      template: rebuild\n        ? 'Rebuild the semantic database? It runs in the background and replaces the current one when it finishes.'\n        : 'Build the semantic database? It runs in the background.',\n      commitLabel: rebuild ? 'Rebuild' : 'Build',\n    })\n      .pipe(takeUntilDestroyed(this._destroyRef))\n      .subscribe(() => this._runBuild());\n  }\n\n  public stopBuild(): void {\n    this._prompt.confirm({\n      title: 'Stop build',\n      template: 'Stop the running build? The current semantic database stays in place until a build finishes.',\n      commitLabel: 'Stop',\n    })\n      .pipe(\n        switchMap(() => this._reportData.semanticBuildStop()),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(() => {\n        this.building.set(false);\n        this._message.success('Stopping the build…');\n        this._refreshStatus();\n      });\n  }\n\n  // Run the semantic-database build. The live feed streams into the FsProcess\n  // dock (bottom-right), whose subscription survives this dialog closing — so\n  // dismissing the dialog never interrupts a running build.\n  private _runBuild(): void {\n    this.building.set(true);\n    this._buildFinalized = false;\n\n    const target$ = this._reportData.semanticBuild()\n      .pipe(\n        // A hard stream/transport failure (the build couldn't even start)\n        // finalizes here — completed$ won't fire in that case.\n        tap({ error: (error) => this._finalizeBuild(error) }),\n        filter((event) =>\n          event?.type === StreamEventType.Data\n          && event.data?.kind === 'log'\n          && typeof event.data.line === 'string'),\n        map((event) => event.data.line as string),\n      );\n\n    this._process\n      .run('Semantic database build', target$)\n      .completed$\n      .pipe(\n        take(1),\n        takeUntilDestroyed(this._destroyRef),\n      )\n      .subscribe(() => this._finalizeBuild(null));\n  }\n\n  /**\n   * Wrap up one build run exactly once. On a hard stream error there is no\n   * status to read, so say so directly; otherwise refresh the status and\n   * announce how the build actually ended — a build that failed (e.g. the AI\n   * couldn't be reached) reports 'Failed' with a reason, and that must surface\n   * instead of the run silently doing nothing.\n   */\n  private _finalizeBuild(streamError: unknown): void {\n    if (this._buildFinalized) {\n      return;\n    }\n    this._buildFinalized = true;\n\n    this.building.set(false);\n    // The build rewrote every entity's function cache — drop the loaded copies\n    // so the next expand refetches fresh data.\n    this._entityFunctions.set({});\n\n    if (streamError) {\n      this._message.error('The semantic database build could not run — check the AI connection and try again.');\n      this._refreshStatus();\n\n      return;\n    }\n\n    this._reportData.semanticBuildStatus()\n      .pipe(takeUntilDestroyed(this._destroyRef))\n      .subscribe((status: SemanticBuildStatus) => {\n        this.status.set(status);\n        this._announceOutcome(status);\n      });\n  }\n\n  /**\n   * Tell the operator how the build ended: a failed/stopped build surfaces its\n   * reason (so an AI connection problem is never silent), a completed one\n   * confirms success.\n   */\n  private _announceOutcome(status: SemanticBuildStatus): void {\n    const build = status?.build;\n    if (build?.state === 'F' || build?.state === 'K') {\n      this._message.error(build.message || 'The semantic database build did not finish.');\n    } else if (build?.state === 'C') {\n      this._message.success('Semantic database build complete.');\n    }\n  }\n\n  public stageColor(stage: SemanticBuildStage): string {\n    return stage === 'done'\n      ? SemanticDatabaseComponent.DONE_COLOR\n      : SemanticDatabaseComponent.PENDING_COLOR;\n  }\n\n  public stageTooltip(stage: SemanticBuildStage): string {\n    return stage === 'done' ? 'Built' : 'Needs building';\n  }\n\n  public kindColor(kind: string): string {\n    return SemanticDatabaseComponent.KIND_COLORS[kind] ?? SemanticDatabaseComponent.KIND_COLORS.other;\n  }\n\n  /**\n   * The loaded function cache for an entity: undefined until the panel is first\n   * expanded, null while the request is in flight (the skeleton window), then\n   * the loaded cache.\n   */\n  public entityFunctions(key: string): SemanticEntityFunctions | null | undefined {\n    return this._entityFunctions()[key];\n  }\n\n  /**\n   * First expand of an entity: fetch its cached functions through the per-entity\n   * endpoint. Subsequent expands reuse the loaded copy (a finished build clears\n   * the copies so a re-expand refetches fresh data).\n   */\n  public entityOpened(entity: SemanticBuildEntity): void {\n    if (this._entityFunctions()[entity.key] !== undefined) {\n      return;\n    }\n\n    this._entityFunctions.update((loaded) => ({ ...loaded, [entity.key]: null }));\n\n    this._reportData.semanticEntityFunctions(entity.key)\n      .pipe(takeUntilDestroyed(this._destroyRef))\n      .subscribe((entityFunctions: SemanticEntityFunctions) => {\n        this._entityFunctions.update((loaded) => ({\n          ...loaded,\n          [entity.key]: {\n            ...entityFunctions,\n            functions: this._sortFunctions(entityFunctions),\n          },\n        }));\n      });\n  }\n\n  private _init(): void {\n    this._refreshStatus();\n  }\n\n  private _refreshStatus(): void {\n    this._reportData.semanticBuildStatus()\n      .pipe(takeUntilDestroyed(this._destroyRef))\n      .subscribe((status: SemanticBuildStatus) => this.status.set(status));\n  }\n\n  /**\n   * Order once at load time (kind priority, then method name) so the template\n   * renders the list as-is.\n   */\n  private _sortFunctions(entityFunctions: SemanticEntityFunctions): SemanticEntityFunctions['functions'] {\n    return [...entityFunctions.functions]\n      .sort((a, b) => {\n        const kindDiff = this._kindRank(a.kind) - this._kindRank(b.kind);\n\n        return kindDiff !== 0 ? kindDiff : a.method.localeCompare(b.method);\n      });\n  }\n\n  private _kindRank(kind: string): number {\n    const rank = SemanticDatabaseComponent.KIND_ORDER.indexOf(kind);\n\n    return rank === -1 ? SemanticDatabaseComponent.KIND_ORDER.length : rank;\n  }\n}\n","<div class=\"fs-column tab-body\">\n  <p class=\"hint\">\n    The semantic database is what the report AI uses to understand your data —\n    tables, relationships and the calculations in code. Rebuild it after\n    significant application updates. The build runs in the background; progress\n    appears in the dock at the bottom right and this dialog can be closed while\n    it runs.\n  </p>\n\n  <div *fsSkeleton=\"status()\">\n    @if (status(); as buildStatus) {\n      <div class=\"build-status\">\n        @if (buildStatus.detail.generatedAt) {\n          <div class=\"stat\">\n            <span class=\"label\">Last built</span>\n            <fs-date\n                [date]=\"buildStatus.detail.generatedAt\"\n                format=\"date-time\">\n            </fs-date>\n          </div>\n          <div class=\"stat\">\n            <span class=\"label\">Coverage</span>\n            <span>\n              {{ buildStatus.detail.entityCount }} entities ·\n              {{ buildStatus.detail.functionCount }} code functions\n            </span>\n          </div>\n        } @else {\n          <fs-message-warning>\n            The semantic database has not been built yet — the report AI can't\n            answer data questions until it is. Run the first build.\n          </fs-message-warning>\n        }\n        @if (buildStatus.build) {\n          <div class=\"stat\">\n            <span class=\"label\">Last build run</span>\n            <span>\n              {{ buildStateLabel() }}\n              @if (buildStatus.build.message) {\n                — {{ buildStatus.build.message }}\n              }\n            </span>\n          </div>\n        }\n      </div>\n\n      <!-- The model scoreboard: every entity the AI knows about, its\n           built-vs-needs-building stages, and a drill-down into its shape, enum\n           values, computed fields and AI-classified code functions. -->\n      @if (buildStatus.detail.entities?.length) {\n        <mat-accordion class=\"entities\">\n          @for (entity of buildStatus.detail.entities; track entity.key) {\n            <mat-expansion-panel (opened)=\"entityOpened(entity)\">\n              <mat-expansion-panel-header>\n                <mat-panel-title>{{ entity.key }}</mat-panel-title>\n                <mat-panel-description>\n                  <div class=\"stage-chips\">\n                    @for (stage of stageKeys; track stage) {\n                      <fs-chip\n                          size=\"tiny\"\n                          [backgroundColor]=\"stageColor(entity.stages[stage])\"\n                          color=\"#ffffff\"\n                          [matTooltip]=\"stageTooltip(entity.stages[stage])\">\n                        {{ stageLabels[stage] }}\n                      </fs-chip>\n                    }\n                  </div>\n                </mat-panel-description>\n              </mat-expansion-panel-header>\n\n              <!-- Deferred: the body (and its functions request) only exists\n                   once expanded. -->\n              <ng-template matExpansionPanelContent>\n                <div class=\"entity-detail\">\n                  <div><strong>Table:</strong> {{ entity.table }}</div>\n                  <div><strong>Columns:</strong> {{ entity.columns }}</div>\n                  <div><strong>Relationships:</strong> {{ entity.relationships }}</div>\n                  @if (entity.enums.length) {\n                    <div class=\"enum-list\">\n                      <strong>Enum values:</strong>\n                      @for (enumColumn of entity.enums; track enumColumn.column) {\n                        <div class=\"enum-row\">\n                          <span class=\"enum-column\">{{ enumColumn.column }}</span>\n                          <span class=\"enum-values\">{{ enumColumn.values.join(', ') }}</span>\n                        </div>\n                      }\n                    </div>\n                  }\n                  @if (entity.computedFields.length) {\n                    <div><strong>Computed fields:</strong> {{ entity.computedFields.join(', ') }}</div>\n                  }\n\n                  <div class=\"functions-section\">\n                    <h3 class=\"functions-heading\">\n                      Code functions\n                      @if (entity.functionCount) {\n                        <span class=\"functions-count\">({{ entity.functionCount }})</span>\n                      }\n                    </h3>\n\n                    <div class=\"functions-body\" *fsSkeleton=\"entityFunctions(entity.key)\">\n                      @if (entityFunctions(entity.key); as fns) {\n                        @if (fns.functions.length) {\n                          @if (fns.generatedAt) {\n                            <div class=\"hint functions-generated\">\n                              Discovered from {{ fns.class }} &middot;\n                              <fs-date\n                                  [date]=\"fns.generatedAt\"\n                                  format=\"date-time\">\n                              </fs-date>\n                            </div>\n                          }\n                          <div class=\"functions-list\">\n                            @for (fn of fns.functions; track fn.method) {\n                              <div class=\"function-row\">\n                                <div class=\"function-head\">\n                                  <fs-chip\n                                      size=\"tiny\"\n                                      [backgroundColor]=\"kindColor(fn.kind)\"\n                                      color=\"#ffffff\">\n                                    {{ fn.kind }}\n                                  </fs-chip>\n                                  <code class=\"function-method\">{{ fn.method }}</code>\n                                </div>\n                                <div class=\"function-summary\">{{ fn.summary }}</div>\n                                @if (fn.produces) {\n                                  <div class=\"function-produces hint\">Produces: {{ fn.produces }}</div>\n                                }\n                              </div>\n                            }\n                          </div>\n                        } @else {\n                          <div class=\"hint\">\n                            No functions cached for this entity yet — run a build to discover its code.\n                          </div>\n                        }\n                      }\n                    </div>\n                  </div>\n                </div>\n              </ng-template>\n            </mat-expansion-panel>\n          }\n        </mat-accordion>\n      }\n    }\n  </div>\n</div>\n"]}