@fallen-8/studio 0.0.37 → 0.0.39

package/dist-lib/{javascript-CVQBymBa.js → javascript-E9zK2eIG.js}

@@ -1,4 +1,4 @@
-import { conf as t, language as e } from "./typescript-LNGesWYR.js";
+import { conf as t, language as e } from "./typescript-BqWn12P7.js";
 var i = t, o = {
   // Set defaultToken to invalid to see what you do not tokenize yet
   defaultToken: "invalid",

package/dist-lib/{jsonMode-B3hcJ0l3.js → jsonMode-BmT8sixk.js}

@@ -1,4 +1,4 @@
-import { m as Et } from "./index-BQbFjItv.js";
+import { m as Et } from "./index-CGOXemLg.js";
 var Lt = Object.defineProperty, Ot = Object.getOwnPropertyDescriptor, Nt = Object.getOwnPropertyNames, Rt = Object.prototype.hasOwnProperty, Mt = (e, r, i, n) => {
   if (r && typeof r == "object" || typeof r == "function")
     for (let t of Nt(r))

package/dist-lib/{liquid-DLrt4Cls.js → liquid-mEomZ5zY.js}

@@ -1,4 +1,4 @@
-import { m as l } from "./index-BQbFjItv.js";
+import { m as l } from "./index-CGOXemLg.js";
 var d = Object.defineProperty, s = Object.getOwnPropertyDescriptor, c = Object.getOwnPropertyNames, u = Object.prototype.hasOwnProperty, m = (t, e, r, n) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let i of c(e))

package/dist-lib/{mdx-DePkemui.js → mdx-poAEdYDh.js}

@@ -1,4 +1,4 @@
-import { m as s } from "./index-BQbFjItv.js";
+import { m as s } from "./index-CGOXemLg.js";
 var d = Object.defineProperty, c = Object.getOwnPropertyDescriptor, p = Object.getOwnPropertyNames, a = Object.prototype.hasOwnProperty, k = (n, e, i, r) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let o of p(e))

package/dist-lib/{python-CUe0bWsE.js → python-BkeUbXrt.js}

@@ -1,4 +1,4 @@
-import { m as o } from "./index-BQbFjItv.js";
+import { m as o } from "./index-CGOXemLg.js";
 var a = Object.defineProperty, l = Object.getOwnPropertyDescriptor, p = Object.getOwnPropertyNames, c = Object.prototype.hasOwnProperty, g = (t, e, n, s) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let r of p(e))

package/dist-lib/{razor-DD_zUh3z.js → razor-CSXbiZmb.js}

@@ -1,4 +1,4 @@
-import { m } from "./index-BQbFjItv.js";
+import { m } from "./index-CGOXemLg.js";
 var s = Object.defineProperty, c = Object.getOwnPropertyDescriptor, l = Object.getOwnPropertyNames, d = Object.prototype.hasOwnProperty, p = (t, e, o, n) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let r of l(e))

package/dist-lib/{tsMode-Ae3UtOmp.js → tsMode-jcKLVReC.js}

@@ -1,4 +1,4 @@
-import { t as O, m as I } from "./index-BQbFjItv.js";
+import { t as O, m as I } from "./index-CGOXemLg.js";
 var N = Object.defineProperty, M = Object.getOwnPropertyDescriptor, R = Object.getOwnPropertyNames, K = Object.prototype.hasOwnProperty, E = (e, t, i, o) => {
   if (t && typeof t == "object" || typeof t == "function")
     for (let n of R(t))

package/dist-lib/types/api/client.d.ts

@@ -96,6 +96,13 @@ export declare function resolveAuthHeaders(instance: InstanceConfig): Promise<Re
  * Shared by {@link apiRequest} and the raw-fetch bulk endpoints so every failure looks the same.
  */
 export declare function throwIfNotOk(response: Response, url: string): Promise<void>;
+/**
+ * Turns one non-ok answer into an {@link ApiError}, whatever transport read it. Separate from
+ * {@link throwIfNotOk} because {@link apiUpload} goes through XMLHttpRequest and has no
+ * `Response`, and a second copy of this would be a second place for the namespace announcement
+ * below to go stale.
+ */
+export declare function raiseApiError(status: number, url: string, body: string): never;
 /**
  * One request's deadline: a signal that aborts when the caller's does OR when the timeout expires,
  * and a flag saying which of the two happened.
@@ -119,3 +126,45 @@ export declare function apiRequest<T>(instance: InstanceConfig, path: string, op
  * itself, so no Content-Type is written here.
  */
 export declare function apiForm<T>(instance: InstanceConfig, path: string, form: FormData, options?: Pick<RequestOptions, "signal" | "scope">): Promise<T | null>;
+/**
+ * Whether a failure is somebody having cancelled rather than something having gone wrong.
+ *
+ * It exists because react-query does NOT treat an aborted MUTATION as a cancellation the way it
+ * treats an aborted query: the mutation moves to `isError` with the abort as its error, so a call
+ * site that renders `isError` puts a red box on the screen of the person who just pressed cancel.
+ *
+ * Matched on the NAME alone, deliberately. Neither `instanceof DOMException` nor `instanceof Error`
+ * can be relied on here: jsdom's `DOMException` does not extend `Error`, so an `instanceof Error`
+ * check passes in a browser and fails in the test suite - which is the worst of both, a guard that
+ * is only absent where it is being verified. Every abort reason carries this name, whatever its
+ * class.
+ */
+export declare function wasCancelled(error: unknown): boolean;
+/** How far a send has got. `total` is null when the browser will not say how much there is. */
+export interface UploadProgress {
+    sent: number;
+    total: number | null;
+}
+/**
+ * Multipart POST that reports how far the SEND has got (feature integration-file-transport).
+ *
+ * XMLHttpRequest and not `fetch`, for one reason: fetch cannot report upload progress. A
+ * `ReadableStream` request body can, but it requires HTTP/2 and `duplex: "half"`, is unsupported in
+ * Safari, and would make progress depend on the transport an instance happens to be reached over.
+ * XHR reports it everywhere, so this is a deliberate exception rather than legacy code, and it is
+ * the ONLY one: everything without a progress bar goes through {@link apiForm}.
+ *
+ * The progress matters because of what this carries. An integration job may be gigabytes of
+ * extracts, and a send with no feedback is indistinguishable from a hang - which is exactly what
+ * the operator who prompted this feature reported: they pressed run, saw nothing for minutes, and
+ * then got an error.
+ *
+ * Failures are shaped like every other call's: an {@link ApiError} for a status, an abort rethrown
+ * as an abort so react-query reads it as a cancellation, and a `TypeError` for a transport failure,
+ * which is the same class `fetch` throws and which `ErrorBox` renders as an unreachable instance.
+ */
+export declare function apiUpload<T>(instance: InstanceConfig, path: string, form: FormData, options?: {
+    signal?: AbortSignal;
+    scope?: "namespace" | "fallen8";
+    onProgress?: (progress: UploadProgress) => void;
+}): Promise<T | null>;

package/dist-lib/types/api/endpoints.d.ts

@@ -1,5 +1,6 @@
+import type { UploadProgress } from "./client";
 import type { InstanceConfig } from "../instances/types";
-import type { AnalyticsResultREST, DocumentBinding, DocumentDetail, DocumentEntityList, DocumentList, DocumentSearchResult, DocumentSearchSpecification, DocumentSummary, IngestTextSpecification, IntegrationJobRequest, IntegrationRunAccepted, IntegrationRunState, IntegrationProvider, NamespaceActivationREST, NamespaceEntry, NamespacesResponse, NamespaceTriState, AnalyticsSpecification, BenchmarkResult, BulkImportResultREST, GraphGenerationResult, AlgorithmPluginRegistration, DelegateKind, DelegateValidationResult, EdgeREST, EmbedElementSpecification, FunctionPluginRegistration, GraphFunctionResultREST, PluginAuthoringCategory, PluginDetailREST, PluginSummaryREST, PluginValidationResult, PluginValidationSpecification, ConfigREST, ConfigWriteREST, ConfigWriteSpec, ChatCompletionSpec, ChatCompletionResultREST, EmbeddingSearchSpecification, EmbeddingWriteSpecification, SaveGame, EdgeSpecification, FulltextIndexScanSpecification, FulltextSearchResultREST, GraphREST, GraphStatisticsREST, IndexAddToSpecification, IndexKeySpecification, IndexScanSpecification, PartitionMembersREST, PathREST, PathSpecification, PluginSpecification, PropertySearchSpecification, PropertySpecification, RangeIndexScanSpecification, ScanSpecification, SearchDistanceSpecification, GraphElementBatchREST, StatusREST, StoredQueryDetailREST, StoredQuerySpecification, StoredQuerySummaryREST, SubGraphSpecification, SubGraphSummary, VectorIndexAddSpecification, VectorIndexScanSpecification, VectorSearchResultREST, VertexREST, VertexSpecification } from "./types";
+import type { AnalyticsResultREST, DocumentBinding, DocumentDetail, DocumentEntityList, DocumentList, DocumentSearchResult, DocumentSearchSpecification, DocumentSummary, FileLimits, IngestTextSpecification, IntegrationJobRequest, IntegrationRunAccepted, IntegrationRunState, IntegrationProvider, NamespaceActivationREST, NamespaceEntry, NamespacesResponse, NamespaceTriState, AnalyticsSpecification, BenchmarkResult, BulkImportResultREST, GraphGenerationResult, AlgorithmPluginRegistration, DelegateKind, DelegateValidationResult, EdgeREST, EmbedElementSpecification, FunctionPluginRegistration, GraphFunctionResultREST, PluginAuthoringCategory, PluginDetailREST, PluginSummaryREST, PluginValidationResult, PluginValidationSpecification, ConfigREST, ConfigWriteREST, ConfigWriteSpec, ChatCompletionSpec, ChatCompletionResultREST, ChatModelsREST, EmbeddingSearchSpecification, EmbeddingWriteSpecification, SaveGame, EdgeSpecification, FulltextIndexScanSpecification, FulltextSearchResultREST, GraphREST, GraphStatisticsREST, IndexAddToSpecification, IndexKeySpecification, IndexScanSpecification, PartitionMembersREST, PathREST, PathSpecification, PluginSpecification, PropertySearchSpecification, PropertySpecification, RangeIndexScanSpecification, ScanSpecification, SearchDistanceSpecification, GraphElementBatchREST, StatusREST, StoredQueryDetailREST, StoredQuerySpecification, StoredQuerySummaryREST, SubGraphSpecification, SubGraphSummary, VectorIndexAddSpecification, VectorIndexScanSpecification, VectorSearchResultREST, VertexREST, VertexSpecification } from "./types";
 /**
  * The reachability probe, and the ONE call with a deadline (see `RequestOptions.timeoutMs`).
  *
@@ -33,6 +34,15 @@ export declare const writeConfig: (i: InstanceConfig, spec: ConfigWriteSpec, sig
  * This is the DEFAULT NL-assist transport (custom endpoints stay browser-direct, off this path).
  */
 export declare const postChat: (i: InstanceConfig, spec: ChatCompletionSpec, signal?: AbortSignal) => Promise<ChatCompletionResultREST | null>;
+/**
+ * What the RUNNING chat backend catalogues (feature chat-model-catalog): one bounded read that fans
+ * out to the backend's own model list. Fallen-8-level and gated exactly like POST /chat (403 when the
+ * chat capability is off), so Studio only calls it where the answer is actionable.
+ *
+ * The answer is not the whole resolvable set: a backend can serve a name it does not catalogue, which
+ * is why the picker fed from this stays free-text.
+ */
+export declare const getChatModels: (i: InstanceConfig, signal?: AbortSignal) => Promise<ChatModelsREST | null>;
 /** Authorized iff the instance needs no key or accepted ours (server contract on StatusREST.ApiKeyRequired). */
 export declare const isAuthorized: (s: StatusREST) => boolean;
 /**
@@ -102,12 +112,12 @@ export declare const getGraphElement: (i: InstanceConfig, id: number, signal?: A
  * which re-reads those singly.
  */
 export declare const getGraphElements: (i: InstanceConfig, ids: number[], signal?: AbortSignal) => Promise<GraphElementBatchREST | null>;
-export declare const getOutEdgeProperties: (i: InstanceConfig, id: number) => Promise<string[] | null>;
-export declare const getInEdgeProperties: (i: InstanceConfig, id: number) => Promise<string[] | null>;
-export declare const getOutEdges: (i: InstanceConfig, id: number, edgePropertyId: string) => Promise<number[] | null>;
-export declare const getInEdges: (i: InstanceConfig, id: number, edgePropertyId: string) => Promise<number[] | null>;
-export declare const getInDegree: (i: InstanceConfig, id: number) => Promise<number | null>;
-export declare const getOutDegree: (i: InstanceConfig, id: number) => Promise<number | null>;
+export declare const getOutEdgeProperties: (i: InstanceConfig, id: number, signal?: AbortSignal) => Promise<string[] | null>;
+export declare const getInEdgeProperties: (i: InstanceConfig, id: number, signal?: AbortSignal) => Promise<string[] | null>;
+export declare const getOutEdges: (i: InstanceConfig, id: number, edgePropertyId: string, signal?: AbortSignal) => Promise<number[] | null>;
+export declare const getInEdges: (i: InstanceConfig, id: number, edgePropertyId: string, signal?: AbortSignal) => Promise<number[] | null>;
+export declare const getInDegree: (i: InstanceConfig, id: number, signal?: AbortSignal) => Promise<number | null>;
+export declare const getOutDegree: (i: InstanceConfig, id: number, signal?: AbortSignal) => Promise<number | null>;
 export declare const getEdgePropertyDegree: (i: InstanceConfig, id: number, direction: "in" | "out", edgePropertyId: string) => Promise<number | null>;
 export declare const getEdgeSource: (i: InstanceConfig, id: number) => Promise<number | null>;
 export declare const getEdgeTarget: (i: InstanceConfig, id: number) => Promise<number | null>;
@@ -125,7 +135,7 @@ export declare const deleteElementEmbedding: (i: InstanceConfig, id: number, nam
 /** Embed text and store it as the element's named embedding (+ model stamp), one txn. */
 export declare const embedElement: (i: InstanceConfig, spec: EmbedElementSpecification) => Promise<boolean | null>;
 /** Semantic search: embed the query text once, then kNN — same result shape as scanVector. */
-export declare const embeddingSearch: (i: InstanceConfig, spec: EmbeddingSearchSpecification) => Promise<VectorSearchResultREST | null>;
+export declare const embeddingSearch: (i: InstanceConfig, spec: EmbeddingSearchSpecification, signal?: AbortSignal) => Promise<VectorSearchResultREST | null>;
 export declare const createIndex: (i: InstanceConfig, spec: PluginSpecification) => Promise<boolean | null>;
 export declare const addToIndex: (i: InstanceConfig, indexId: string, spec: IndexAddToSpecification) => Promise<boolean | null>;
 export declare const removeIndexKey: (i: InstanceConfig, indexId: string, key: IndexKeySpecification) => Promise<boolean | null>;
@@ -201,13 +211,49 @@ export declare const listEntities: (i: InstanceConfig, options?: {
 }, signal?: AbortSignal) => Promise<DocumentEntityList | null>;
 /** The integrations this instance's runtime ships. A 403 or 401 means the capability is off. */
 export declare const listIntegrationProviders: (i: InstanceConfig, signal?: AbortSignal) => Promise<IntegrationProvider[] | null>;
-/** Runs one job and returns its report. A job that RAN and failed still answers 200. */
+/**
+ * What a job may carry on THIS instance: the ceilings already reconciled with the proxy's own
+ * transport bound, so there is one number per question and nothing to combine here. Read before
+ * staging so an oversized set is refused in the form rather than after an upload.
+ *
+ * An instance too old to serve it answers 404, which is why every caller has to treat "unknown"
+ * as "check nothing" rather than substituting a guess: a hardcoded ceiling here is how Studio
+ * came to carry one BELOW the runtime's and refuse jobs the instance would have accepted.
+ */
+export declare const getIntegrationLimits: (i: InstanceConfig, signal?: AbortSignal) => Promise<FileLimits | null>;
 /**
  * Starts a run. Answers a run id, NOT a report: the report is read afterwards from
  * getIntegrationRun, because any real source outlives the connection that would have carried it.
  * Everything that can reject the job still fails this call, so a resolved promise means it started.
+ *
+ * Sent as a MULTIPART FORM (feature integration-file-transport): the document in a `job` part with
+ * its `files` map left out, and each file as its own part streamed straight from the browser's
+ * handle. There is deliberately no JSON fallback here, even though the instance still accepts one -
+ * keeping it would mean keeping a base64 encoder, and that encoder is what capped a job at about
+ * 384 MiB regardless of what the instance would have accepted. Against an apiApp too old to accept
+ * multipart the answer is a 415, which says so plainly.
+ *
+ * `onProgress` is how far the SEND has got, which for a multi-gigabyte set of extracts is the
+ * difference between a progress bar and an apparent hang.
+ */
+export declare const submitIntegrationJob: (i: InstanceConfig, job: IntegrationJobRequest, options?: {
+    signal?: AbortSignal;
+    onProgress?: (progress: UploadProgress) => void;
+}) => Promise<IntegrationRunAccepted | null>;
+/**
+ * The job as a multipart form. Exported so a test can assert on the parts rather than on a mock's
+ * arguments: what matters is the shape that goes on the wire.
+ *
+ * The `job` part is a STRING and not a Blob. Appending a Blob makes the browser declare a filename
+ * on that part, which the runtime refuses by name because a value part carrying a filename is how
+ * the whole envelope gets sent as a file.
+ *
+ * The part naming is the runtime's grammar: `files[<key>]` for a setting given one file,
+ * `files[<key>][<n>]` numbered from 0 for one given several. The distinction is load-bearing rather
+ * than cosmetic - a list of one is a different statement from one file, and a setting the descriptor
+ * does not declare `multiple` refuses the list form.
  */
-export declare const submitIntegrationJob: (i: InstanceConfig, job: IntegrationJobRequest) => Promise<IntegrationRunAccepted | null>;
+export declare function integrationJobForm(job: IntegrationJobRequest): FormData;
 /**
  * One identity's current or most recent run: the phase while it runs, the report once it ends.
  * Answers 404 when the runtime has no slot for that identity, which a caller should read as "not

package/dist-lib/types/api/types.d.ts

@@ -435,6 +435,10 @@ export interface EmbeddingProviderStatsREST {
 export interface ChatProviderStatsREST {
     enabled: boolean;
     backend: string | null;
+    /**
+     * From the configured options, not from a probe target: reported for EVERY backend, including
+     * the ones with no residency API.
+     */
     model: string | null;
     loaded: boolean;
     resident?: boolean | null;
@@ -526,8 +530,28 @@ export interface ChatCompletionStatsREST {
 export interface ChatCompletionResultREST {
     content: string;
     model: string | null;
+    /**
+     * Which backend served THIS response (feature model-providers), stamped by the server. Null on
+     * a server predating the field. Per-call versus ambient: see lib/modelProvenance.ts.
+     */
+    backend?: string | null;
     stats?: ChatCompletionStatsREST | null;
 }
+export interface ChatModelREST {
+    /** Verbatim from the backend's catalog; the server sorts ordinally for a stable contract. */
+    name: string;
+    /** Null when the backend does not say (OpenAI, Anthropic, an old sidecar, a failed lookup). */
+    capability: "completion" | "embedding" | null;
+    /** Whether a worker can serve it right now; null when the backend reports nothing. */
+    available: boolean | null;
+    /** The backend's own class string, passed through verbatim and carrying no published legend. */
+    class: string | null;
+}
+export interface ChatModelsREST {
+    /** The running backend's name, in the spelling ChatCompletionResultREST.backend uses. */
+    backend: string;
+    models: ChatModelREST[];
+}
 export interface GraphStatisticsREST {
     vertexCount: number;
     edgeCount: number;
@@ -793,6 +817,14 @@ export interface SubGraphSemanticSummary {
         pattern: string;
         minScore: number;
     }[] | null;
+    /**
+     * Which embedding backend turned queryText into the bound vector, and that function's identity
+     * stamp (`name[@version]#dimension#metric`) - both stamped at registration and carried with the
+     * recipe, so the echo is the same on create, on read and after a recalculate. Absent for a
+     * vector-in registration: no embed call happened, so there is nothing honest to report.
+     */
+    embeddingBackend?: string | null;
+    embeddingIdentity?: string | null;
 }
 export interface SubGraphSummary {
     name: string;
@@ -1003,6 +1035,13 @@ export interface IntegrationProvider {
     id: string;
     displayName: string;
     description: string;
+    /**
+     * Absolute http(s) URL of the integration's own documentation, when it declares one. It is what
+     * keeps `description` a sentence instead of a reference manual in a table cell. Optional: an
+     * older runtime, or a provider whose author wrote no page, sends none. Render it only through
+     * `docsHref` in state/integrations.ts, which refuses a scheme a browser should not follow.
+     */
+    docsUrl?: string | null;
     settings: IntegrationSetting[];
     entityKinds: string[];
     claimTypes: string[];
@@ -1079,18 +1118,48 @@ export interface IntegrationDiagnostic {
     message: string;
     subject?: string | null;
 }
-/** One file a job carries: its own name, and its bytes base64. */
+/**
+ * One file a job carries: the browser's own handle on it.
+ *
+ * A `File` and NOT its bytes, which is the whole of feature integration-file-transport on this side.
+ * The version this replaced carried `contentBase64`, so the tab had to hold every file's bytes, the
+ * base64 expansion of them and the serialised request all at once; a set of AUTOSAR extracts left
+ * gigabytes resident before the send even started, and the encoder failed outright at about 384 MiB
+ * of input because a JavaScript string caps at 512 MiB. A handle costs nothing until the browser
+ * streams it off disk.
+ *
+ * The price, and it is real: the file is read at SEND time, so one moved, renamed or edited after
+ * being staged fails then rather than at pick time. The form says so.
+ */
 export interface IntegrationJobFile {
     /** The file's own name, used verbatim in the run's messages. Never a path. */
     name: string;
-    /** The file's BYTES, base64 - not its text, so a UTF-16 extract survives the trip. */
-    contentBase64: string;
+    /** The handle. Nothing reads it until the request is sent. */
+    file: File;
 }
 /**
  * The whole configuration of one run. A credential setting's value arrives in `credentialValues` and
  * a file setting's file in `files`, never in `settings`: the runtime leases and redacts the first,
  * holds the second for the run and drops it, and treats `settings` as ordinary data.
  */
+/**
+ * What a job may carry on one instance (feature integration-file-transport), from
+ * `GET /integrations/limits`. Already the ceiling that BINDS: the runtime owns the configuration,
+ * but every request arrives through the apiApp's transport bound, so the proxy reconciles the two
+ * and serves one number per question. Nothing here is combined client-side, on purpose - a client
+ * that computes its own ceiling is how Studio ended up with one below the runtime's.
+ *
+ * Zero or less means that ceiling is switched off, which only `maxJobFiles` can report: the byte
+ * ceilings always have the proxy's transport bound behind them.
+ */
+export interface FileLimits {
+    /** The most decoded bytes ONE file may carry. */
+    maxFileBytes: number;
+    /** The most decoded bytes one job's files may come to in TOTAL, across every file setting. */
+    maxJobFileBytes: number;
+    /** How many files one job may carry, counted across every file setting. */
+    maxJobFiles: number;
+}
 export interface IntegrationJobRequest {
     providerId: string;
     integrationInstanceId: string;

package/dist-lib/types/canvas/InteractPanel.d.ts

@@ -0,0 +1,19 @@
+import type { ElementRef } from "./GraphCanvas";
+/**
+ * Canvas "Interact" tab (feature canvas-interact): filters build a MATCH SET over the canvas
+ * vertices, and two view-only verbs apply to it - expand every match's neighborhood, or remove
+ * every match from the view. With no filter active the match set is every canvas vertex, which is
+ * how "expand all" is expressed rather than as a separate button.
+ *
+ * Label, property and on-canvas degree are cheap, so they evaluate live on every render. Database
+ * degree and the semantic threshold cost server round trips, so they run behind Preview, and any
+ * filter edit or canvas change INVALIDATES that result: acting on a stale match set is the bug
+ * this lifecycle exists to prevent. Nothing here touches the database.
+ */
+export declare function InteractPanel({ selected, onSelect, onHover, }: {
+    /** What the Detail panel currently shows, so a bulk remove can retire a selection it took. */
+    selected: ElementRef | null;
+    onSelect: (ref: ElementRef | null) => void;
+    /** Spotlight a previewed vertex on the canvas, the Find tab's affordance. */
+    onHover?: (ref: ElementRef | null) => void;
+}): import("react").JSX.Element;

package/dist-lib/types/components/ConfigurationSurface.d.ts

@@ -1,5 +1,6 @@
-import type { ApiError } from "../api/client";
-import type { ObservabilityConfigREST, PendingRestartREST, SettingREST } from "../api/types";
+import { ApiError } from "../api/client";
+import type { InstanceConfig } from "../instances/types";
+import type { ChatProviderStatsREST, ObservabilityConfigREST, PendingRestartREST, SettingREST } from "../api/types";
 /**
  * The configuration surface (feature configuration-surface): one dialog holding everything this
  * instance binds, reached from the single Configure button on the Connect screen's configuration card.
@@ -14,12 +15,24 @@ import type { ObservabilityConfigREST, PendingRestartREST, SettingREST } from ".
  * a value under a half-typed field here, which is exactly what the poll suspension exists to prevent.
  * What this component does own is where you are looking: the section, the query and the filter. Those
  * live under Dialog.Content, which Radix unmounts on close, so they reset without an effect.
+ *
+ * The ONE server read it does own is the chat model catalog (feature chat-model-catalog), because it
+ * only makes sense once the operator has navigated to one particular section: it sits on its own cache
+ * key, is never polled, fetches at most once per visit and unmounts with this subtree. The draft still
+ * belongs to the card, so this cannot replace a value under a half-typed field.
  */
 export interface ConfigurationSurfaceProps {
     open: boolean;
     onClose: () => void;
     /** Named in the header, because the settings behind it belong to one instance and not the next. */
     instanceName: string;
+    /**
+     * The instance the catalog read addresses (feature chat-model-catalog). A PROP rather than a
+     * registry subscription: everything else here is prop-driven, and subscribing re-rendered this
+     * subtree during an instance switch instead of letting it unmount, so it could paint one pass
+     * addressing the new instance while every other prop still described the old one.
+     */
+    instance: InstanceConfig | null;
     settings: readonly SettingREST[];
     pendingRestart: readonly PendingRestartREST[];
     observability: ObservabilityConfigREST;
@@ -38,5 +51,13 @@ export interface ConfigurationSurfaceProps {
     isRowDisabled: (key: string) => boolean;
     /** A blanked numeric field the server would refuse the whole batch over, if there is one. */
     blankNumericKey?: string;
+    /**
+     * The chat gateway's RUNNING state (feature chat-model-catalog), absent or null when the instance
+     * reports none. Two facts live only here: whether chat is on at all, and which backend is actually
+     * serving. Neither is derivable from the inventory - Fallen8:Chat:Enabled is never-writable so its
+     * value is withheld, and the Backend descriptor publishes the STORED value, which after a write is
+     * the pending one. The picker follows what is running.
+     */
+    chat?: ChatProviderStatsREST | null;
 }
 export declare function ConfigurationSurface(props: ConfigurationSurfaceProps): import("react").JSX.Element;

package/dist-lib/types/components/ErrorBox.d.ts

@@ -1,6 +1,12 @@
 /**
  * Every failed request shows HTTP status + server message (NFR: never a silent console
  * error). A network-level failure renders as the disconnected state with a retry.
+ *
+ * The fallback title is deliberately NOT about requests. This box also renders throws from the
+ * client side of a mutation, where no request was made at all: an integration submit that could
+ * not build its body reported "Request failed / Invalid string length", which sent the reader
+ * looking for a server fault that did not exist. A title is a claim, so the generic one claims
+ * only what is always true.
  */
 export declare function ErrorBox({ error, onRetry }: {
     error: unknown;

package/dist-lib/types/components/SemanticBlockEditor.d.ts

@@ -1,4 +1,5 @@
 import { type SemanticDraft } from "../lib/semantic";
+import type { EmbeddingProviderStatsREST } from "../api/types";
 /**
  * The Path screen's declarative semantic block (feature element-embeddings): the shared
  * query core (SemanticQueryEditor) plus the block-local minScore filter and
@@ -11,7 +12,7 @@ import { type SemanticDraft } from "../lib/semantic";
  * Controlled: the parent owns the SemanticDraft and derives which delegate slots to
  * disable from semanticOwnsVertex{Filter,Cost}.
  */
-export declare function SemanticBlockEditor({ draft, onChange, allowCost, costDisabledReason, providerEnabled, embeddingNames, idPrefix, disabled, disabledReason, }: {
+export declare function SemanticBlockEditor({ draft, onChange, allowCost, costDisabledReason, providerEnabled, provider, embeddingNames, idPrefix, disabled, disabledReason, }: {
     draft: SemanticDraft;
     onChange: (patch: Partial<SemanticDraft>) => void;
     /** costBySimilarity is a path concept; false disables the cost slot entirely. */
@@ -21,6 +22,8 @@ export declare function SemanticBlockEditor({ draft, onChange, allowCost, costDi
     costDisabledReason?: string;
     /** Resolved provider state; null = unknown (no graph shape computed yet). */
     providerEnabled: boolean | null;
+    /** Passed straight to SemanticQueryEditor, which documents it. */
+    provider?: EmbeddingProviderStatsREST | null;
     embeddingNames: string[];
     idPrefix: string;
     /** e.g. a stored template is selected — the block cannot apply. */

package/dist-lib/types/components/SemanticQueryEditor.d.ts

@@ -1,15 +1,22 @@
 import type { SemanticQueryDraft } from "../lib/semantic";
+import type { EmbeddingProviderStatsREST } from "../api/types";
 /**
  * The semantic QUERY fields (source, vector/text, embedding name, metric) — the one query
  * every semantic decision of a request scores against. Extracted so the Path screen's
  * block editor and the Subgraph screen's per-request query section render exactly one
  * implementation. Pure data — it compiles no C#.
  */
-export declare function SemanticQueryEditor({ query, onChange, providerEnabled, embeddingNames, idPrefix, }: {
+export declare function SemanticQueryEditor({ query, onChange, providerEnabled, provider, embeddingNames, idPrefix, }: {
     query: SemanticQueryDraft;
     onChange: (patch: Partial<SemanticQueryDraft>) => void;
     /** Resolved provider state; null = unknown (no graph shape computed yet). */
     providerEnabled: boolean | null;
+    /**
+     * The provider snapshot behind {@link providerEnabled}, when the caller holds it: it names the
+     * backend and embedding function that will turn the text into a vector. Optional, so a call
+     * site that cannot answer that question simply says nothing.
+     */
+    provider?: EmbeddingProviderStatsREST | null;
     embeddingNames: string[];
     idPrefix: string;
 }): import("react").JSX.Element;

package/dist-lib/types/components/SettingRow.d.ts

@@ -1,4 +1,10 @@
 import type { SettingREST } from "../api/types";
+/** One value a string row can OFFER without requiring it (feature chat-model-catalog). */
+export interface SettingSuggestion {
+    value: string;
+    /** What is known about it, shown beside the value; omitted when nothing is known. */
+    label?: string;
+}
 export declare const SettingRow: import("react").NamedExoticComponent<{
     setting: SettingREST;
     /** The unsaved value, or undefined when this row is untouched. */
@@ -7,4 +13,12 @@ export declare const SettingRow: import("react").NamedExoticComponent<{
     onClear: (key: string) => void;
     /** True when the whole editable region is gated off (an embed host locked it). */
     disabled?: boolean;
+    /**
+     * Values to offer on a `string` row, as a native combobox. OFFER is the whole contract: a typed
+     * value outside the list is not an error, because for a model name the list is not the whole
+     * resolvable set. Absent (or empty) leaves the row exactly as it was.
+     */
+    suggestions?: readonly SettingSuggestion[];
+    /** One line under the control, for whoever supplied the suggestions to say why it could not. */
+    note?: string;
 }>;

package/dist-lib/types/delegate/nl/NlDraftStats.d.ts

@@ -0,0 +1,13 @@
+import type { NlGenerationStats } from "./generate";
+/**
+ * One draft's generation stats (nl-assist-ux FR-5), the row UNDER the draft label: the summary
+ * line plus the provider's raw fields on demand. Both NL panels render this one component, so
+ * the formatter and the markup have a single home.
+ *
+ * The backend segment is whatever the stats object captured with THIS draft carries, never the
+ * live configuration (see lib/modelProvenance.ts). The row sits BELOW the label, not beside it:
+ * a same-row block costs the label width the panel's 288px sidebar does not have.
+ */
+export declare function NlDraftStats({ stats }: {
+    stats: NlGenerationStats;
+}): import("react").JSX.Element;

package/dist-lib/types/delegate/nl/config.d.ts

@@ -26,10 +26,11 @@ export interface NlAssistConfig {
     maxRetries: number;
 }
 /**
- * The default model the compose stack pulls for the instance's chat backend (produced by
- * nl-assist-finetune). Shown as a hint only; in instance mode the server owns the model, and
- * in custom mode the user picks one (see NL_PRESETS). If the chosen model is absent on the
- * backend, calls 404 - create it with the training pipeline or pick the stock phi4-mini preset.
+ * CUSTOM-MODE ONLY: the prefill for the model field, and the fine-tune the compose stack pulls
+ * (produced by nl-assist-finetune). It says nothing about instance mode - the server owns that
+ * model and reports it on /status, which is where the panels read it from. If the chosen model is
+ * absent on the endpoint, calls 404 - create it with the training pipeline or pick the stock
+ * phi4-mini preset.
  */
 export declare const DEFAULT_NL_MODEL = "phi4-f8-mini";
 export declare const DEFAULT_NL_CONFIG: NlAssistConfig;

package/dist-lib/types/delegate/nl/generate.d.ts

@@ -34,6 +34,12 @@ export interface NlGenerationStats {
     completionTokens?: number;
     durationMs?: number;
     tokensPerSecond?: number;
+    /**
+     * Which server-side backend produced THIS draft, from that call's own response. Undefined in
+     * custom mode, deliberately: a browser-direct call reaches no Fallen-8, so there is no server
+     * selector to report and inventing one would sit a fabricated name beside real ones.
+     */
+    backend?: string;
     /** The provider's stats fields verbatim, for the expandable raw view. */
     raw: Record<string, unknown>;
 }

package/dist-lib/types/lib/canvasCap.d.ts

@@ -5,3 +5,13 @@
  * sample-graph loaders and the Canvas screen's "Show whole graph" load.
  */
 export declare const CANVAS_ELEMENT_CAP = 20000;
+/**
+ * The most elements (vertices PLUS edges) a bulk expand will grow the canvas to before it stops
+ * and says so (feature canvas-interact).
+ *
+ * A separate number from `CANVAS_ELEMENT_CAP` on purpose: that one bounds each KIND of a fetch, so
+ * "Show whole graph" can legitimately leave 20,000 vertices AND 20,000 edges on the canvas. A
+ * sweep refusing to grow a canvas the app itself just filled would be enforcing a ceiling nothing
+ * else in the product has, which is why this is the sum and twice the size.
+ */
+export declare const CANVAS_EXPAND_CEILING: number;