@fallen-8/studio 0.0.32

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

@@ -0,0 +1,58 @@
+/**
+ * SPDX SBOM → Fallen-8 graph (feature sample-graphs). ONE transform, two consumers: the
+ * build script bakes the fallen-8-core default (fallen8-deps.jsonl), and the Studio's
+ * GitHub card runs it in the browser on any public repo's SBOM fetched just-in-time from
+ * api.github.com. Output is the jsonlGraph vertex/edge shape, so both paths hand it to
+ * the same importer + loader.
+ */
+import type { JsonlEdge, JsonlVertex } from "./jsonlGraph";
+/** The subset of the SPDX SBOM document we read (GitHub's dependency-graph export). */
+export interface SpdxSbom {
+    packages?: SpdxPackage[];
+    relationships?: SpdxRelationship[];
+}
+interface SpdxPackage {
+    name: string;
+    SPDXID: string;
+    versionInfo?: string;
+    licenseConcluded?: string;
+    licenseDeclared?: string;
+    externalRefs?: Array<{
+        referenceType?: string;
+        referenceLocator?: string;
+    }>;
+}
+interface SpdxRelationship {
+    spdxElementId: string;
+    relatedSpdxElement: string;
+    relationshipType: string;
+}
+export interface SbomGraphResult {
+    vertices: JsonlVertex[];
+    edges: JsonlEdge[];
+    /** Ecosystem → package count, for the caller's summary/messaging. */
+    ecosystemCounts: Record<string, number>;
+}
+/**
+ * Transforms an SPDX SBOM into a dependency graph. Nodes are packages (label =
+ * ecosystem); edges are DEPENDS_ON relationships. A package referenced only by a
+ * relationship (no package entry) is skipped, so every edge resolves — the importer
+ * requires it. Deterministic: packages keep their SBOM order for stable ids.
+ */
+export declare function sbomToGraph(sbom: SpdxSbom): SbomGraphResult;
+/** GitHub's rate-limit headers, passed through so the message can name a retry time. */
+export interface GithubRateLimit {
+    remaining: string | null;
+    reset: string | null;
+}
+/**
+ * Turns a non-OK GitHub SBOM response into a SPECIFIC, actionable message (feature
+ * sample-graphs). The `GET /repos/{repo}/dependency-graph/sbom` endpoint answers 404 for
+ * THREE different causes — the repo is missing, it's private, or its dependency graph is
+ * disabled — so the old "not found (or private, or has no dependency graph)" lumped all
+ * three and buried the one the user can act on. GitHub's own error body carries a `message`
+ * that distinguishes them (notably "Dependency graph is disabled…"); we lead with that.
+ * Pure + parameterized on `now` so it is unit-testable.
+ */
+export declare function describeGithubSbomFailure(repo: string, status: number, githubMessage: string, rateLimit: GithubRateLimit, now: number): string;
+export {};

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

@@ -0,0 +1,39 @@
+/**
+ * Per-section "How does this work?" help (feature studio-section-help): the ONE home for
+ * mapping each Studio main section to the 1-3 docs pages that explain it. Keys are the same
+ * `leaf` strings used by the NAV array in app/AppShell.tsx; the shell renders <SectionHelp/>
+ * once, keyed by the active leaf. The explanation of every feature lives on its docs page -
+ * this module only wires a section to the pages, it does not re-narrate them (one-home rule).
+ *
+ * Blurbs mirror each page's frontmatter `description` in short form. A vitest drift guard
+ * asserts every `slug` here resolves to a real docs/src/content/docs/<slug>.(md|mdx) file, and
+ * a coverage test asserts every NAV leaf has an entry here.
+ */
+/** Published Starlight docs origin. The single home for the docs URL, shared with the
+ *  top-bar "docs" pill in AppShell so there is one origin constant, not two. */
+export declare const DOCS_BASE = "https://docs.fallen-8.com/";
+/** Absolute URL of a docs page from its slug (e.g. "path-finding" -> ".../path-finding/"). */
+export declare const docUrl: (slug: string) => string;
+/** One row in a section's help popover: a docs page, its title, and a one-line blurb. */
+export interface SectionDocLink {
+    /** Docs page slug, e.g. "path-finding" (NOT a full URL). Resolved via docUrl. */
+    slug: string;
+    /** Page title shown as the row label. */
+    title: string;
+    /** One-line description (mirrors the page's frontmatter description in short form). */
+    blurb: string;
+}
+/** The help content for one Studio section: a heading plus 1-3 doc links, primary first. */
+export interface SectionHelpEntry {
+    /** Popover heading, e.g. "How path finding works". Also the button's title tooltip. */
+    heading: string;
+    /** Ordered primary-first, length 1..3 (enforced by test). */
+    links: SectionDocLink[];
+}
+/**
+ * Keyed by the SAME leaf strings as AppShell's NAV array. Flat/unscoped sections carry a
+ * leading slash ("/", "/save-games", "/integrations"); scoped sections are bare leaves.
+ */
+export declare const SECTION_HELP: Record<string, SectionHelpEntry>;
+/** Accessor: the help entry for a section leaf, or undefined when the leaf has no mapping. */
+export declare const sectionHelp: (leaf: string | null | undefined) => SectionHelpEntry | undefined;

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

@@ -0,0 +1,95 @@
+import type { SemanticTraversalSpecification, SubGraphSemanticSummary } from "../api/types";
+/**
+ * The declarative semantic-traversal drafts (features element-embeddings and
+ * subgraph-semantic-thresholds), as edited in the studio and built into requests. Pure
+ * logic here so the gating rules — which mirror the server's one-owner-per-slot and
+ * metric constraints — are unit-testable without a screen.
+ *
+ * Two shapes share one query core:
+ * - The Path screen edits a {@link SemanticDraft}: the query plus the block-local
+ *   minScore filter / costBySimilarity cost switches.
+ * - The Subgraph screen edits a bare {@link SemanticQueryDraft}: one query per request;
+ *   the thresholds live on the vertex-filter SLOTS (top level and per vertex pattern
+ *   step), not in the block.
+ *
+ * Reference for the rules: features/done/element-embeddings/README.md, "Semantic traversal".
+ */
+export type SemanticSource = "vector" | "text";
+export type SemanticMetric = "Cosine" | "DotProduct" | "L2";
+/**
+ * How a vertex-filter slot is filled (feature subgraph-semantic-thresholds): nothing, a
+ * compiled C# fragment, or a declarative semantic threshold. One owner per slot is
+ * structural — a slot has exactly one mode.
+ */
+export type SlotMode = "everything" | "fragment" | "semantic";
+/** The query core: what the traversal scores against, without any slot decisions. */
+export interface SemanticQueryDraft {
+    source: SemanticSource;
+    vectorText: string;
+    queryText: string;
+    embeddingName: string;
+    metric: SemanticMetric;
+}
+export declare const DEFAULT_SEMANTIC_QUERY_DRAFT: SemanticQueryDraft;
+/** The Path screen's block: the query plus its declarative filter/cost switches. */
+export interface SemanticDraft extends SemanticQueryDraft {
+    /** Whether the block is active (sent, and owning its declarative slots). */
+    enabled: boolean;
+    /** Apply the declarative minScore vertex filter. */
+    minScoreEnabled: boolean;
+    minScore: string;
+    /** Apply the declarative similarity vertex cost (path only, non-DotProduct). */
+    costBySimilarity: boolean;
+}
+export declare const DEFAULT_SEMANTIC_DRAFT: SemanticDraft;
+/**
+ * The block owns the vertex-FILTER slot whenever the server installs a filter closure into
+ * it: for the minScore threshold, and ALSO for costBySimilarity alone, which carries an
+ * implied "has the named embedding" filter (a cost is only defined over embedded vertices).
+ * See SemanticTraversalHelper.TryBuild's `if (MinScore) … else if (CostBySimilarity)`.
+ */
+export declare function semanticOwnsVertexFilter(draft: SemanticDraft): boolean;
+/** The block owns the vertex-COST slot when costBySimilarity is active (path only). */
+export declare function semanticOwnsVertexCost(draft: SemanticDraft): boolean;
+export type SemanticQueryBuild = {
+    ok: true;
+    spec: SemanticTraversalSpecification;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Builds the query core of a semantic block from a draft — the one implementation both
+ * screens validate with. `providerEnabled` is the resolved provider state (null =
+ * unknown/not-yet-computed): queryText needs it true.
+ */
+export declare function buildSemanticQuery(draft: SemanticQueryDraft, options: {
+    providerEnabled: boolean | null;
+}): SemanticQueryBuild;
+/**
+ * Threshold text → finite number; empty or non-numeric is undefined (an empty input is
+ * NOT silently zero). The one parser every threshold slot builds and validates with.
+ */
+export declare function parseThreshold(text: string): number | undefined;
+/**
+ * One line for the subgraph list's semantic badge tooltip: what the registered subgraph
+ * was bound to and where its thresholds sit.
+ */
+export declare function describeSemanticSummary(summary: SubGraphSemanticSummary): string;
+export type SemanticBuild = {
+    ok: true;
+    spec: SemanticTraversalSpecification | undefined;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Builds the Path screen's block from a draft, applying the same guards the server
+ * enforces so an invalid request is structurally caught before submit. `allowCost` is
+ * false where costBySimilarity cannot apply. Returns spec: undefined when the block is
+ * disabled.
+ */
+export declare function buildSemanticSpec(draft: SemanticDraft, options: {
+    allowCost: boolean;
+    providerEnabled: boolean | null;
+}): SemanticBuild;

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

@@ -0,0 +1,43 @@
+import type { PathSpecification, PatternSpecification, SemanticTraversalSpecification, StoredPathQueryBlock, StoredSubGraphQueryBlock } from "../api/types";
+import type { PathDraft, SubgraphPatternDraft } from "../state/instanceStore";
+/**
+ * Pure stored-query logic (concept spec §5): spec builders that make the server's
+ * "storedQuery is mutually exclusive with inline fragments" 400 structurally
+ * unreachable, block extraction for "Save as stored query…", and the read-only
+ * preview rows rendered under the picker.
+ */
+/** Server-side name rule: always a safe URL path segment, compared case-sensitively. */
+export declare const STORED_QUERY_NAME: RegExp;
+/**
+ * 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
+ * (it supplies the query vector to declarative closures, inline fragments, or a stored
+ * path query's fragments alike).
+ */
+export declare function buildPathSpecification(draft: PathDraft, semantic?: SemanticTraversalSpecification): PathSpecification;
+/** The draft's committed fragments as a registration block (empty parts omitted). */
+export declare function pathBlockFromDraft(draft: PathDraft): StoredPathQueryBlock;
+export declare function hasAnyPathFragment(draft: PathDraft): boolean;
+/**
+ * Strips builder-only keys and normalizes per-type fields the way the create form
+ * always has (shared by PUT /subgraph and stored-query registration). A vertex step's
+ * filter slot sends exactly what its MODE says (feature subgraph-semantic-thresholds):
+ * the fragment, the parsed threshold, or nothing — the other representation stays in the
+ * draft, so switching modes never loses input.
+ */
+export declare function normalizePatterns(patterns: SubgraphPatternDraft[]): PatternSpecification[];
+export declare function subGraphBlock(vertexFilter: string, edgeFilter: string, patterns: PatternSpecification[]): StoredSubGraphQueryBlock;
+export interface StoredFragmentRow {
+    label: string;
+    fragment: string;
+}
+export interface StoredSpecificationPreview {
+    rows: StoredFragmentRow[];
+    note: string | null;
+}
+/**
+ * Renders a stored entry's specificationJson as label/fragment rows — best-effort:
+ * the JSON is the server's own stored document, but an unparseable one degrades to a
+ * note instead of a crash.
+ */
+export declare function describeStoredSpecification(kind: string | null, specificationJson: string | null): StoredSpecificationPreview;

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

@@ -0,0 +1,34 @@
+/**
+ * The display caps, in characters, for each kind of user-controlled string — the one home
+ * for "a number of chars that makes sense". Values are never lost: the full string always
+ * rides in the title tooltip (see <Truncated>). Tune here, not per call site.
+ */
+export declare const DISPLAY_CAP: {
+    /** Names/ids: namespace, instance, index, stored-query, subgraph, algorithm, plugin. */
+    readonly name: 40;
+    /** Names inside fixed-width chrome (dropdown rows, badges, chips). */
+    readonly chipName: 28;
+    /** Property keys / edge-property ids. */
+    readonly propertyKey: 40;
+    /** Property values (a vector is pre-shrunk by previewVector first). */
+    readonly propertyValue: 80;
+    /** CLR / fully-qualified type names. */
+    readonly typeName: 36;
+    /** Vertex/edge labels. */
+    readonly label: 40;
+    /** Path- / URL-shaped values (use middle mode so the tail stays readable). */
+    readonly path: 48;
+    /** Free-form status/error lines interpolating user text. */
+    readonly message: 140;
+};
+/**
+ * Clips <paramref name="text"/> to at most <paramref name="max"/> characters (the ellipsis
+ * included in that budget). End mode (default) keeps the head — `"fraud-quarterly" → "fraud-q…"`;
+ * middle mode keeps both ends, best for paths/URLs whose tail carries meaning —
+ * `"/ns/fraud-quarterly/status" → "/ns/fr…status"`.
+ */
+export declare function truncateChars(text: string, max: number, options?: {
+    middle?: boolean;
+}): string;
+/** Whether {@link truncateChars} would actually shorten this text (i.e. a title tooltip helps). */
+export declare function isTruncated(text: string, max: number): boolean;

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

@@ -0,0 +1,7 @@
+import type { GraphREST } from "../api/types";
+/**
+ * FR-7: GET /graph?maxElements=N truncates silently (no paging, no marker). The only
+ * reliable signal is the returned element count reaching the requested cap, so whenever
+ * that happens the UI must show an explicit "truncated at N" indicator.
+ */
+export declare function isTruncated(graph: GraphREST, requestedMax: number): boolean;

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

@@ -0,0 +1,13 @@
+/**
+ * Query-vector input parsing (concept spec §6): vectors are PASTED (a JSON array or
+ * comma/whitespace-separated floats), never typed — this validates client-side so a
+ * dimension mismatch or a NaN is caught before the server's 400.
+ */
+export type ParsedVector = {
+    ok: true;
+    vector: number[];
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseVector(text: string): ParsedVector;

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

@@ -0,0 +1 @@
+export {};

package/dist-lib/types/plugin/PluginEditor.d.ts

@@ -0,0 +1,20 @@
+import type { InstanceConfig } from "../instances/types";
+/**
+ * The whole-type plugin authoring editor (feature plugin-registration §6): pick a category
+ * (+ contract for an algorithm), load a per-category scaffold into a full-file Monaco C#
+ * editor, compile-validate it debounced through POST /plugins/{category}/validate (the
+ * whole-type sibling of the delegate editor's /delegates/validate loop), then register into
+ * the addressed namespace. Registration + validate are gated: a 403 surfaces as a friendly
+ * "registration is disabled" line, exactly like the delegate editor's 401 auth-gate message.
+ *
+ * The plugin validate contract returns a plain-text `error` (not positioned diagnostics), so
+ * — unlike the delegate editor's markers.ts path — diagnostics render as text; the Monaco
+ * setup and the full-file csharp editor are the shared pieces.
+ */
+export declare const PLUGIN_NAME: RegExp;
+export declare const PLUGIN_GATE_MESSAGE = "plugin registration is disabled on this server (enable the dynamic-plugin capability to author plugins)";
+export declare function PluginEditor({ instance, onRegistered, onCancel, }: {
+    instance: InstanceConfig;
+    onRegistered: (name: string) => void;
+    onCancel: () => void;
+}): import("react").JSX.Element;

package/dist-lib/types/plugin/nl/PluginNlAssistPanel.d.ts

@@ -0,0 +1,13 @@
+import type { AlgorithmContract, PluginAuthoringCategory, PluginValidationResult } from "../../api/types";
+interface PluginNlAssistPanelProps {
+    category: PluginAuthoringCategory;
+    contract: AlgorithmContract;
+    name: string;
+    scaffold: string;
+    currentSource: string;
+    onDraft: (source: string) => void;
+    validateDraft: (source: string) => Promise<PluginValidationResult | null>;
+    drivingRef: React.MutableRefObject<boolean>;
+}
+export declare const PluginNlAssistPanel: (props: PluginNlAssistPanelProps) => import("react").ReactElement<PluginNlAssistPanelProps, string | import("react").JSXElementConstructor<any>> | null;
+export {};

package/dist-lib/types/plugin/nl/pluginPrompt.d.ts

@@ -0,0 +1,48 @@
+import type { NlPrompt } from "../../delegate/nl/prompt";
+import type { AlgorithmContract, PluginAuthoringCategory } from "../../api/types";
+/**
+ * Whole-type generation prompt assembly for plugin authoring (feature plugin-registration §6).
+ * The delegate NL path (src/delegate/nl/prompt.ts) drafts a single lambda BODY; a plugin is a
+ * whole type, so the shape rules, the per-contract member guidance, the few-shot (the scaffold
+ * itself), and the output extractor all differ. The model backend transport (generate.ts) and
+ * the backend-config store (config.ts) are shared unchanged.
+ */
+interface PluginPromptInput {
+    category: PluginAuthoringCategory;
+    contract: AlgorithmContract;
+    /** The exact registration name — must be the type's PluginName (server-validated). */
+    name: string;
+    /** The current scaffold: the shape to complete (correct usings, class, IPlugin members). */
+    scaffold: string;
+    intent: string;
+    priorDrafts?: string[];
+}
+export declare function buildPluginGenerationPrompt(input: PluginPromptInput): NlPrompt;
+/** Follow-up turn for the refine loop: the failed source + the compiler/contract diagnostics. */
+export declare function buildPluginRefinePrompt(input: {
+    category: PluginAuthoringCategory;
+    contract: AlgorithmContract;
+    name: string;
+    source: string;
+    error: string;
+}): string;
+/**
+ * Output handling for a whole type: prefer a fenced ```csharp block; otherwise strip any leading
+ * prose before the first C# construct. Unlike the fragment extractor it does NOT truncate at the
+ * first ";" — a plugin is a whole file, not a single statement.
+ */
+export declare function extractType(raw: string): string;
+/**
+ * Guarantees a model draft carries the usings its contract needs, whatever the model dropped
+ * (feature plugin-registration §6). The whole-type plugin surface is the ONLY NL path where the
+ * model authors its own using directives (the delegate/fragment path emits a bare lambda body and
+ * the server harness supplies the usings), and a small model routinely regenerates the scaffold
+ * minus one line, most damagingly `NoSQL.GraphDB.Core.Plugins`, which holds IGraphFunction and
+ * GraphFunctionResult, so the type "could not be found". This unions the scaffold's known-required
+ * usings into the draft (adding usings never breaks the compile: the scaffold's own set compiles,
+ * so a subset re-added to a draft cannot introduce an ambiguity the scaffold does not already
+ * have), and adds System.Linq when the body calls a LINQ operator without it. It repairs only the
+ * import lines; genuine body mistakes still surface through the compile-and-refine loop.
+ */
+export declare function ensureRequiredUsings(draft: string, scaffold: string): string;
+export {};

package/dist-lib/types/plugin/scaffolds.d.ts

@@ -0,0 +1,26 @@
+import type { AlgorithmContract, PluginAuthoringCategory } from "../api/types";
+/**
+ * Per-category/-contract authoring scaffolds (feature plugin-registration §6): the starter
+ * WHOLE type — correct usings, the contract interface, the IPlugin members and the contract
+ * method stubbed — so the author fills in the body, not the boilerplate. This is the
+ * whole-type analogue of the delegate editor's opening snippet (src/delegate/kinds.ts).
+ *
+ * The scaffold's PluginName string is the exact registration name (the server validates
+ * equality); the C# class identifier is a sanitized form, since a plugin name may contain a
+ * dash while a C# identifier may not. Algorithm contract methods are stubbed with
+ * NotImplementedException (they compile and satisfy the one-implementor contract, so the
+ * skeleton validates immediately); the function scaffold ships a working label scan.
+ */
+/** The algorithm contracts a scaffold can target, and the interface each implements. */
+export declare const ALGORITHM_CONTRACTS: AlgorithmContract[];
+/** The interface the source must implement for a given category/contract (for display). */
+export declare function contractInterface(category: PluginAuthoringCategory, contract: AlgorithmContract): string;
+/** A sensible default registration name per category (also a valid C# identifier). */
+export declare const DEFAULT_PLUGIN_NAME: Record<PluginAuthoringCategory, string>;
+/** Turns a registration name into a legal C# type identifier (dash → underscore, etc.). */
+export declare function toClassIdentifier(name: string): string;
+/**
+ * The starter source for a category (+ contract for an algorithm), with the registration
+ * name interpolated as both the PluginName string and the C# class identifier.
+ */
+export declare function scaffoldFor(category: PluginAuthoringCategory, contract: AlgorithmContract, name: string): string;

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

@@ -0,0 +1,8 @@
+/**
+ * Analytics (feature studio-coverage §3/§4): understand the graph's shape, then compute
+ * over it. The Graph shape panel is the ONLY caller of GET /statistics (on demand — the
+ * pass is budgeted and rate-limited); its snapshot doubles as the schema cache feeding
+ * identifier suggestions across the Studio (gap G-3). The runner mirrors the backend's
+ * one-shot design: no history, no queueing — 429/408 are first-class outcomes.
+ */
+export declare function AnalyticsScreen(): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * Element browser (FR-5/6/7): fetch a vertex/edge/graph element by id with typed
+ * properties; one-click adjacency + degrees; bulk view with the mandatory truncation
+ * indicator; "send to canvas".
+ */
+export declare function BrowserScreen(): import("react").JSX.Element;

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

@@ -0,0 +1,10 @@
+/**
+ * Graph canvas screen (FR-18/19/20 + studio-canvas-viz + canvas-view-controls): renders the
+ * active instance's canvas store in 2D or 3D, a sectioned style panel (data-driven
+ * color/size/image/width, layouts, render toggles), a color legend, selection-driven detail
+ * panel, remove-from-view (view only!), expand-on-demand which merges a vertex's edges +
+ * neighbors, and the working-set controls: "Show whole graph" (an explicit, capped,
+ * merge-only load; the canvas still never auto-loads anything) and "Clear view" (empties
+ * the working set including the selection; style config and result sets survive).
+ */
+export declare function CanvasScreen(): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,13 @@
+/**
+ * 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;

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

@@ -0,0 +1,8 @@
+/**
+ * Indexes workspace (feature index-workspace): the top-level home for index OBJECTS —
+ * live inventory (id, type, capabilities, counts, embedding binding), create, delete
+ * behind a typed confirmation, and per-index content management over the full REST
+ * surface. Querying an index lives on the Query screen; the Query row action jumps
+ * there with the index preselected.
+ */
+export declare function IndexesScreen(): import("react").JSX.Element;

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

@@ -0,0 +1,14 @@
+/**
+ * Integrations (feature integrations): the integrations this instance's runtime ships, a settings
+ * form for the selected one, and the report of the run it submits.
+ *
+ * The form is rendered from the DESCRIPTOR alone - from each setting's kind, required flag and help
+ * text - and there is deliberately no switch on provider id anywhere in this file. A provider that
+ * 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.
+ */
+export declare function IntegrationsScreen(): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * Path finder (FR-12/13/14): BLS vs Dijkstra with the explainer, defaults pre-filled,
+ * the five delegate slots as the advanced tier (all optional, empty by default), results
+ * as ordered element lists + canvas overlay. Fragments were already validated in the
+ * 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).
+ */
+export declare function PathScreen(): import("react").JSX.Element;

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

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

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

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

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

@@ -0,0 +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
+ * 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/SaveGamesScreen.d.ts

@@ -0,0 +1,7 @@
+import type { SaveGame, SaveGameNamespace } from "../api/types";
+/**
+ * The namespaces an entry effectively contains — mirrors the server's normalization: a
+ * pre-namespace (v1) entry is a default-only save described by its top-level fields.
+ */
+export declare function effectiveNamespaces(game: SaveGame): SaveGameNamespace[];
+export declare function SaveGamesScreen(): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,63 @@
+import { type UseBoundStore, type StoreApi } from "zustand";
+import type { ChangeEvent } from "../api/changefeed";
+/**
+ * Per-namespace event-feed state (feature studio-event-feed): the newest
+ * {@link EVENT_FEED_CAPACITY} RAW change-feed events of one namespace, the bell's unread
+ * accounting, and the catch-up position (`since`). Deliberately NOT persisted: there is
+ * no history read API, so a reload starting empty is honest - replaying a stale buffer
+ * would fake a history the server does not serve. The interest FILTER, in contrast, is
+ * a lasting preference and persists in the workspace store (see feedFilter.ts).
+ *
+ * Events are stored unfiltered so a filter change is a pure view re-evaluation: instant,
+ * no network, and it can reveal already-observed events the previous filter hid.
+ */
+export declare const EVENT_FEED_CAPACITY = 100;
+export interface FeedEntry {
+    /** Stable list key: `seq` alone can repeat after an epoch change or a replay. */
+    key: number;
+    event: ChangeEvent;
+    /** Client receipt time - the timestamp fallback for events without a usable `ts`. */
+    receivedAt: number;
+}
+export interface EventFeedState {
+    /** Newest first, capped at {@link EVENT_FEED_CAPACITY}; includes resync entries. */
+    entries: FeedEntry[];
+    /** Interest-matching events observed while the panel was closed. */
+    unread: number;
+    /** A resync arrived while the panel was closed: continuity was lost unseen. */
+    resyncSinceOpen: boolean;
+    panelOpen: boolean;
+    /** Last seen SSE `id:` (`epoch:seq`) - the `since` position for a resubscribe. */
+    lastEventId: string | null;
+    /**
+     * Buffers one event. Unread accrues only while the panel is closed (visible = read):
+     * a resync raises the distinct flag instead of counting; element events count when
+     * they match the interest filter (the caller evaluates the filter - this store stays
+     * filter-agnostic).
+     */
+    record: (event: ChangeEvent, matchesInterest: boolean) => void;
+    setLastEventId: (id: string) => void;
+    /** Opening resets unread and the resync flag; closing just flips the gate back on. */
+    setPanelOpen: (open: boolean) => void;
+    /** Full reset (buffer, unread, flag, catch-up position) - the namespace was recreated. */
+    clear: () => void;
+}
+type EventFeedStore = UseBoundStore<StoreApi<EventFeedState>>;
+/** Returns the one feed belonging to this instance id + namespace (memoized). */
+export declare function getEventFeed(instanceId: string, namespace?: string): EventFeedStore;
+/**
+ * Drops a namespace's feed - called alongside instanceStore.purgeInstanceStore when the
+ * namespace is dropped or recreated in place: the buffered events describe a dead graph,
+ * and a stale `since` against its successor's feed would be meaningless.
+ */
+export declare function purgeEventFeed(instanceId: string, namespace?: string): void;
+/** Drops EVERY namespace's feed of one instance (the factory-reset blast radius). */
+export declare function purgeAllEventFeeds(instanceId: string): void;
+/**
+ * Follows a namespace rename: the graph (and its feed epoch/sequence) is unchanged, so
+ * the buffer and the catch-up position stay valid under the new address.
+ */
+export declare function migrateEventFeed(instanceId: string, from: string, to: string): void;
+/** Test hook: drop all memoized feeds. */
+export declare function resetEventFeedsForTests(): void;
+export {};

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

@@ -0,0 +1,42 @@
+import type { ChangeElementType, ChangeEvent, ChangeFeedFilter } from "../api/changefeed";
+/**
+ * The Events panel's interest filter (feature studio-event-feed): the configuration
+ * vocabulary IS the REST filter grammar - same dimensions, same semantics - applied
+ * client-side over the raw event buffer (the panel rides the one shared stream, it
+ * never opens a second filtered subscription). Pinned to server parity by tests:
+ * AND across dimensions, OR within one, exact case-sensitive matches, an unlabeled
+ * element never matches a `labels` filter, and only property events carry a key (so a
+ * `keys` filter hides creates/removes). `resync` is exempt - always shown, mirroring
+ * "resync is always delivered".
+ *
+ * The draft persists per instance + namespace inside the workspace store
+ * (instanceStore.ts) - a lasting preference, unlike the session-only event buffer.
+ */
+export declare const ELEMENT_EVENT_KINDS: readonly ["vertexCreated", "vertexRemoved", "edgeCreated", "edgeRemoved", "propertySet", "propertyRemoved"];
+export type ElementEventKind = (typeof ELEMENT_EVENT_KINDS)[number];
+export declare const ELEMENT_TYPES: readonly ["vertex", "edge"];
+/**
+ * Checkbox semantics: `kinds`/`elements` hold the ENABLED values (all enabled = the
+ * wildcard); `labels`/`keys` hold exact values (empty = the wildcard). An empty
+ * `kinds`/`elements` selection matches nothing - expressible here, not over REST
+ * (see {@link toChangeFeedFilter}).
+ */
+export interface FeedFilterDraft {
+    kinds: ElementEventKind[];
+    elements: ChangeElementType[];
+    labels: string[];
+    keys: string[];
+}
+export declare const DEFAULT_FEED_FILTER: FeedFilterDraft;
+/** Server-parity event matching; see the module doc for the pinned semantics. */
+export declare function matchesFilter(event: ChangeEvent, filter: FeedFilterDraft): boolean;
+/**
+ * Whether the draft is expressible as a `GET /changefeed` query: the REST grammar has
+ * wildcards but no "match nothing", so an empty kinds/elements selection is not.
+ */
+export declare function isExpressibleAsRest(filter: FeedFilterDraft): boolean;
+/**
+ * The draft as the wire filter, wildcard dimensions omitted and kinds/elements in
+ * canonical order - feed it to buildChangeFeedQuery for the copy-as-REST string.
+ */
+export declare function toChangeFeedFilter(filter: FeedFilterDraft): ChangeFeedFilter;