@firestitch/report 18.0.7 → 18.0.9

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

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

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

@@ -0,0 +1,8 @@
+import { FsMarkdownEditorConfig } from '@firestitch/markdown-editor';
+import * as i0 from "@angular/core";
+export declare class AiKnowledgeComponent {
+    readonly content: import("@angular/core").ModelSignal<string>;
+    readonly config: import("@angular/core").InputSignal<FsMarkdownEditorConfig>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiKnowledgeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AiKnowledgeComponent, "fs-ai-report-global-settings-ai-knowledge", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": true; "isSignal": true; }; }, { "content": "contentChange"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,8 @@
+import { ReportInstruction } from '../../../../interfaces/report.interface';
+import * as i0 from "@angular/core";
+export declare class HistoryComponent {
+    readonly versions: import("@angular/core").InputSignal<ReportInstruction[]>;
+    readonly restore: import("@angular/core").OutputEmitterRef<ReportInstruction>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HistoryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HistoryComponent, "fs-ai-report-global-settings-history", never, { "versions": { "alias": "versions"; "required": true; "isSignal": true; }; }, { "restore": "restore"; }, never, never, true, never>;
+}

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

@@ -0,0 +1,50 @@
+import { SemanticBuildEntity, SemanticBuildStage, SemanticBuildStatus, SemanticEntityFunctions } from '../../../../interfaces/report.interface';
+import * as i0 from "@angular/core";
+export declare class SemanticDatabaseComponent {
+    private static readonly ACTIVE_STATES;
+    private static readonly STATE_LABELS;
+    private static readonly DONE_COLOR;
+    private static readonly PENDING_COLOR;
+    private static readonly KIND_COLORS;
+    private static readonly KIND_ORDER;
+    readonly stageKeys: string[];
+    readonly stageLabels: Record<string, string>;
+    readonly status: import("@angular/core").WritableSignal<SemanticBuildStatus>;
+    readonly building: import("@angular/core").WritableSignal<boolean>;
+    readonly buildActive: import("@angular/core").Signal<boolean>;
+    readonly buildStateLabel: import("@angular/core").Signal<string>;
+    private readonly _entityFunctions;
+    private readonly _reportData;
+    private readonly _process;
+    private readonly _prompt;
+    private readonly _message;
+    private readonly _destroyRef;
+    constructor();
+    build(): void;
+    stopBuild(): void;
+    stageColor(stage: SemanticBuildStage): string;
+    stageTooltip(stage: SemanticBuildStage): string;
+    kindColor(kind: string): string;
+    /**
+     * The loaded function cache for an entity: undefined until the panel is first
+     * expanded, null while the request is in flight (the skeleton window), then
+     * the loaded cache.
+     */
+    entityFunctions(key: string): SemanticEntityFunctions | null | undefined;
+    /**
+     * First expand of an entity: fetch its cached functions through the per-entity
+     * endpoint. Subsequent expands reuse the loaded copy (a finished build clears
+     * the copies so a re-expand refetches fresh data).
+     */
+    entityOpened(entity: SemanticBuildEntity): void;
+    private _init;
+    private _refreshStatus;
+    /**
+     * Order once at load time (kind priority, then method name) so the template
+     * renders the list as-is.
+     */
+    private _sortFunctions;
+    private _kindRank;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SemanticDatabaseComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SemanticDatabaseComponent, "fs-ai-report-global-settings-semantic-database", never, {}, {}, never, never, true, never>;
+}

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

@@ -1,30 +1,20 @@
-import { OnInit } from '@angular/core';
 import { FsMarkdownEditorConfig } from '@firestitch/markdown-editor';
-import { ReportInstruction, ReportInstructions, SemanticBuildStatus } from '../../interfaces/report.interface';
+import { ReportInstruction, ReportInstructions } from '../../interfaces/report.interface';
 import * as i0 from "@angular/core";
-export declare class GlobalSettingsComponent implements OnInit {
-    private static readonly ACTIVE_STATES;
-    private static readonly STATE_LABELS;
+export declare class GlobalSettingsComponent {
     selectedTab: string;
-    content: string;
-    editorConfig: FsMarkdownEditorConfig;
+    readonly content: import("@angular/core").WritableSignal<string>;
+    readonly editorConfig: FsMarkdownEditorConfig;
     readonly instructions: import("@angular/core").WritableSignal<ReportInstructions>;
-    readonly status: import("@angular/core").WritableSignal<SemanticBuildStatus>;
-    readonly building: import("@angular/core").WritableSignal<boolean>;
-    readonly buildActive: import("@angular/core").Signal<boolean>;
-    readonly buildStateLabel: import("@angular/core").Signal<string>;
     private readonly _dialogRef;
     private readonly _reportData;
     private readonly _message;
     private readonly _prompt;
-    private readonly _process;
     private readonly _destroyRef;
-    ngOnInit(): void;
+    constructor();
     save: () => import("rxjs").Observable<ReportInstructions>;
     restore(version: ReportInstruction): void;
-    build(): void;
-    stopBuild(): void;
-    private _refreshStatus;
+    private _init;
     private _applyInstructions;
     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

@@ -198,10 +198,39 @@ export interface SemanticBuild {
     startDate: Date;
     endDate: Date;
 }
+export type SemanticBuildStage = 'done' | 'missing';
+export interface SemanticBuildEnum {
+    column: string;
+    values: string[];
+}
+export interface SemanticBuildEntity {
+    key: string;
+    table: string;
+    columns: number;
+    relationships: number;
+    enums: SemanticBuildEnum[];
+    computedFields: string[];
+    functionCount: number;
+    stages: Record<string, SemanticBuildStage>;
+}
 export interface SemanticBuildDetail {
     generatedAt: Date | null;
     entityCount: number;
     functionCount: number;
+    entities: SemanticBuildEntity[];
+}
+export interface SemanticEntityFunction {
+    method: string;
+    signature: string;
+    kind: string;
+    summary: string;
+    produces: string;
+}
+export interface SemanticEntityFunctions {
+    entity: string;
+    generatedAt: Date | null;
+    class: string | null;
+    functions: SemanticEntityFunction[];
 }
 export interface SemanticBuildStatus {
     build: SemanticBuild | null;

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

@@ -176,6 +176,15 @@ export class ReportData {
             ...config,
         });
     }
+    // One entity's cached AI-classified code functions — loaded on expand, one
+    // entity at a time, because the full set across all entities is far too big
+    // to ship inside the scoreboard call.
+    semanticEntityFunctions(entity, config = {}) {
+        return this._api.get(this._path(`semantic/entities/${entity}/functions`), {}, {
+            key: 'entityFunctions',
+            ...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
@@ -195,4 +204,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  // 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  // 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/ai-knowledge/ai-knowledge.component.mjs

@@ -0,0 +1,31 @@
+import { ChangeDetectionStrategy, Component, input, model } from '@angular/core';
+import { ControlContainer, FormsModule, NgForm } from '@angular/forms';
+import { FsFormModule } from '@firestitch/form';
+import { FsMarkdownEditorComponent } from '@firestitch/markdown-editor';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@firestitch/form";
+// The AI Knowledge tab: the operator-authored markdown document appended to the
+// report agent's system instructions on every chat turn — the lever for
+// terminology, business rules and special cases no code deploy can cover.
+//
+// A field-level child of the settings dialog form: the editor registers with
+// the parent <form fsForm> via the ControlContainer view provider, so the
+// dialog's Save button submits and validates this content. The draft itself
+// lives on the parent (bound through `content`), so switching tabs never loses
+// an edit.
+export class AiKnowledgeComponent {
+    content = model('');
+    config = input.required();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AiKnowledgeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.14", type: AiKnowledgeComponent, isStandalone: true, selector: "fs-ai-report-global-settings-ai-knowledge", inputs: { content: { classPropertyName: "content", publicName: "content", isSignal: true, isRequired: false, transformFunction: null }, config: { classPropertyName: "config", publicName: "config", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { content: "contentChange" }, ngImport: i0, template: "<div class=\"fs-column tab-body\">\n  <p class=\"hint\">\n    This document is given to the report AI on every chat message. Use it for\n    terminology, business rules and special cases the AI can't work out from the\n    data on its own \u2014 it takes effect immediately, no deploy needed.\n  </p>\n  <fs-markdown-editor\n      [ngModel]=\"content()\"\n      (ngModelChange)=\"content.set($event)\"\n      [config]=\"config()\"\n      name=\"content\">\n  </fs-markdown-editor>\n</div>\n", styles: [".tab-body{padding-top:16px}.hint{margin:0 0 12px;color:#0009;font-size:13px;line-height:1.5}fs-markdown-editor{display:block;min-height:320px}\n"], dependencies: [{ kind: "ngmodule", type: FormsModule }, { 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.FsFormNoFsValidatorsDirective, selector: "[ngModel]:not([required]):not([fsFormRequired]):not([fsFormCompare]):not([fsFormDateRange]):not([fsFormEmail]):not([fsFormEmails]):not([fsFormFunction]):not([fsFormGreater]):not([fsFormGreaterEqual]):not([fsFormInteger]):not([fsFormLesser]):not([fsFormMax]):not([fsFormMaxLength]):not([fsFormMin]):not([fsFormMinLength]):not([fsFormNumeric]):not([fsFormPattern]):not([fsFormPhone]):not([fsFormUrl]):not([validate])" }, { kind: "component", type: FsMarkdownEditorComponent, selector: "fs-markdown-editor", inputs: ["config", "disabled"] }], viewProviders: [{ provide: ControlContainer, useExisting: NgForm }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AiKnowledgeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'fs-ai-report-global-settings-ai-knowledge', viewProviders: [{ provide: ControlContainer, useExisting: NgForm }], changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        FormsModule,
+                        FsFormModule,
+                        FsMarkdownEditorComponent,
+                    ], template: "<div class=\"fs-column tab-body\">\n  <p class=\"hint\">\n    This document is given to the report AI on every chat message. Use it for\n    terminology, business rules and special cases the AI can't work out from the\n    data on its own \u2014 it takes effect immediately, no deploy needed.\n  </p>\n  <fs-markdown-editor\n      [ngModel]=\"content()\"\n      (ngModelChange)=\"content.set($event)\"\n      [config]=\"config()\"\n      name=\"content\">\n  </fs-markdown-editor>\n</div>\n", styles: [".tab-body{padding-top:16px}.hint{margin:0 0 12px;color:#0009;font-size:13px;line-height:1.5}fs-markdown-editor{display:block;min-height:320px}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,32 @@
+import { ChangeDetectionStrategy, Component, input, output } from '@angular/core';
+import { MatButton } from '@angular/material/button';
+import { FsChipModule } from '@firestitch/chip';
+import { FsDateModule } from '@firestitch/date';
+import { FsMarkdownRendererComponent } from '@firestitch/markdown-editor';
+import { FsMessageModule } from '@firestitch/message';
+import * as i0 from "@angular/core";
+import * as i1 from "@firestitch/chip";
+import * as i2 from "@firestitch/date";
+import * as i3 from "@firestitch/message";
+// The History tab: every saved version of the AI Knowledge document
+// (append-only), each previewed and restorable. Restoring mutates the current
+// version and reseeds the editor — a parent concern — so this stays
+// presentational: it renders the versions it is given and emits the one to
+// restore.
+export class HistoryComponent {
+    versions = input.required();
+    restore = output();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HistoryComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: HistoryComponent, isStandalone: true, selector: "fs-ai-report-global-settings-history", inputs: { versions: { classPropertyName: "versions", publicName: "versions", isSignal: true, isRequired: true, transformFunction: null } }, outputs: { restore: "restore" }, ngImport: i0, template: "<div class=\"fs-column tab-body\">\n  @if (versions().length) {\n    @for (version of versions(); track version.id) {\n      <div class=\"version\">\n        <div class=\"version-header\">\n          <fs-date\n              [date]=\"version.createDate\"\n              format=\"date-time\">\n          </fs-date>\n          @if (version.accountName) {\n            <span class=\"author\">{{ version.accountName }}</span>\n          }\n          <span class=\"spacer\"></span>\n          @if (version.current) {\n            <fs-chip\n                size=\"tiny\"\n                [backgroundColor]=\"'#2e7d32'\"\n                color=\"#ffffff\">\n              Current\n            </fs-chip>\n          } @else {\n            <button\n                type=\"button\"\n                mat-stroked-button\n                (click)=\"restore.emit(version)\">\n              Restore\n            </button>\n          }\n        </div>\n        <div class=\"version-preview\">\n          <fs-markdown-renderer [markdown]=\"version.content\"></fs-markdown-renderer>\n        </div>\n      </div>\n    }\n  } @else {\n    <fs-message-info>\n      No versions yet \u2014 every save of the AI Knowledge document lands here, and\n      any version can be restored.\n    </fs-message-info>\n  }\n</div>\n", styles: [".tab-body{padding-top:16px}.version{border:1px solid rgba(0,0,0,.12);border-radius:6px;padding:12px}.version+.version{margin-top:12px}.version .version-header{display:flex;align-items:center;gap:8px}.version .version-header .author{color:#0009}.version .version-header .spacer{flex:1}.version .version-preview{margin-top:8px;max-height:200px;overflow-y:auto;border-top:1px solid rgba(0,0,0,.08);padding-top:8px}\n"], dependencies: [{ kind: "component", type: MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "ngmodule", type: FsChipModule }, { kind: "component", type: i1.FsChipComponent, selector: "fs-chip", inputs: ["selectable", "removable", "value", "maxWidth", "width", "backgroundColor", "borderColor", "color", "shape", "outlined", "outlineDash", "icon", "image", "selected", "disabled", "padding", "contrastColor", "size"], outputs: ["selectedToggled", "removed", "click"] }, { kind: "ngmodule", type: FsDateModule }, { kind: "component", type: i2.FsDateComponent, selector: "fs-date", inputs: ["date", "format", "timezone"] }, { kind: "ngmodule", type: FsMessageModule }, { kind: "component", type: i3.FsMessageInfoComponent, selector: "fs-message-info" }, { kind: "component", type: FsMarkdownRendererComponent, selector: "fs-markdown-renderer", inputs: ["config", "markdown"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HistoryComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'fs-ai-report-global-settings-history', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [
+                        MatButton,
+                        FsChipModule,
+                        FsDateModule,
+                        FsMessageModule,
+                        FsMarkdownRendererComponent,
+                    ], template: "<div class=\"fs-column tab-body\">\n  @if (versions().length) {\n    @for (version of versions(); track version.id) {\n      <div class=\"version\">\n        <div class=\"version-header\">\n          <fs-date\n              [date]=\"version.createDate\"\n              format=\"date-time\">\n          </fs-date>\n          @if (version.accountName) {\n            <span class=\"author\">{{ version.accountName }}</span>\n          }\n          <span class=\"spacer\"></span>\n          @if (version.current) {\n            <fs-chip\n                size=\"tiny\"\n                [backgroundColor]=\"'#2e7d32'\"\n                color=\"#ffffff\">\n              Current\n            </fs-chip>\n          } @else {\n            <button\n                type=\"button\"\n                mat-stroked-button\n                (click)=\"restore.emit(version)\">\n              Restore\n            </button>\n          }\n        </div>\n        <div class=\"version-preview\">\n          <fs-markdown-renderer [markdown]=\"version.content\"></fs-markdown-renderer>\n        </div>\n      </div>\n    }\n  } @else {\n    <fs-message-info>\n      No versions yet \u2014 every save of the AI Knowledge document lands here, and\n      any version can be restored.\n    </fs-message-info>\n  }\n</div>\n", styles: [".tab-body{padding-top:16px}.version{border:1px solid rgba(0,0,0,.12);border-radius:6px;padding:12px}.version+.version{margin-top:12px}.version .version-header{display:flex;align-items:center;gap:8px}.version .version-header .author{color:#0009}.version .version-header .spacer{flex:1}.version .version-preview{margin-top:8px;max-height:200px;overflow-y:auto;border-top:1px solid rgba(0,0,0,.08);padding-top:8px}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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