@fallen-8/studio 0.0.36 → 0.0.38

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/components/StoredQueriesPanel.d.ts

@@ -1,14 +1,19 @@
-import type { StoredQueryKind } from "../api/types";
+import type { StoredQuerySummaryREST } from "../api/types";
 /**
- * Kind-scoped stored-query management (concept spec §5.3): a stored query is unique to its
- * scenario — Path or SubGraph — so its management home lives on that scenario's screen, next
- * to the fragments it captures. The panel lists ONLY entries of `kind`, with read-only source,
- * recompile diagnostics, delete (immutable entries: delete + re-register is the edit flow),
- * and a **Use** action that selects the entry into this screen's own filter picker. Capture
- * ("Save as stored query…") lives in the inline advanced tier of the same screen.
+ * The stored-query library (concept spec §5.3): the WHOLE `/storedquery` collection of the
+ * namespace in one table, with a **kind** column naming each entry's scenario. It was always
+ * one server-side collection; until feature studio-traverse-merge the Studio rendered it as
+ * two kind-scoped panels, one per scenario screen, which hid that fact and split the view.
+ *
+ * Read-only source, recompile diagnostics, delete (entries are immutable, so delete plus
+ * re-register is the edit flow), and a **Use** action that hands the entry back to the host,
+ * which selects it into the matching scenario's filter picker. Capture ("Save as stored
+ * query…") stays in each scenario's inline advanced tier, next to the fragments it captures.
  */
-export declare function StoredQueriesPanel({ kind, onUse, }: {
-    kind: StoredQueryKind;
-    /** Select this entry into the host screen's filter picker (stored source + name). */
-    onUse: (name: string) => void;
+export declare function StoredQueriesPanel({ onUse, }: {
+    /**
+     * Select this entry into its scenario's filter picker (stored source + name). The whole
+     * entry is handed over, not just the name, because the host has to route it by `kind`.
+     */
+    onUse: (entry: StoredQuerySummaryREST) => void;
 }): import("react").JSX.Element;

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

@@ -2,11 +2,10 @@ import type { StoredPathQueryBlock, StoredQueryKind, StoredSubGraphQueryBlock }
 import type { InstanceConfig } from "../instances/types";
 import type { FilterSource } from "../state/instanceStore";
 /**
- * Stored-query surfaces shared by Path and Subgraph (concept spec §5.1/5.2): the
- * inline|stored source toggle, the kind-filtered picker with a read-only fragment
+ * Stored-query surfaces shared by the two Traverse scenario tabs (concept spec §5.1/5.2):
+ * the inline|stored source toggle, the kind-filtered picker with a read-only fragment
  * preview, and the "Save as stored query…" capture dialog. Management (list, source,
- * delete) lives in the kind-scoped Stored queries panel below on the same screen — the
- * picker only points there.
+ * delete) lives in the Traverse screen's Stored queries tab; the picker only points there.
  */
 export declare const REGISTRATION_401 = "registration requires the instance's API key \u2014 configure it on the Connect screen";
 export declare function FilterSourceToggle({ value, onChange, }: {

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;

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

@@ -8,6 +8,16 @@ import type { PathDraft, SubgraphPatternDraft } from "../state/instanceStore";
  */
 /** Server-side name rule: always a safe URL path segment, compared case-sensitively. */
 export declare const STORED_QUERY_NAME: RegExp;
+/**
+ * The draft patch that points a scenario at a stored entry. Every gesture that hands a name
+ * back ("Save as stored query…" succeeding, "Use" in the library) means the same two things:
+ * switch the source to stored, and select this name. Both path and subgraph drafts carry
+ * those two fields, so one home instead of a copy per call site.
+ */
+export declare const selectStoredQuery: (name: string) => {
+    readonly filterSource: "stored";
+    readonly storedQuery: string;
+};
 /**
  * The whole spec from a draft — stored and inline fragments never travel together. The
  * semantic block (feature element-embeddings) attaches regardless of the filter source

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

@@ -0,0 +1,49 @@
+import type { EmbeddingProviderStatsREST, PropertySpecification } from "../api/types";
+/**
+ * What a NEW vector index is created with, in one place: two screens create one (the Indexes
+ * screen's create panel and the Query screen's semantic on-ramp, feature
+ * semantic-search-onramp) and the numbers are not a preference. A bound index whose dimension
+ * or metric disagrees with the model writing into it is refused on every later embed and every
+ * later search, so the provider is the authority and guessing it twice is how the two copies
+ * would drift.
+ */
+/**
+ * Fallbacks for a server that reports no usable provider. Not a recommendation: a shape the
+ * engine accepts, so the form has something to submit while saying (at the call site) that
+ * these are defaults rather than the instance's own numbers.
+ */
+export declare const VECTOR_INDEX_FALLBACK: {
+    readonly dimension: "384";
+    readonly metric: "Cosine";
+};
+export interface VectorIndexDefaults {
+    /** The provider is on AND names a dimension, so its numbers are the authoritative ones. */
+    providerReady: boolean;
+    dimension: string;
+    metric: string;
+}
+/** The dimension + metric a new vector index should default to on this instance. */
+export declare function vectorIndexDefaults(provider: EmbeddingProviderStatsREST | null | undefined): VectorIndexDefaults;
+/** The engine's own bounds on a vector index's dimension (VectorIndex.Initialize). */
+export declare const VECTOR_DIMENSION_RANGE: {
+    readonly min: 1;
+    readonly max: 4096;
+};
+/**
+ * Whether this dimension is one the engine will take. The number input's `min`/`max` are not
+ * enough on their own: neither attribute blocks an EMPTY field, and neither is consulted at all
+ * unless the button is a submit. An empty value travels as `propertyValue: ""` against
+ * `System.Int32`, which the server cannot convert, so the round trip is spent to be told so.
+ */
+export declare function isValidVectorDimension(dimension: string): boolean;
+/**
+ * The `pluginOptions` of POST /index for a vector index. Options travel as typed literals
+ * (vector-index README §creation), and embeddingName/model are emitted only when set, so a raw
+ * index keeps exactly the two-option shape (pinned by index-management.test.tsx).
+ */
+export declare function vectorIndexPluginOptions(options: {
+    dimension: string;
+    metric: string;
+    embeddingName?: string;
+    model?: string;
+}): Record<string, PropertySpecification>;

package/dist-lib/types/screens/PathScreen.d.ts

@@ -5,5 +5,8 @@
  * editor - /path swallows compile errors, so an empty result here is "no paths found",
  * never an error (FR-13). Filters come from inline fragments or a stored query — the
  * source toggle keeps the two mutually exclusive (concept spec §5.1).
+ *
+ * Rendered as the "Path finding" tab of the Traverse screen (feature studio-traverse-merge),
+ * which also owns the stored-query library this screen used to host at its foot.
  */
 export declare function PathScreen(): import("react").JSX.Element;

package/dist-lib/types/screens/TraverseScreen.d.ts

@@ -0,0 +1 @@
+export declare function TraverseScreen(): import("react").JSX.Element;

package/dist-lib/types/state/instanceStore.d.ts

@@ -67,6 +67,19 @@ export interface ResultSet {
 }
 /** Where a path/subgraph run takes its fragments from (concept spec §5.1). */
 export type FilterSource = "inline" | "stored";
+/**
+ * The tabs of the merged Traverse screen (feature studio-traverse-merge), in strip order.
+ * ONE home for the ids: the tab strip renders them, the route validates `?tab=` against them,
+ * and the persisted `traverseTab` remembers the last one per instance-and-namespace.
+ */
+export declare const TRAVERSE_TABS: readonly ["path", "subgraph", "stored"];
+export type TraverseTab = (typeof TRAVERSE_TABS)[number];
+/** The tab a fresh workspace opens on: path finding is the more frequent scenario. */
+export declare const DEFAULT_TRAVERSE_TAB: TraverseTab;
+/** Guard for the two untrusted sources of a tab id: the `?tab=` search param and storage. */
+export declare const isTraverseTab: (value: unknown) => value is TraverseTab;
+/** The scenario tab a stored query of this kind belongs to (its `kind` is `string | null`). */
+export declare const traverseTabForKind: (kind: string | null | undefined) => TraverseTab;
 export interface PathDraft {
     from: string;
     to: string;
@@ -85,13 +98,23 @@ export interface PathDraft {
     semantic: SemanticDraft;
 }
 export declare const DEFAULT_PATH_DRAFT: PathDraft;
+/** The Query screen's three ways of asking (feature index-workspace / semantic-search-onramp). */
+export declare const QUERY_MODES: readonly ["property", "index", "semantic"];
+export type QueryMode = (typeof QUERY_MODES)[number];
 /**
  * The Query screen's whole input form (feature index-workspace). Persisted per instance
  * so leaving for the Canvas and coming back restores it exactly — results are re-run on
  * demand (kept out of the lean persisted store). Reset via the screen's Clear button.
  */
 export interface QueryDraft {
-    mode: "property" | "index";
+    /**
+     * "semantic" is text-in kNN (feature semantic-search-onramp): its own mode rather than a
+     * source toggle inside the index mode's vector form, because a capability reachable only
+     * after picking the right index is one nobody finds. It shares the kNN parameters below
+     * with that form - same question, different query source - but NOT the index, which is
+     * drawn from a different set (see semanticIndexId).
+     */
+    mode: QueryMode;
     /** Property-scan scope: one named "key" (typed operator) or "any" property (contains search). */
     propertyScope: "key" | "any";
     propertyId: string;
@@ -100,6 +123,13 @@ export interface QueryDraft {
     /** All-property search label restrictor (propertyScope === "any"); empty scans every label. */
     searchLabel: string;
     indexId: string;
+    /**
+     * The semantic mode's index, kept apart from `indexId` because the two modes choose from
+     * different sets: every registered index there, only the ones that can rank a vector here.
+     * Sharing one field meant picking a vector index for a semantic search silently replaced the
+     * operator's index-mode selection AND the query form that went with it.
+     */
+    semanticIndexId: string;
     form: IndexCapability;
     operator: BinaryOperatorName;
     resultType: "Vertices" | "Edges" | "Both";
@@ -111,14 +141,23 @@ export interface QueryDraft {
     fulltextQuery: string;
     spatialElementId: string;
     spatialDistance: string;
+    /** The pasted query vector (index mode, vector form); the semantic mode never uses it. */
     vectorText: string;
     vectorK: string;
     vectorKind: "any" | "vertex" | "edge";
     vectorLabel: string;
-    vectorSource: "vector" | "text";
+    /** The query text of the semantic mode, embedded once server-side. */
     vectorSearchText: string;
 }
 export declare const DEFAULT_QUERY_DRAFT: QueryDraft;
+/**
+ * Rehydrates a persisted Query draft. Text-in kNN used to be a `vectorSource` toggle INSIDE the
+ * index mode's vector form; feature semantic-search-onramp made it its own mode, so a draft
+ * written by an older build is LIFTED rather than dropped: the text, k, kind and label are the
+ * same question asked the same way, and only the route to the form changed. The stale key is
+ * stripped instead of spread through, so nothing carries a field this build has no meaning for.
+ */
+export declare function migrateQueryDraft(persisted: Partial<QueryDraft> | undefined): QueryDraft;
 /**
  * One pattern row of the subgraph builder: a pattern spec plus a stable list key and the
  * step's vertex-slot state (feature subgraph-semantic-thresholds) — the slot MODE and the
@@ -246,6 +285,13 @@ export interface WorkspaceState {
     browserDraft: BrowserDraft;
     analyticsDraft: AnalyticsDraft;
     canvasToolsDraft: CanvasToolsDraft;
+    /**
+     * The Traverse tab last left open (feature studio-traverse-merge). Persisted rather than
+     * URL-only because switching namespace or instance rewrites the leaf WITHOUT the search
+     * param (see app/scopedRoute.ts), and being dumped on another tab by a context switch is
+     * the same "lose what you were looking at" the switchers exist to avoid.
+     */
+    traverseTab: TraverseTab;
     scanPrefill: ScanPrefill | null;
     mergeIntoCanvas: (vertices: VertexREST[], edges: EdgeREST[]) => void;
     removeFromCanvas: (kind: "node" | "edge", id: number) => void;
@@ -266,6 +312,7 @@ export interface WorkspaceState {
     setAnalyticsDraft: (patch: Partial<AnalyticsDraft>) => void;
     resetAnalyticsDraft: () => void;
     setCanvasToolsDraft: (patch: Partial<CanvasToolsDraft>) => void;
+    setTraverseTab: (tab: TraverseTab) => void;
     setScanPrefill: (prefill: ScanPrefill | null) => void;
     setFeedFilter: (patch: Partial<FeedFilterDraft>) => void;
     setInspectPrefill: (id: number | null) => void;

package/dist-lib/types/state/integrations.d.ts

@@ -1,5 +1,5 @@
 import type { InstanceConfig } from "../instances/types";
-import type { IntegrationProvider } from "../api/types";
+import type { FileLimits, IntegrationProvider } from "../api/types";
 /**
  * The integrations capability of one instance (feature integrations), read from the one route that
  * answers it: the provider catalog.
@@ -15,6 +15,16 @@ import type { IntegrationProvider } from "../api/types";
  */
 export type IntegrationsCapability = "checking" | "available" | "absent" | "unreachable";
 export declare function useIntegrationProviders(instance: InstanceConfig | null): import("@tanstack/react-query").UseQueryResult<NoInfer<IntegrationProvider[] | null>, unknown>;
+/**
+ * What a job may carry on this instance (feature integration-file-transport). Read once per
+ * instance and held for the session: the ceilings come from configuration, so they change when the
+ * instance is redeployed and never while a screen is open.
+ *
+ * It fails softly on purpose. An instance too old to serve the route answers 404, and a form that
+ * cannot read the ceilings must check NOTHING rather than fall back to a number of its own - see
+ * `lib/fileLimits.ts`, which is the only place allowed to interpret the absence.
+ */
+export declare function useIntegrationLimits(instance: InstanceConfig | null): import("@tanstack/react-query").UseQueryResult<NoInfer<FileLimits | null>, unknown>;
 /** Whether a failure is the capability being off rather than the instance being unwell. */
 export declare function isCapabilityRefusal(error: unknown): boolean;
 /** The capability verdict of a providers query, for the rail and for a deep link. */

package/dist-lib/{typescript-CmUu7z19.js → typescript-BIjKKvsW.js}

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

package/dist-lib/{xml-BID2APnO.js → xml-CT-uMOiT.js}

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

package/dist-lib/{yaml-CpQ-mN6F.js → yaml-Dezcc_VH.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fallen-8/studio",
-  "version": "0.0.36",
+  "version": "0.0.38",
   "description": "F8 Studio - browser frontend for Fallen-8 instances, and its graph canvas as a standalone component",
   "license": "MIT",
   "author": "Henning Rauch",