@fallen-8/studio 0.0.38 → 0.0.40

package/dist-lib/{javascript-BL3tIzUw.js → javascript-BAw14QCv.js}

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

package/dist-lib/{jsonMode-FxM7KRm5.js → jsonMode-BgO9x6Pt.js}

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

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

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

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

@@ -1,4 +1,4 @@
-import { m } from "./index-0ioFtrZM.js";
+import { m } from "./index-bm1ERcEP.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-zMn1qnUE.js → tsMode--dsrDMOH.js}

@@ -1,4 +1,4 @@
-import { t as O, m as I } from "./index-0ioFtrZM.js";
+import { t as O, m as I } from "./index-bm1ERcEP.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/endpoints.d.ts

@@ -112,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>;
@@ -135,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>;

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

@@ -438,8 +438,18 @@ export interface ChatProviderStatsREST {
     /**
      * From the configured options, not from a probe target: reported for EVERY backend, including
      * the ones with no residency API.
+     *
+     * The ASSIST purpose's model. It keeps the bare name `model` deliberately: every reader of it
+     * predates the purposes, and renaming it would have changed a contract to add one.
      */
     model: string | null;
+    /**
+     * The AGENT purpose's model (feature agent-host), or null when the selected backend names none,
+     * which is the shipped state for OpenAI and Anthropic. Distinct from `model` because the two are
+     * configured by different people for different reasons: the assist model is the fine-tune, the
+     * agent model is a general one that can call tools.
+     */
+    agentModel?: string | null;
     loaded: boolean;
     resident?: boolean | null;
     gpu?: boolean | null;
@@ -1035,6 +1045,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[];
@@ -1117,7 +1134,7 @@ export interface IntegrationDiagnostic {
  * 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
+ * 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.
  *

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/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;

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

@@ -0,0 +1,174 @@
+import type { EdgeREST, VectorSearchResultREST, VertexREST } from "../api/types";
+import type { InstanceConfig } from "../instances/types";
+import type { CanvasEdge, CanvasNode } from "../state/instanceStore";
+/**
+ * Pure logic for the Canvas "Interact" tab (feature canvas-interact): filters build a MATCH SET
+ * over the canvas vertices, and two view-only verbs (expand, remove) apply to it. Kept DOM-free
+ * so every decision below is unit-tested without a render.
+ *
+ * The verbs are also the single home for expand-on-demand: the Detail panel's "Expand neighbors"
+ * runs `expandVertices` over one id, the tab runs it over the match set. See
+ * features/open/canvas-interact/spec.md.
+ */
+/**
+ * The most candidates a DATABASE-degree evaluation will sweep. Two requests per candidate, so the
+ * cap is about bounding a click, not about correctness; above it the run is refused rather than
+ * partially evaluated, and the cheap filters are the narrowing tool. One tuning home.
+ */
+export declare const DEGREE_SWEEP_CAP = 1000;
+/**
+ * The most matched vertices one Expand may sweep. A single vertex's expand is already several
+ * requests (both adjacency listings, then every edge and endpoint), so this is the difference
+ * between a click and a thousand-request storm.
+ */
+export declare const EXPAND_SWEEP_CAP = 100;
+/** How many vertices are expanded (or degree-probed) concurrently in one batched round. */
+export declare const INTERACT_BATCH_SIZE = 8;
+/** Which edges a degree comparison counts. */
+export type DegreeSource = "database" | "canvas";
+export type DegreeDirection = "in" | "out" | "total";
+export type DegreeOp = "over" | "under";
+export type SemanticDirection = "closer" | "farther";
+/**
+ * The filters that need no server round trip, so they evaluate live on every render: label and
+ * property read the canvas snapshot, and on-canvas degree counts the edges actually loaded.
+ * A field is INACTIVE when empty, which is why the degree value is a string - "" has to mean
+ * "not filtering", and 0 is a legitimate threshold.
+ */
+export interface CheapFilters {
+    label: string;
+    propKey: string;
+    propTerm: string;
+    degreeSource: DegreeSource;
+    degreeDirection: DegreeDirection;
+    degreeOp: DegreeOp;
+    /** The comparison value as typed; "" (or unparseable) leaves the degree filter inactive. */
+    degreeValue: string;
+}
+/** A degree filter that is actually on: parsed, and known to be the canvas-counted source. */
+export interface ActiveDegree {
+    direction: DegreeDirection;
+    op: DegreeOp;
+    value: number;
+}
+/**
+ * The degree filter as a number, or null when it is not filtering at all. A blank or
+ * unparseable value is inactive rather than 0: typing "over 0" is a real filter and must not be
+ * what an empty box means.
+ */
+export declare function activeDegree(filters: CheapFilters): ActiveDegree | null;
+/** Whether any cheap filter is on, which is what makes an empty match set meaningful. */
+export declare function anyCheapActive(filters: CheapFilters): boolean;
+/** `over` and `under` are strict, so "over 50" excludes a vertex of exactly 50. */
+export declare function compareDegree(degree: number, op: DegreeOp, value: number): boolean;
+/**
+ * The canvas vertices surviving every ACTIVE cheap filter, AND-composed.
+ *
+ * A stub vertex (merged as an edge's unloaded endpoint: no `props`, null label) matches no label
+ * and no property filter, because nothing was ever read about it - but an on-canvas degree filter
+ * counts its loaded edges like any other vertex's, since that is a fact about the view rather
+ * than about the element.
+ *
+ * On-canvas degree delegates to the style engine's `visibleDegrees`, which is what degree-based
+ * node sizing already reads: one home for counting the view's edges.
+ */
+export declare function matchCheap(nodes: CanvasNode[], edges: CanvasEdge[], filters: CheapFilters): CanvasNode[];
+/** The ids whose fetched degree satisfies the comparison; an id with no score is not matched. */
+export declare function applyDegree(degrees: ReadonlyMap<number, number>, op: DegreeOp, value: number): Set<number>;
+/** What a semantic threshold decided, including how much of the input it could not judge. */
+export interface SemanticVerdict {
+    matched: Set<number>;
+    /** Candidates the search returned no score for. They match NOTHING, in either direction. */
+    unscored: number;
+}
+/**
+ * The candidates a semantic threshold keeps, oriented by the search's own metric.
+ *
+ * `higherIsBetter` comes from the server (Cosine/DotProduct: higher is closer; L2: lower is), and
+ * the threshold is in that metric's RAW units - the client never re-derives a similarity.
+ *
+ * A candidate the result carries no score for is UNSCORED and matches neither direction. It has
+ * no embedding, or it fell outside the search window, and either way nothing measured it: "I
+ * could not look" must never become "it is far", least of all in front of a bulk remove.
+ */
+export declare function applySemantic(candidateIds: number[], result: VectorSearchResultREST | null, direction: SemanticDirection, threshold: number): SemanticVerdict;
+/** How far a batched sweep has got, for the panel's progress line. */
+export interface SweepProgress {
+    done: number;
+    total: number;
+}
+/** A degree sweep's answer: what it read, and what it could NOT read. */
+export interface DegreeSweepResult {
+    degrees: Map<number, number>;
+    /**
+     * Candidates whose degree the server would not answer. They are absent from `degrees`, so they
+     * match nothing - and the caller must SAY so, because "0 of 500 match" is otherwise
+     * indistinguishable from "500 vertices measured and none qualified".
+     */
+    unreadable: number;
+}
+/**
+ * Every candidate's DATABASE degree in one direction, batched and abortable.
+ *
+ * `total` costs both requests per vertex; a direction costs one. A vertex whose degree cannot be
+ * read is left OUT of the map rather than recorded as 0, so it fails the comparison instead of
+ * being swept up by "under x" by a bulk remove - and it is COUNTED, which is the half that makes
+ * the rule honest rather than merely safe (the semantic filter's unscored count is the precedent).
+ */
+export declare function degreeSweep(instance: InstanceConfig, ids: number[], options: {
+    direction: DegreeDirection;
+    signal?: AbortSignal;
+    onProgress?: (progress: SweepProgress) => void;
+}): Promise<DegreeSweepResult>;
+/** What an expand sweep actually did, which is never assumed to be "all of it". */
+export interface ExpandOutcome {
+    /** Vertices the sweep ATTEMPTED (its progress position), failures included. */
+    attempted: number;
+    /** Vertices whose neighborhood came back and was merged. `expanded + failed === attempted`. */
+    expanded: number;
+    total: number;
+    /** True when the canvas element ceiling stopped the sweep before the last vertex. */
+    stoppedAtCeiling: boolean;
+    cancelled: boolean;
+    /**
+     * Vertices whose neighborhood fetch threw. NOTE the honest limitation: the neighborhood
+     * primitive swallows per-request HTTP failures and returns empty arrays, so a vertex whose
+     * adjacency the server refused looks exactly like a vertex with no neighbors. This counts only
+     * what reaches us as an exception (a malformed answer), which is why the panel never presents
+     * it as "everything that went wrong" - and why an ABORT is handled by discarding its batch
+     * rather than by counting it here, since an aborted fetch does not throw out of the primitive
+     * either.
+     */
+    failed: number;
+    /**
+     * Vertices where the per-vertex edge cap cut the neighborhood short, so the canvas holds only
+     * part of what they touch. Reported, because the alternative is a hub that looks fully expanded.
+     */
+    truncated: number;
+}
+/**
+ * Expand a set of vertices: one hop each, merged as every batch lands.
+ *
+ * The one home for expand-on-demand. `onMerge` is called per batch rather than once at the end,
+ * so a long sweep grows the canvas visibly and a cancel keeps what already landed. `skip` is
+ * re-read per batch through `liveElementCount`/`skipIds` callbacks rather than captured once,
+ * because each merge changes what the next batch would re-fetch.
+ *
+ * The sweep stops when the canvas reaches `elementCeiling` and SAYS so (`stoppedAtCeiling`), the
+ * same honesty as the whole-graph truncation notice - silently expanding half a match set would
+ * look identical to a graph that simply has fewer neighbors. The signal reaches the fetches
+ * themselves, so a cancel stops issuing requests rather than only stopping the next batch.
+ */
+export declare function expandVertices(instance: InstanceConfig, ids: number[], options: {
+    /** Ids not to re-hydrate, re-read before each batch (the live canvas). */
+    skipIds: () => ReadonlySet<number>;
+    /** Current canvas element count, re-read before each batch. */
+    liveElementCount?: () => number;
+    /** Stop once the canvas holds this many elements. Omitted = no ceiling. */
+    elementCeiling?: number;
+    onMerge: (vertices: VertexREST[], edges: EdgeREST[]) => void;
+    onProgress?: (progress: SweepProgress) => void;
+    signal?: AbortSignal;
+    /** Per-vertex edge cap; defaults to the standing expand cap. */
+    cap?: number;
+}): Promise<ExpandOutcome>;

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

@@ -62,6 +62,18 @@ export interface SectionGroup {
     /** The sub-groups, direct keys first; a single unlabelled group when the section renders flat. */
     groups: SettingGroup[];
 }
+/**
+ * The purposes a chat completion can name, as they are spelled in a settings key
+ * (`Fallen8:Chat:<Backend>:Models:<Purpose>`). ONE list, so a surface that offers something per
+ * purpose cannot offer it for a subset: the server resolves the model per purpose and refuses a
+ * completion whose purpose names none, which is a state an operator has to be able to see and fix
+ * for every purpose that exists.
+ *
+ * Order is the order they are shown in, and `Assist` is first because it is the purpose a
+ * completion gets when it names none. Not because it is the one an instance has configured: the
+ * two Ollama-protocol backends default BOTH purposes and the two metered ones default neither.
+ */
+export declare const CHAT_PURPOSES: readonly string[];
 /**
  * Buckets the published settings into the ordered sections, preserving the server's order within a
  * raw section: the catalog authors related keys adjacently (an index switch is followed by the index

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

@@ -110,6 +110,13 @@ export declare const FIELD_HELP: {
     readonly canvasEdgeLabels: "Show edge-container names on edges (2D: always visible, 3D: on hover). Subject to the same 5,000-element degrade threshold as node labels.";
     readonly canvasEdgeArrows: "Draw arrowheads pointing at each edge's target vertex, making direction visible in both 2D and 3D.";
     readonly saveGameDeleteFiles: "Also delete the checkpoint's files on the server's disk, not just its registry entry. The data is then unrecoverable.";
+    readonly interactLabel: "Match only vertices carrying exactly this label. A vertex the canvas holds only as an edge's endpoint has no label read yet, so it never matches a label filter.";
+    readonly interactProperty: "Match vertices carrying this property key; add a term to require the value to contain it (case-insensitive). This reads the canvas snapshot, which holds scalars only and caps strings at 200 characters, so a term that occurs only past that cap will not match. The Find tab is the server-side search.";
+    readonly interactDegreeSource: "Which edges the degree counts. 'the database' asks the server for the vertex's true degree, one small request per candidate, so it needs Preview. 'edges on canvas' counts only the edges currently loaded: instant, and the number you see, but a vertex you never expanded reads 0 there whatever the database knows.";
+    readonly interactDegree: "Keep vertices whose degree is strictly over (or under) this number, counted in the chosen direction. Leave the number empty to switch the filter off; 0 is a real bound, not 'off'.";
+    readonly interactSemantic: "Keep vertices whose stored embedding is closer (or farther) than a threshold from this text. The provider embeds the text once, then the bound vector index ranks your elements. The threshold is in the index metric's RAW units, exactly as the search reports them: with Cosine/DotProduct a higher score is closer, with L2 a lower one is.";
+    readonly interactDegreeUnreadable: "Vertices whose degree the server would not answer (deleted since they landed on the canvas, or an instance that stopped answering). They are left OUT of the match set rather than counted as 0, so 'under x' cannot sweep up a vertex nobody measured, and they are counted here so a shrunken match set is never mistaken for a measurement.";
+    readonly interactSemanticUnscored: "A canvas vertex the search returned no score for (no embedding stored, or outside the search window) matches NEITHER direction, and the preview counts it. Nothing measured it, so calling it 'far' would remove vertices on no evidence.";
     readonly feedKinds: "Event kinds to show and count. Dimensions combine like the REST filter grammar: AND across dimensions, OR within one. Resync events are exempt and always shown, because they mean continuity was lost.";
     readonly feedElements: "Restrict to vertex or edge events: the elements dimension of the REST filter grammar.";
     readonly feedLabels: "Exact, case-sensitive labels to match (Enter or comma adds one). An element without a label never matches a labels filter, the same rule the server applies.";

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

@@ -6,7 +6,7 @@ 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
+ * someone their several gibibytes of files are over the ceiling. Reporting that in mebibytes is arithmetic
  * the reader should not have to do while being told no.
  */
 export declare function formatBytes(bytes: number): string;

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

@@ -41,8 +41,22 @@ export declare function capList<T>(items: readonly T[], max?: number): {
     shown: T[];
     total: number;
 };
+/**
+ * How tall ONE row is, in rem, for a list whose rows are not a single line. The cap is a row
+ * COUNT, so it needs a height per row to work with; the CSS default (2.5rem, see index.css) is a
+ * one-line table row, and a list of wrapped prose hits that ceiling several rows early and scrolls
+ * a list far shorter than its threshold. Add an entry only for a list that reads that way.
+ */
+export declare const SCROLL_ROW_REM: {
+    /**
+     * Available integrations (IntegrationsScreen): each row is a sentence describing what the
+     * integration reads, and it wraps to three or four lines on a narrow window.
+     */
+    readonly integrations: 5;
+};
 /**
  * Inline style that tells a `.scroll-list` wrapper how many rows to show before it caps its
- * height and scrolls. Custom CSS properties need the cast; this keeps it in one place.
+ * height and scrolls, and optionally how tall to assume one row is (see {@link SCROLL_ROW_REM};
+ * omitted, the CSS default applies). Custom CSS properties need the cast; this keeps it in one place.
  */
-export declare function scrollRows(rows: number): CSSProperties;
+export declare function scrollRows(rows: number, rowRem?: number): CSSProperties;

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

@@ -25,6 +25,7 @@ export interface Neighborhood {
 export declare function fetchVertexNeighborhood(instance: InstanceConfig, vertexId: number, options: {
     cap: number;
     skipNeighborIds?: ReadonlySet<number>;
+    signal?: AbortSignal;
 }): Promise<Neighborhood>;
 /**
  * An edge's endpoint vertices plus EVERY edge between them, both directions — found by

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

@@ -0,0 +1,19 @@
+/**
+ * The engine's own ceiling on a kNN `k`, mirrored client-side.
+ *
+ * ONE home, because every caller of `/scan/index/vector` and `/embedding/search` has to agree with
+ * the server or the request is refused outright: `VectorIndex.MaxK` is 1024 and
+ * `VectorIndex.TryNearestNeighbors` rejects anything above it, which the embedding controller
+ * turns into a 400 AFTER the provider has already embedded the query text. So a k picked from some
+ * other quantity does not degrade, it fails, and it fails having spent a model call.
+ *
+ * That is not hypothetical: the canvas Interact tab first shipped this asking for the canvas
+ * element cap (20,000) worth of neighbours, which made its semantic filter unusable on every real
+ * instance while every mocked test passed.
+ */
+export declare const MAX_K = 1024;
+/**
+ * A kNN window that cannot exceed the engine's ceiling, for a caller who wants "as many as I might
+ * need" rather than a number a person typed. `wanted` is what the caller would ideally ask for.
+ */
+export declare function boundedK(wanted: number): number;

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

@@ -220,9 +220,17 @@ export declare const DEFAULT_ANALYTICS_DRAFT: AnalyticsDraft;
  * state (re-run on demand), exactly like every other result in the studio - only the inputs here
  * persist.
  */
+/**
+ * The tabs of the canvas tool strip, in strip order. ONE home for the ids: the strip renders them
+ * and the persisted `canvasToolsDraft.tab` is validated against them on rehydration.
+ */
+export declare const CANVAS_TABS: readonly ["style", "find", "connect", "interact"];
+export type CanvasTab = (typeof CANVAS_TABS)[number];
+/** Guard for the untrusted source of a canvas tab id: persisted storage. */
+export declare const isCanvasTab: (value: unknown) => value is CanvasTab;
 export interface CanvasToolsDraft {
-    /** Which right-panel tab is active: styling, element search, or path connecting. */
-    tab: "style" | "find" | "connect";
+    /** Which right-panel tab is active: styling, element search, path connecting, or interacting. */
+    tab: CanvasTab;
     /** Find: the all-property contains term (fed to POST /scan/graph/properties). */
     findTerm: string;
     /** Find: optional exact-match label restrictor; empty searches every label. */
@@ -233,6 +241,25 @@ export interface CanvasToolsDraft {
     connectMaxDepth: number;
     /** Connect: use every canvas vertex, or only a picked subset, as the pair endpoints. */
     connectScope: "all" | "pick";
+    /**
+     * Interact (feature canvas-interact): the filter rows that build the match set the tab's two
+     * verbs act on. Every one is INACTIVE when blank - which is why the two numeric thresholds are
+     * strings, since 0 is a legitimate degree bound and "" has to mean "not filtering" - and with
+     * none of them active the match set is every canvas vertex, i.e. "expand all".
+     */
+    interactLabel: string;
+    interactPropKey: string;
+    interactPropTerm: string;
+    /** Which edges the degree comparison counts: the database's answer, or the loaded ones. */
+    interactDegreeSource: "database" | "canvas";
+    interactDegreeDirection: "in" | "out" | "total";
+    interactDegreeOp: "over" | "under";
+    interactDegreeValue: string;
+    interactSemanticText: string;
+    interactSemanticIndexId: string;
+    interactSemanticDirection: "closer" | "farther";
+    /** The threshold in the metric's RAW units, as typed (blank = the filter is off). */
+    interactSemanticThreshold: string;
 }
 export declare const DEFAULT_CANVAS_TOOLS_DRAFT: CanvasToolsDraft;
 /** One-shot navigation intent: "open Query with this index preselected" (cleared on consume). */
@@ -295,6 +322,8 @@ export interface WorkspaceState {
     scanPrefill: ScanPrefill | null;
     mergeIntoCanvas: (vertices: VertexREST[], edges: EdgeREST[]) => void;
     removeFromCanvas: (kind: "node" | "edge", id: number) => void;
+    /** Removes a SET of vertices (and their incident edges) in one write - see the implementation. */
+    removeManyFromCanvas: (ids: readonly number[]) => void;
     clearCanvas: () => void;
     setWholeGraphTruncation: (truncation: WholeGraphTruncation | null) => void;
     setStyleConfig: (patch: Partial<StyleConfig>) => void;

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

@@ -27,6 +27,16 @@ export declare function useIntegrationProviders(instance: InstanceConfig | null)
 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 href for a provider's documentation link, or null when there is nothing safe to link.
+ *
+ * The runtime refuses anything but an absolute http(s) URL when it builds its catalog, so this is
+ * the second half of that check rather than the only one: the descriptor arrives over the network
+ * from a deployable Studio does not ship with, and a `javascript:` href here would run in the
+ * operator's browser. Anything else is dropped silently - the row simply carries no link, which is
+ * the same state as a provider that declares no documentation.
+ */
+export declare function docsHref(provider: Pick<IntegrationProvider, "docsUrl">): string | null;
 /** The capability verdict of a providers query, for the rail and for a deep link. */
 export declare function capabilityOf(query: {
     isError: boolean;

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

@@ -1,4 +1,4 @@
-import { m as s } from "./index-0ioFtrZM.js";
+import { m as s } from "./index-bm1ERcEP.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-CT-uMOiT.js → xml-BgTKhrv7.js}

@@ -1,4 +1,4 @@
-import { m as r } from "./index-0ioFtrZM.js";
+import { m as r } from "./index-bm1ERcEP.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-Dezcc_VH.js → yaml-CDTzHXpW.js}

@@ -1,4 +1,4 @@
-import { m as l } from "./index-0ioFtrZM.js";
+import { m as l } from "./index-bm1ERcEP.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.38",
+  "version": "0.0.40",
   "description": "F8 Studio - browser frontend for Fallen-8 instances, and its graph canvas as a standalone component",
   "license": "MIT",
   "author": "Henning Rauch",