@fallen-8/studio 0.0.37 → 0.0.38

package/dist-lib/{javascript-CVQBymBa.js → javascript-BL3tIzUw.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-BIjKKvsW.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-FxM7KRm5.js}

@@ -1,4 +1,4 @@
-import { m as Et } from "./index-BQbFjItv.js";
+import { m as Et } from "./index-0ioFtrZM.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-wB7unZht.js}

@@ -1,4 +1,4 @@
-import { m as l } from "./index-BQbFjItv.js";
+import { m as l } from "./index-0ioFtrZM.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-DmS41r19.js}

@@ -1,4 +1,4 @@
-import { m as s } from "./index-BQbFjItv.js";
+import { m as s } from "./index-0ioFtrZM.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-C24igqMV.js}

@@ -1,4 +1,4 @@
-import { m as o } from "./index-BQbFjItv.js";
+import { m as o } from "./index-0ioFtrZM.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-BRvioLVk.js}

@@ -1,4 +1,4 @@
-import { m } from "./index-BQbFjItv.js";
+import { m } from "./index-0ioFtrZM.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-zMn1qnUE.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-0ioFtrZM.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;
 /**
@@ -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;
@@ -1079,18 +1111,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
+ * 5.84 GiB 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/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/fieldHelp.d.ts

@@ -20,7 +20,7 @@ export declare const FIELD_HELP: {
     readonly lookupKind: "What the id refers to: vertex, edge, or graphelement (either — the server figures out which).";
     readonly maxElements: "Upper bound on how many elements the bulk view loads from GET /graph. Keep it modest on big graphs — this is a browser, not an export (use JSONL export for that).";
     readonly bulkFilter: "Client-side filter over the loaded elements: matches an exact id or a substring of the label.";
-    readonly scanKind: "Property scan walks all elements (no index needed); 'ask an index' picks a registered index and offers the query forms its type answers.";
+    readonly scanKind: "Property scan walks all elements (no index needed); 'ask an index' picks a registered index and offers the query forms its type answers; 'semantic search' types words instead, and the embedding provider turns them into the query vector.";
     readonly propertyScope: "Specific key: scan one named property with an operator and typed literal. Any property: a case-insensitive substring search across EVERY property value (numbers and dates included, compared as text) - a cold, un-indexed full-graph discovery scan.";
     readonly searchTerm: "The substring to look for across every property value, case-insensitively. An element matches when any of its values contains it.";
     readonly searchLabel: "Optional: restrict the search to elements with exactly this label. Leave empty to search every label.";
@@ -50,6 +50,8 @@ export declare const FIELD_HELP: {
     readonly vectorBindEmbeddingName: "Optional: bind this vector index to a named element embedding. A bound index maintains itself as a projection of that embedding — you write embeddings on the elements and the index follows; explicit vector-adds are rejected. Leave empty for a raw (bring-your-own-vector) index.";
     readonly vectorModel: "Optional model-identity string this index expects its vectors to come from (e.g. 'bge-micro-v2#384#Cosine'). The embedding provider refuses to write mismatched vectors; a search whose provider identity differs answers 409. Diagnostic only for a raw index.";
     readonly embeddingSearchText: "Search text. The embedding provider embeds it once (server-side), then runs kNN — you never handle the vector. Needs the provider enabled on this instance.";
+    readonly semanticIndexId: "The vector index the search ranks against. The list is narrowed to the indices that report the vector family, since only they hold vectors to rank; one bound to an embedding name projects that embedding off your elements and maintains itself.";
+    readonly semanticBindEmbedding: "Required here, unlike on the Indexes screen: this index exists so a typed query can rank the embeddings ALREADY on your elements, and only a bound index projects them. Name the embedding they carry ('default' unless you chose otherwise). An unbound index would hold nothing until you pasted vectors into it by hand.";
     readonly embeddingName: "Name of the embedding to read/write on this element, e.g. 'default'. Letters, digits, underscore, dash; max 64 chars. Different names hold independent vectors (and may differ in dimension).";
     readonly embeddingVectorPaste: "The embedding vector, pasted as a JSON array or comma-separated floats. The element is the source of truth; any vector index bound to this name updates automatically on save.";
     readonly embeddingText: "Text to embed onto this element via the server's embedding provider (stored with a model-identity stamp). Needs the provider enabled; otherwise paste a vector.";

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

@@ -0,0 +1,69 @@
+import type { FileLimits } from "../api/types";
+/**
+ * Whether a job's files fit what THIS instance accepts, checked at pick time (feature
+ * integration-file-transport).
+ *
+ * This module is the only place in Studio allowed to reason about file ceilings, and it holds no
+ * numbers of its own. Every ceiling arrives from `GET /integrations/limits` already reconciled with
+ * the proxy's transport bound, so there is one number per question and nothing to combine. That
+ * matters because the version this replaced had a ceiling of its own, about 384 MiB, which sat
+ * BELOW the instance's: jobs the instance would have accepted were refused in the browser, and no
+ * amount of configuration could fix it.
+ *
+ * The corollary is the rule for the unknown case. An instance too old to serve the route, or one
+ * whose integrations capability is off, leaves the limits undefined, and then NOTHING is checked
+ * and nothing is guessed: the send goes ahead and the instance refuses it if it must. A default
+ * substituted here would be the same bug again.
+ */
+/** Enough of a file to check it, whichever transport carries it later. */
+export interface SizedFile {
+    name: string;
+    size: number;
+}
+/**
+ * The ceilings, or their absence. Absence has three spellings and they all mean the same thing
+ * here: the query has not answered yet, it failed, or the instance answered with no body.
+ */
+export type MaybeLimits = FileLimits | null | undefined;
+/**
+ * What one file setting is being asked to hold, and what the rest of the job already holds.
+ *
+ * Generic over the incoming type, so a caller passing real `File` handles gets `File`s back with no
+ * cast. That is not cosmetic: it is what makes "this only ever filters, it never constructs" a fact
+ * the compiler holds rather than a comment somebody has to keep true.
+ */
+export interface StagingRequest<T extends SizedFile = SizedFile> {
+    /** The ceilings this instance published, or absent when they could not be read. */
+    limits: MaybeLimits;
+    /** The files being added to ONE file setting, in the order they were picked. */
+    incoming: T[];
+    /** What that setting already holds. Kept whatever this verdict says. */
+    staged?: SizedFile[];
+    /** What every OTHER file setting of the same job holds: the total and the count are job-wide. */
+    elsewhere?: SizedFile[];
+    /** True when the setting declares `multiple`, so its files are read as ONE claimed set. */
+    claimedSet?: boolean;
+}
+export interface StagingVerdict<T extends SizedFile = SizedFile> {
+    /** The incoming files that may be staged, in pick order. */
+    accepted: T[];
+    /** One message for the setting's problem channel, or null when there is nothing to say. */
+    problem: string | null;
+}
+/**
+ * The refusal that keeps a set out of the tab before it is ever sent.
+ *
+ * Granularity differs between the three ceilings on purpose. A file over the per-file ceiling is
+ * individually too big, so it is refused individually and its siblings still stage. A broken TOTAL
+ * or COUNT is a property of the whole job, so no single file is at fault and none of the incoming
+ * batch is accepted: picking some arbitrary prefix that fits would drop the tail on a decision the
+ * person picking never made, and for a claimed set it would silently split the set.
+ */
+export declare function checkStaging<T extends SizedFile>(request: StagingRequest<T>): StagingVerdict<T>;
+/**
+ * What the form says when it could not read the ceilings. Its job is to stop someone reading the
+ * absence of refusals as approval, without naming a number Studio does not know.
+ */
+export declare const LIMITS_UNKNOWN_NOTE: string;
+/** The ceilings in one line, for the form to state up front rather than only when refusing. */
+export declare function describeLimits(limits: MaybeLimits): string;

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

@@ -2,6 +2,14 @@
 export declare function formatCompact(value: number): string;
 /** Full number with grouping, for exact values ("10,001,000"). */
 export declare function formatExact(value: number): string;
+/**
+ * A size in bytes, in binary units up to GiB ("0 B", "512 B", "1.5 KiB", "5.8 GiB").
+ *
+ * GiB and not MiB because two callers need it: a save-game registry, and the refusal that tells
+ * someone their 5983 MiB of files is over the ceiling. Reporting that as "5983.0 MiB" is arithmetic
+ * the reader should not have to do while being told no.
+ */
+export declare function formatBytes(bytes: number): string;
 /**
  * The one glyph this UI renders for a value the server does not have, so a row cannot mix two
  * spellings of "absent" in one table and read as two different states.

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

@@ -0,0 +1,26 @@
+import type { ChatProviderStatsREST, EmbeddingProviderStatsREST } from "../api/types";
+/**
+ * How Studio names the model backend that serves a request (feature model-providers).
+ *
+ * Two kinds of label, and the distinction is the feature:
+ * - AMBIENT ("requests will go to X") reads the polled /status block, which describes the
+ *   CURRENT configuration. {@link chatAmbientLabel} is named so a call site cannot use it by
+ *   accident where a per-call answer belongs.
+ * - PER-CALL reads the `backend` field carried on that call's own response. A draft produced
+ *   under one backend must keep saying so after the operator switches, so nothing per-call may
+ *   be derived from here.
+ *
+ * Neither function invents a name it cannot know: an absent field yields a sentence saying the
+ * value is absent, never a plausible default.
+ */
+/**
+ * The ambient chat destination: `"{backend} · {model}"`, or the reason there is no pair to show.
+ * `undefined` means /status has not answered yet, which is a different thing from chat being off.
+ */
+export declare function chatAmbientLabel(chat: ChatProviderStatsREST | null | undefined): string;
+/**
+ * The embedding function's identity as a reader recognises it: `modelName[@modelVersion]`.
+ * A provider that reports no model name is described by its dimension instead, because that is
+ * the one property of the vector space still known to be true.
+ */
+export declare function embeddingStamp(provider: EmbeddingProviderStatsREST): string;