@fallen-8/studio 0.0.32

package/dist-lib/types/canvas/eclipse.d.ts

@@ -0,0 +1,136 @@
+/** Node radius (px) floor so a small or distant node still shows a visible corona. */
+export declare const ECLIPSE_MIN_RADIUS = 9;
+/** Clamp a raw on-screen node radius (px) up to the visible floor. */
+export declare function eclipseRadius(rawRadius: number): number;
+/**
+ * 3d-force-graph's default `nodeRelSize`: the world-space radius it renders per unit of
+ * `cbrt(val)`. Named because it is the anchor of every px-to-world conversion on the 3D canvas,
+ * and a second copy of it would silently decouple the sphere from the sprite drawn over it.
+ */
+export declare const NODE_REL_SIZE = 4;
+/**
+ * World-space sphere radius for a node value: `cbrt(val) * NODE_REL_SIZE`, collapsing a
+ * non-positive value to 0.
+ *
+ * That floor is where this DIVERGES from the library on purpose. three-forcegraph reads a falsy
+ * `nodeVal` as 1 (`valAccessor(node) || 1`), so it would report the DEFAULT radius for val 0 and
+ * a negative radius for val below 0 - it is not even self-consistent, clamping with
+ * `Math.max(0, val || 1)` on its arrow path but not on its sphere path. Sizing the hover corona
+ * off a value the scene cannot honour is worse than sizing it off 0. Unreachable in practice:
+ * resolveMagnitudes rejects a non-positive configured magnitude, so a resolved size is always
+ * positive; this stays a floor, not a live divergence.
+ */
+export declare function worldRadiusForVal(val: number): number;
+/**
+ * Screen-space radius (px) of a sphere of world radius `worldRadius`, seen at camera `distance`
+ * through a perspective camera of vertical field of view `fovDeg`, in a viewport `viewportHeight`
+ * px tall. Closer or larger spheres project bigger; a non-positive distance (camera on the node)
+ * yields 0 rather than a divide-by-zero.
+ */
+export declare function perspectiveScreenRadius(distance: number, worldRadius: number, fovDeg: number, viewportHeight: number): number;
+/**
+ * A 2D node radius in px as a 3d-force-graph node value. `nodeVal` is proportional to sphere
+ * VOLUME, so cubing the ratio is what keeps a 3D radius proportional to its 2D counterpart:
+ * substituting into `worldRadiusForVal` gives `size * NODE_REL_SIZE / NODE_SIZE_DEFAULT`, making
+ * the divisor the constant of proportionality between world units and pixels (0.8 today).
+ *
+ * The divisor is therefore the DEFAULT node size, never the configured `nodeSize`. Dividing by the
+ * configured value would normalise the host's knob away: `nodeSize: 20` would render in 3D exactly
+ * like the default while 2D grew fourfold, which is the opposite of keeping the renderers coupled.
+ */
+export declare function sizeToVal(size: number): number;
+/**
+ * Sprite edge length per px of 2D radius: an image node's sprite spans the DIAMETER of the sphere
+ * it replaces. Derived from the same anchor as `sizeToVal` so the two cannot drift, and exactly
+ * the 1.6 this was written as before (`(2 * 4) / 5` is the same double as the literal).
+ */
+export declare const SPRITE_SCALE_PER_PX: number;
+/** three.js PerspectiveCamera's default vertical field of view, in degrees. */
+export declare const DEFAULT_FOV = 50;
+/**
+ * Default fit inset in px: what the 3D mount auto-fit has always used, and the frame
+ * `getCameraRatio` measures against until a fit picks another.
+ */
+export declare const FIT_PADDING_PX = 60;
+/**
+ * SIGMA. The camera ratio that frames the whole graph with `paddingPx` of viewport margin.
+ *
+ * Under `autoRescale` sigma projects the normalised graph through `min(w, h) - 2 * stagePadding` px
+ * and then divides by the camera ratio (`matrixFromCamera`), so the quotient of those two spans is
+ * the zoom that turns one framing into the other. Asking for the padding already in effect returns
+ * exactly 1, which is what a camera reset does, so the default path is a plain reset.
+ *
+ * Padding is expressed as a ZOOM rather than by writing sigma's `stagePadding` setting, and the two
+ * are not interchangeable: `stagePadding` reframes without touching element sizes, whereas a camera
+ * ratio also divides every node radius and edge width by `sqrt(ratio)` (`scaleSize`). Zooming is the
+ * honest reading of "leave more margin" - a user's wheel-zoom does exactly the same - and it stays
+ * transient camera state rather than mutating a persistent setting and forcing a re-index. Label
+ * text does NOT shrink with it (`labelSize` is used verbatim), so a fit with a large inset makes
+ * labels relatively larger. A host that wants margin WITHOUT a zoom should size its own container.
+ *
+ * One consequence to know: far enough out, sigma's `minEdgeThickness` floor (Canvas2D sets it)
+ * catches ordinary and path-overlay edges alike, so the path's extra WIDTH stops reading. Its colour
+ * and its node sizes still do, which is why the overlay stays legible rather than invisible.
+ *
+ * Padding is clamped because it is a divisor sigma never validates: at 390x100 an unclamped 60 px
+ * request yields a NEGATIVE ratio, which renders the graph mirrored. The clamp never bites the stage
+ * padding itself, so the omitted-argument case is still exactly 1.
+ */
+export declare function fitCameraRatio(viewport: {
+    width: number;
+    height: number;
+}, stagePadding: number, paddingPx: number | undefined): number;
+/**
+ * 3D-FORCE-GRAPH. Camera distance FROM THE WORLD ORIGIN at which the whole node cloud just fits a
+ * `viewportWidth` x `viewportHeight` frame inset by `paddingPx`, seen through a perspective camera
+ * of vertical field of view `fovDeg`. This is the distance `zoomToFit` parks at, so dividing the
+ * live camera distance by it gives a ratio that is 1 exactly when the graph fits.
+ *
+ * Reproduced from three-render-objects' `fitToBbox`, including three things a from-scratch
+ * derivation would get "right" and thereby wrong:
+ * - the extent is measured from the ORIGIN, not the cloud's centroid, so an off-centre graph pulls
+ *   the camera further back (the library re-aims at the origin when it fits),
+ * - the divisor is `atan(paddedFov)` rather than the correct `2 * tan(paddedFov / 2)`, which is why
+ *   this disagrees with `perspectiveScreenRadius` above: that one must match what WebGL projects,
+ *   this one must match where the library moves,
+ * - a node contributes its rendered radius, links and arrowheads nothing outside that hull.
+ *
+ * Returns 0 for "no fit is defined": no placed node, zero extent, a zero-size viewport, or a
+ * padding eating at least half the height, which is where `fitToBbox` itself goes to Infinity.
+ */
+export declare function graphFitDistance(nodes: Iterable<{
+    val: number;
+    x?: number;
+    y?: number;
+    z?: number;
+}>, fovDeg: number, viewportWidth: number, viewportHeight: number, paddingPx: number): number;
+/**
+ * `position` moved to sit `distance` from the origin along the same direction: the move a fit
+ * makes, at a chosen distance. A camera exactly on the origin has no direction to preserve and
+ * goes to +z, where the library's own initial camera sits.
+ */
+export declare function scaleCameraDistance(position: {
+    x: number;
+    y: number;
+    z: number;
+}, distance: number): {
+    x: number;
+    y: number;
+    z: number;
+};
+/**
+ * A host-supplied fit inset brought inside what the 3D renderer can honour. Padding is a divisor
+ * there too, and the library does NOT guard it: `paddedFov = (1 - 2 * padding / height) * fov`, so
+ * a padding of exactly half the height sends the fit distance to Infinity and more than half sends
+ * it NEGATIVE, and `fitToBbox` only rejects a distance below zero - it parks the camera at Infinity
+ * quite happily. The 0.4 ceiling matches the 2D clamp and leaves a fifth of the field of view.
+ */
+export declare function clampFitPadding(paddingPx: number, viewportHeight: number): number;
+/** A fit tween length: non-finite or negative means the default, and `floorMs` is the renderer's
+ *  own lower bound (sigma divides by the duration, so it cannot take 0; three.js treats 0 as
+ *  "immediately", which is what a resize-driven fit wants). */
+export declare function fitDurationMs(durationMs: number | undefined, fallback: number, floorMs: number): number;
+/** A camera ratio a host may set: 1 fits, larger is further out. Zero, negative and NaN all blank
+ *  the canvas irrecoverably (they divide element sizes and the projection), so they are refused
+ *  rather than clamped - silently substituting a number would hide the caller's bug. */
+export declare function isUsableCameraRatio(ratio: number): boolean;

package/dist-lib/types/canvas/imageAssets.d.ts

@@ -0,0 +1,3 @@
+import type { ImageSpec } from "./styleEngine";
+/** Resolves an ImageSpec to something an <img>/texture loader can consume. */
+export declare function imageUrlFor(spec: ImageSpec): string;

package/dist-lib/types/canvas/styleConfig.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Canvas style configuration (feature studio-canvas-viz): what the style panel edits,
+ * what the store persists per instance, and what the style engine resolves against.
+ * Defaults reproduce the pre-feature rendering exactly (spec FR-8).
+ */
+export type CanvasRenderer = "2d" | "3d";
+export type Layout2d = "force" | "circular" | "circlepack" | "grid" | "random";
+export type Layout3d = "force" | "dag-td" | "dag-radial";
+/** How a color is chosen: stable label hash (default) or a user-named property. */
+export type ColorMode = "label" | "property";
+/** Node size source; degree modes count edges visible on the canvas (spec: Decisions). */
+export type NodeSizeMode = "fixed" | "property" | "in-degree" | "out-degree" | "degree";
+export type EdgeWidthMode = "fixed" | "property";
+export interface StyleConfig {
+    renderer: CanvasRenderer;
+    layout2d: Layout2d;
+    layout3d: Layout3d;
+    nodeColorMode: ColorMode;
+    nodeColorProperty: string;
+    nodeSizeMode: NodeSizeMode;
+    nodeSizeProperty: string;
+    /** Property whose value renders as the node: http(s)/data URL or emoji/text (FR-5). */
+    nodeImageProperty: string;
+    edgeColorMode: ColorMode;
+    edgeColorProperty: string;
+    edgeWidthMode: EdgeWidthMode;
+    edgeWidthProperty: string;
+    showNodeLabels: boolean;
+    showEdgeLabels: boolean;
+    edgeArrows: boolean;
+    /**
+     * Node radius in px for `nodeSizeMode: "fixed"`. Also the fallback the scaled modes use for
+     * a node they cannot measure (no such property, or a non-numeric value).
+     * Default: `NODE_SIZE_DEFAULT`.
+     */
+    nodeSize?: number;
+    /** `[min, max]` node radius in px for the scaled modes. Default: `NODE_SIZE_RANGE`. */
+    nodeSizeRange?: readonly [number, number];
+    /** Edge width in px for `edgeWidthMode: "fixed"`, and the unmeasurable-edge fallback. Default: `EDGE_WIDTH_DEFAULT`. */
+    edgeWidth?: number;
+    /** `[min, max]` edge width in px for the scaled mode. Default: `EDGE_WIDTH_RANGE`. */
+    edgeWidthRange?: readonly [number, number];
+    /** Node label px. Default: `LABEL_SIZE_DEFAULT`. */
+    labelSize?: number;
+    /** Edge label px. Default: `EDGE_LABEL_SIZE_DEFAULT`. */
+    edgeLabelSize?: number;
+}
+export declare const DEFAULT_STYLE_CONFIG: StyleConfig;

package/dist-lib/types/canvas/styleEngine.d.ts

@@ -0,0 +1,125 @@
+import { type CanvasEdge, type CanvasNode } from "../state/instanceStore";
+import type { ColorMode, StyleConfig } from "./styleConfig";
+/**
+ * Pure style resolution (studio-canvas-viz, spec "Decisions"): maps the canvas model +
+ * style config + path overlay to per-element visuals. This is the ONE home for the
+ * styling rules — the 2D and 3D renderers only consume what is resolved here.
+ */
+export interface PathOverlaySets {
+    nodeIds: Set<number>;
+    edgeIds: Set<number>;
+    active: boolean;
+    /** true: non-members grey out (path overlay); false: members pop, the rest keeps its colors (adjacency-preview emphasis). */
+    dim: boolean;
+}
+export declare const EMPTY_OVERLAY: PathOverlaySets;
+/** What a node image property value turned out to be (FR-5). */
+export interface ImageSpec {
+    kind: "url" | "emoji";
+    value: string;
+}
+export interface ResolvedNodeStyle {
+    color: string;
+    size: number;
+    image: ImageSpec | null;
+    zIndex: number;
+    dimmed: boolean;
+}
+export interface ResolvedEdgeStyle {
+    color: string;
+    width: number;
+    zIndex: number;
+    dimmed: boolean;
+}
+export interface ResolvedStyles {
+    nodes: Record<number, ResolvedNodeStyle>;
+    edges: Record<number, ResolvedEdgeStyle>;
+    /** What the renderers draw with, defaulted once (see resolveMagnitudes). */
+    magnitudes: ResolvedMagnitudes;
+}
+export declare const NODE_SIZE_DEFAULT = 5;
+export declare const NODE_SIZE_RANGE: readonly [number, number];
+export declare const EDGE_WIDTH_DEFAULT = 1;
+export declare const EDGE_WIDTH_RANGE: readonly [number, number];
+export declare const LABEL_SIZE_DEFAULT = 11;
+export declare const EDGE_LABEL_SIZE_DEFAULT = 9;
+export declare const PATH_NODE_MIN_SIZE = 8;
+export declare const PATH_EDGE_MIN_WIDTH = 3;
+export declare const PATH_EDGE_COLOR = "#4cc38a";
+export declare const DIM_NODE_COLOR = "#2a3240";
+export declare const DIM_EDGE_COLOR = "#1a2029";
+export declare const UNLABELED_EDGE_COLOR = "#2c3543";
+type StyledElement = {
+    label: string | null;
+    props?: Record<string, string | number | boolean>;
+};
+/** Numeric magnitude of a property value; booleans are categories, never magnitudes. */
+export declare function numericValue(value: unknown): number | null;
+/** FR-5: http(s)/data URLs load as images; any other scalar rasterizes as emoji/text. */
+export declare function classifyImageValue(value: unknown): ImageSpec | null;
+/** How a color mode + property resolve over a concrete element set (FR-1/FR-2, FR-10). */
+export type ColorScale = {
+    kind: "label";
+} | {
+    kind: "categorical";
+    property: string;
+} | {
+    kind: "gradient";
+    property: string;
+    min: number;
+    max: number;
+};
+export declare function buildColorScale(elements: StyledElement[], mode: ColorMode, property: string): ColorScale;
+/**
+ * The magnitudes a renderer actually draws with: each optional StyleConfig magnitude resolved
+ * against its documented default. This is the ONE home for that defaulting, so no renderer and
+ * no call site repeats a fallback expression.
+ */
+export interface ResolvedMagnitudes {
+    nodeSize: number;
+    nodeSizeRange: readonly [number, number];
+    /** What a scaled mode draws for a node it cannot measure (see fallbackWithin). */
+    nodeSizeFallback: number;
+    edgeWidth: number;
+    edgeWidthRange: readonly [number, number];
+    edgeWidthFallback: number;
+    labelSize: number;
+    edgeLabelSize: number;
+}
+/**
+ * The one rule for "a positive magnitude a host supplied": a finite number above zero. Exported
+ * because the camera handle applies it to a zoom ratio for the same reason, namely that hosts call
+ * in from plain JavaScript where `undefined`, `null` and NaN all arrive without a type error, and
+ * every one of these numbers ends up a divisor in a renderer that does not validate it.
+ *
+ * Zero and negatives are refused rather than honoured: they render nothing, and a host that reaches
+ * this state has a bug (a slider at its minimum, an unparsed input) that a blank canvas would hide.
+ */
+export declare function isUsableMagnitude(value: number | undefined): value is number;
+export declare function resolveMagnitudes(config: StyleConfig): ResolvedMagnitudes;
+/** Visible in/out degree per node id (spec "Decisions": the canvas is the working set). */
+export declare function visibleDegrees(edges: CanvasEdge[]): Map<number, {
+    in: number;
+    out: number;
+}>;
+export declare function resolveStyles(nodes: Record<number, CanvasNode>, edges: Record<number, CanvasEdge>, overlay: PathOverlaySets, config: StyleConfig): ResolvedStyles;
+/** Legend model for the canvas screen (FR-10): follows the node color mode. */
+export type LegendModel = {
+    kind: "categorical";
+    title: string;
+    entries: {
+        key: string;
+        color: string;
+        count: number;
+    }[];
+} | {
+    kind: "gradient";
+    title: string;
+    min: number;
+    max: number;
+};
+export declare const LEGEND_MAX_ENTRIES = 12;
+export declare function buildLegend(nodes: Record<number, CanvasNode>, config: StyleConfig): LegendModel;
+/** Sorted union of snapshot property keys — feeds the style panel datalists (FR-8). */
+export declare function knownPropertyKeys(elements: StyledElement[]): string[];
+export {};

package/dist-lib/types/canvas/styling.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Stable label-to-color assignment (FR-19): a label always hashes to the same palette
+ * slot, in any instance and any session. Palette tuned for the dark chrome.
+ */
+export declare const LABEL_PALETTE: readonly ["#4cc38a", "#58a6ff", "#d29922", "#f778ba", "#a371f7", "#ff7b72", "#39c5cf", "#9e6a03", "#7ee787", "#79c0ff"];
+export declare const UNLABELED_COLOR = "#55647a";
+export declare function colorForLabel(label: string | null | undefined): string;
+/** Property values color like labels: stringified, then stably hashed (FR-1/FR-2). */
+export declare function colorForValue(value: unknown): string;
+/** Two-color ramp for all-numeric properties (FR-1): min → cyan, max → pink. */
+export declare const GRADIENT_LOW = "#39c5cf";
+export declare const GRADIENT_HIGH = "#f778ba";
+export declare function gradientColor(t: number): string;
+/** FR-20: past this rendered-element count the canvas degrades (drops labels) instead of freezing. */
+export declare const DEGRADE_THRESHOLD = 5000;

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

@@ -0,0 +1,11 @@
+import type { EdgeREST, VertexREST } from "../api/types";
+/**
+ * Right-column adjacency panel (feature adjacency-preview). A vertex offers graph|stats;
+ * an edge always renders the neighborhood preview (endpoints + parallel bundle). One
+ * component for both kinds so the preview instance survives vertex↔edge hops instead of
+ * remounting (which would flicker).
+ */
+export declare function AdjacencyPanel({ element, onInspect, }: {
+    element: VertexREST | EdgeREST;
+    onInspect: (id: number) => void;
+}): import("react").JSX.Element;

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

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

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

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

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

@@ -0,0 +1,18 @@
+import { type ReactNode } from "react";
+/**
+ * Typed confirmation for destructive actions (FR-1d, FR-3): the dialog names the target
+ * instance AND its endpoint, and the user must type the instance name to arm the action.
+ * Optional `extra` content renders above the typed-name field (e.g. a "delete files too"
+ * checkbox).
+ */
+export declare function ConfirmDialog({ open, title, description, instanceName, endpoint, confirmLabel, onConfirm, onCancel, extra, }: {
+    open: boolean;
+    title: string;
+    description: string;
+    instanceName: string;
+    endpoint: string;
+    confirmLabel: string;
+    onConfirm: () => void;
+    onCancel: () => void;
+    extra?: ReactNode;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,18 @@
+import type { DurabilityREST } from "../api/types";
+/**
+ * The durability signal, for a human (feature platform-integrity-audit W5).
+ *
+ * The engine has published this on /status for a while and a machine already acts on it - the
+ * integrations runtime refuses to delete anything while it is unhealthy - but nothing showed it to
+ * the person watching. That was the gap: "a client writes into a degraded log and nobody watching a
+ * dashboard finds out" was the failure this signal existed to prevent, and it stopped one hop short.
+ *
+ * Deliberately SILENT when everything is fine. A dashboard that always carries a green durability
+ * badge trains people to stop reading it, and the three states worth interrupting for are all
+ * exceptional: the log is degraded (commits are landing in memory only), the last recovery was
+ * truncated (the graph is a prefix of history, so anything reconciling against it is reasoning from
+ * incomplete data), or the last checkpoint dropped indexes (they are gone after the next load).
+ */
+export declare function DurabilityNotice({ durability }: {
+    durability: DurabilityREST | null | undefined;
+}): import("react").JSX.Element | null;

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

@@ -0,0 +1,11 @@
+import type { EdgeREST, VertexREST } from "../api/types";
+export declare function ElementDetail({ element, providerEnabled, onRefresh, onInspect, tab, onTabChange, }: {
+    element: VertexREST | EdgeREST;
+    providerEnabled: boolean | null;
+    onRefresh: () => void;
+    onInspect: (id: number) => void;
+    /** Owned by the screen so the chosen tab survives the unmount a missing-element
+     *  lookup causes (hops and refreshes keep this panel mounted since adjacency-preview). */
+    tab: "properties" | "embeddings";
+    onTabChange: (tab: "properties" | "embeddings") => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,19 @@
+import type { EdgeREST, VertexREST } from "../api/types";
+/**
+ * Hydrated element list as a table (FR-11 "open as table"). `scores` adds the optional
+ * score column shared by the vector scan and analytics top-K (concept spec §9);
+ * `scoreHeader` names the metric so an L2 distance is never misread as a similarity.
+ */
+export declare function ElementTable({ elements, onInspect, onAddToCanvas, scores, scoreHeader, }: {
+    elements: (VertexREST | EdgeREST)[];
+    onInspect?: (id: number) => void;
+    /**
+     * Optional per-row "add just this element to the canvas" action (feature: per-row canvas add).
+     * When provided, a trailing action column renders one button per row; the caller maps the
+     * element to the canvas merge (a lone edge brings its endpoints in as placeholder nodes). Callers
+     * that do not pass it (Browser, Analytics) render no extra column - the addition is opt-in.
+     */
+    onAddToCanvas?: (element: VertexREST | EdgeREST) => void;
+    scores?: Map<number, number>;
+    scoreHeader?: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,15 @@
+import type { EdgeREST, VertexREST } from "../api/types";
+import type { InstanceConfig } from "../instances/types";
+/**
+ * Named-embedding management for one element (feature element-embeddings): lists the
+ * element's embeddings (folded out of the plain property table), and sets/replaces/removes
+ * one via the typed endpoints. Bring-your-own-vector (paste) is always available; text-in
+ * needs the embedding provider. onRefresh re-fetches the element so the list reflects the
+ * write. Server 400/404/409 reasons render verbatim.
+ */
+export declare function EmbeddingsTab({ instance, element, providerEnabled, onRefresh, }: {
+    instance: InstanceConfig;
+    element: VertexREST | EdgeREST;
+    providerEnabled: boolean | null;
+    onRefresh: () => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+export declare function ErrorBox({ error, onRetry }: {
+    error: unknown;
+    onRetry?: () => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,16 @@
+import type { LiveFeedStatus } from "../state/liveFeed";
+/**
+ * The Events bell (feature studio-event-feed): the top-bar presence of the change feed.
+ * Signals without being clicked - an interest-filtered unread count (display capped at
+ * 99+), and a distinct warning treatment when a resync arrived unseen (continuity was
+ * lost, which deserves more than a +1). Muted but clickable while the stream is not
+ * live: the panel then explains the state instead of a dead-looking list.
+ */
+/** Unread numbers above this render as "99+" (the counter itself is uncapped). */
+export declare const FEED_BADGE_MAX = 99;
+export declare function EventFeedBell({ scopeId, status, onOpen, }: {
+    /** The bound instance id ("<id>/<namespace>") naming the feed scope. */
+    scopeId: string;
+    status: LiveFeedStatus;
+    onOpen: () => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,10 @@
+import type { InstanceConfig } from "../instances/types";
+import type { LiveFeedStatus } from "../state/liveFeed";
+export declare function EventFeedPanel({ instance, status, open, onClose, onInspect, }: {
+    /** The namespace-BOUND instance view (compound id) the feed streams for. */
+    instance: InstanceConfig;
+    status: LiveFeedStatus;
+    open: boolean;
+    onClose: () => void;
+    onInspect: (id: number) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+import { type FieldHelpKey } from "../lib/fieldHelp";
+/**
+ * Labeled field with hover help (feature studio-mutations-ux): the title sits on the
+ * WRAPPER, so hovering the label or the input itself shows the explanation. Help copy
+ * lives only in lib/fieldHelp.ts; call sites pass a key, never text.
+ */
+export declare function Field({ helpKey, label, htmlFor, className, children, }: {
+    helpKey: FieldHelpKey;
+    label: ReactNode;
+    htmlFor?: string;
+    className?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;

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

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

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

@@ -0,0 +1,5 @@
+/** Clickable element-id chip. Navigation is owned by the Browser screen via onInspect. */
+export declare function InspectLink({ id, onInspect, }: {
+    id: number;
+    onInspect: (id: number) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,10 @@
+/**
+ * Honest footer for the hard row ceiling: renders "showing N of M" ONLY when a list is actually
+ * truncated at LIST_MAX_ROWS (see capList in lib/listCaps.ts) — a rare safety cap, never the
+ * everyday scroll threshold — so a list that big never hides the overflow silently. Nothing
+ * renders when everything fits (the normal case: the list just scrolls).
+ */
+export declare function ListCapNote({ shown, total }: {
+    shown: number;
+    total: number;
+}): import("react").JSX.Element | null;

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

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

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

@@ -0,0 +1,22 @@
+import type { InstanceConfig } from "../instances/types";
+import type { NamespaceEntry } from "../api/types";
+/**
+ * The top-bar namespace switcher (feature graph-namespaces, per the approved mock): a
+ * trigger showing the active namespace with its counts, and a dropdown with a filter,
+ * per-namespace rows (state dot, counts, active / bare-URL-alias / not-ready / not-loaded
+ * tags), an
+ * inline "+ New namespace" create that switches to the newborn, a "Manage…" jump to the
+ * Connect panel, and the quota footer. Full CRUD stays on the Connect screen.
+ *
+ * This component renders in the app shell on EVERY screen, so it must survive any entry the
+ * inventory can contain: a namespace the server did not load carries null counts, and throwing
+ * on one of them would take the whole Studio down with the error boundary - including the
+ * Namespaces panel an operator would use to undo the exclusion. Hence `formatCountOrDash`.
+ */
+export declare function NamespaceSwitcher({ instance, entries, maxNamespaces, activeNamespace, onSwitch, }: {
+    instance: InstanceConfig;
+    entries: NamespaceEntry[];
+    maxNamespaces: number | null;
+    activeNamespace: string;
+    onSwitch: (name: string) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,11 @@
+/**
+ * The "inherit" label, resolved against what the instance would actually do (feature
+ * writable-instance-config 5.9). A bare "inherit" left an operator unable to tell whether it meant
+ * load or skip, which is the whole question the row is asked.
+ *
+ * The two fields are published UNCOMPOSED on purpose, and both matter here: a startup mode of "all"
+ * or "defaultOnly" SHORT-CIRCUITS every per-namespace preference, so under those modes the default is
+ * not what inherit resolves to and saying otherwise would be a confident lie.
+ */
+export declare function inheritLabel(loadOnStartupDefault: boolean | undefined, startupLoadMode: string | undefined): string;
+export declare function NamespacesPanel(): import("react").JSX.Element | null;

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

@@ -0,0 +1,10 @@
+import type { EdgeREST, VertexREST } from "../api/types";
+/**
+ * Rendered 1-hop neighborhood (feature adjacency-preview): a vertex with its adjacent
+ * edges + neighbors, or an edge between its endpoints with every parallel edge — the
+ * focus element emphasized, clicks navigating via onInspect.
+ */
+export declare function NeighborhoodPreview({ element, onInspect, }: {
+    element: VertexREST | EdgeREST;
+    onInspect: (id: number) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,9 @@
+/**
+ * Plugins screen · registry table (feature plugin-registration): the registry's ONE
+ * management home — list (name, category, contract, compileState badge), read-only source +
+ * recompile diagnostics for a selected/Failed entry, a function runner for a registered
+ * graph function, and delete (immutable entries: delete + re-register is the edit flow). The
+ * whole-type authoring flow lives in the "Register plugin" editor, the sibling of the
+ * stored-query library's inline capture — see StoredQueriesPanel for the shape this mirrors.
+ */
+export declare function PluginsPanel(): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+import type { PropertyREST } from "../api/types";
+export declare function PropertiesTab({ properties }: {
+    properties: PropertyREST[];
+}): import("react").JSX.Element;

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

@@ -0,0 +1,26 @@
+import type { PropertySpecification } from "../api/types";
+import { type TypedValue } from "../lib/literals";
+/**
+ * 0..n initial properties for the create-vertex/edge forms (feature
+ * studio-mutations-ux): rows of property id + typed value, validated as a set so the
+ * submit button can gate on propertyRowsError().
+ */
+export interface PropertyRow {
+    /** Stable per-row React key, minted by newPropertyRow(). */
+    key: number;
+    propertyId: string;
+    value: TypedValue;
+}
+export declare const newPropertyRow: () => PropertyRow;
+/**
+ * Why duplicates are rejected client-side: the wire format is a list, but the server
+ * builds a one-value-per-key property dictionary from it and rejects a duplicate id
+ * before the transaction is even enqueued — with a much murkier error than this one.
+ */
+export declare function propertyRowsError(rows: PropertyRow[]): string | null;
+export declare const toPropertySpecs: (rows: PropertyRow[]) => PropertySpecification[] | undefined;
+export declare function PropertyListEditor({ rows, onChange, idPrefix, }: {
+    rows: PropertyRow[];
+    onChange: (rows: PropertyRow[]) => void;
+    idPrefix: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,3 @@
+export declare function SampleGraphsPanel(): import("react").JSX.Element;
+/** Accepts "owner/repo" or a full/bare GitHub URL; returns "owner/repo" or null. */
+export declare function normalizeRepo(input: string): string | null;

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

@@ -0,0 +1,11 @@
+/**
+ * Per-section "How does this work?" help (feature studio-section-help). Rendered ONCE by the
+ * shell, keyed by the active nav leaf; it drops an anchored popover listing the 1-3 docs pages
+ * that explain the current section (each opens the published docs site in a new tab). Renders
+ * nothing for a leaf with no mapping in sectionHelp.ts. Mirrors the hand-rolled anchored
+ * dropdown pattern from NamespaceSwitcher (open-gated mousedown/keydown listeners), with
+ * focus returned to the trigger on close.
+ */
+export declare function SectionHelp({ sectionKey }: {
+    sectionKey: string | null;
+}): import("react").JSX.Element | null;