@fallen-8/studio 0.0.35 → 0.0.37

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

@@ -7,8 +7,9 @@
  * needed its own component would be a contract failure rather than a UI task, and the agent that
  * writes the fourth integration cannot write a React component for it anyway.
  *
- * There is no schedule, no run history and no saved job list here, because the runtime keeps none:
- * timing belongs to whoever wants the data, and a Studio-side copy would be a second home for a
- * decision this screen cannot judge. Submitting is a one-shot action.
+ * Submitting STARTS a run and does not wait for it: the runtime answers a run id, and this screen
+ * then watches that run - the phase it is in, and its report once it ends. That is not a run history
+ * (the boundary is on IntegrationRunState), so there is no schedule, no list of past runs and no
+ * saved job list here; timing belongs to whoever wants the data.
  */
 export declare function IntegrationsScreen(): import("react").JSX.Element;

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

@@ -1,7 +1,7 @@
 /**
- * Samples (feature sample-graphs): the one-click demo gallery, promoted from the Dashboard
- * to its own rail entry so every card spans the full width and carries its "what you can
- * test" steps, with a tag bar to filter by capability. Namespace-scoped — a load replaces
+ * Samples (feature sample-graphs): the one-click demo gallery. It has its own rail entry so every
+ * card spans the full width and carries its "what you can test" steps, with a tag bar to filter
+ * by capability. Namespace-scoped - a load replaces
  * the active namespace's graph (SampleGraphsPanel owns the loader + typed-confirm wipe).
  */
 export declare function SamplesScreen(): 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;
@@ -199,12 +212,41 @@ export declare const DEFAULT_CANVAS_TOOLS_DRAFT: CanvasToolsDraft;
 /** One-shot navigation intent: "open Query with this index preselected" (cleared on consume). */
 export interface ScanPrefill {
     indexId: string;
+    /**
+     * A query vector to search WITH, in the bracketed form the vector box parses. Set by the
+     * "find similar" gesture, which reads it off the source element's own stored embedding: the
+     * search surface takes a vector, never an element id, so the element-as-query gesture is
+     * composed on this side rather than asked of the server.
+     */
+    vectorText?: string;
+    /**
+     * The element the vector came from, so it can be dropped from its own results. There is no
+     * self-exclusion anywhere in the engine or the REST contract, so an unfiltered search returns
+     * the source element at rank 1 every time.
+     */
+    sourceElementId?: number;
+    /**
+     * The source element's label, inherited as the search constraint. Not a convenience: several
+     * entity kinds embed as little more than their identifier, so an unconstrained similarity
+     * search over such a graph ranks identifier-shaped noise against real matches.
+     */
+    label?: string;
+    kind?: "any" | "vertex" | "edge";
 }
 export interface WorkspaceState {
     /** The Events panel's interest filter (feature studio-event-feed, see feedFilter.ts). */
     feedFilter: FeedFilterDraft;
     /** One-shot navigation intent: "open the Browser inspecting this element id". */
     inspectPrefill: number | null;
+    /**
+     * The integration identity whose run this instance is watching, or null.
+     *
+     * PERSISTED, unlike the one-shot prefills, and that is the point: a run outlives the request that
+     * started it and can take hours, so reopening the screen - or reloading the page - has to re-attach
+     * to it rather than lose it. The identity is enough to re-find the run, because the runtime keys its
+     * slot by exactly that.
+     */
+    integrationWatch: string | null;
     canvasNodes: Record<number, CanvasNode>;
     canvasEdges: Record<number, CanvasEdge>;
     styleConfig: StyleConfig;
@@ -217,6 +259,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;
@@ -237,9 +286,11 @@ 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;
+    setIntegrationWatch: (instanceId: string | null) => void;
 }
 type WorkspaceStore = UseBoundStore<StoreApi<WorkspaceState>>;
 /**

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

@@ -4,8 +4,27 @@ import type { InstanceConfig } from "../instances/types";
  * consumer reads one cache row and rides its periodic refresh; /status is the cheap
  * discovery surface (available plugins + live index inventory — feature
  * studio-index-discovery), unlike the budgeted Graph-shape pass in graphShape.ts.
+ *
+ * Accepts null and then asks nothing: the shell-level readers (the durability banner, the
+ * first-run auto-show) render outside the connection gate, so "no instance yet" is a state they
+ * pass through rather than an assertion they can make.
+ *
+ * Pass poll: true to drive the shared row on a timer. Exactly one caller does - the app shell,
+ * on the same 15s cadence as its instance health probe - because the durability banner is a
+ * warning nobody goes looking for: it has to arrive while the operator is on some other screen.
+ * Every other observer rides that refresh through the shared cache row and asks for nothing.
+ *
+ * Polling implies `retry: 0`, matching the health probe, and that pairing is load-bearing rather
+ * than tidy: on a server that predates namespaces the bound view collapses to the raw instance, so
+ * this row and the probe become the SAME query key. react-query takes `retry` from whichever
+ * observer initiated the current fetch, so without this the probe's deliberate fail-fast became a
+ * coin flip against a default of three retries - and for the ~7s of backoff that won, a dead
+ * instance still read "online" with the nav unlocked. There is no point retrying a 15s poll anyway;
+ * the next tick is the retry.
  */
-export declare function useStatus(instance: InstanceConfig): import("@tanstack/react-query").UseQueryResult<NoInfer<import("../api/types").StatusREST | null>, Error>;
+export declare function useStatus(instance: InstanceConfig | null, options?: {
+    poll?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<NoInfer<import("../api/types").StatusREST | null>, Error>;
 /**
  * The instance's configuration (features instance-config and writable-instance-config): the setting
  * inventory, the semantic providers and the observability posture behind the Connect Configuration

package/dist-lib/{typescript-oqqsXxrY.js → typescript-LNGesWYR.js}

@@ -1,4 +1,4 @@
-import { m as s } from "./index-B9b5xEwe.js";
+import { m as s } from "./index-BQbFjItv.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-pmqwhaBA.js → xml-BuD_-6ib.js}

@@ -1,4 +1,4 @@
-import { m as r } from "./index-B9b5xEwe.js";
+import { m as r } from "./index-BQbFjItv.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-DN1I59zm.js → yaml-DCzPbyTS.js}

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

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

@@ -1,13 +0,0 @@
-/**
- * Dashboard (FR-2/3/4): the status overview for the active namespace — vertex/edge counts
- * and memory, from /status. It is deliberately lean: the sample gallery, the persistence/
- * administration actions, the stored-query library, the plugin registry, and the instance
- * configuration (semantic providers, observability) each have their own home (Samples, Save
- * games, Query, Plugins, and the Connect Configuration section).
- *
- * On an empty, not-yet-dismissed namespace this is also the home of the first-run show
- * (feature studio-first-run): instead of three zeroed tiles a newcomer gets an animated,
- * read-only walkthrough that creates nothing. It is dismissed per namespace and re-armed the
- * moment the namespace is seen non-empty, so a returning user is never nagged.
- */
-export declare function DashboardScreen(): import("react").JSX.Element;