@fallen-8/studio 0.0.32

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

@@ -0,0 +1,29 @@
+import { type SemanticDraft } from "../lib/semantic";
+/**
+ * The Path screen's declarative semantic block (feature element-embeddings): the shared
+ * query core (SemanticQueryEditor) plus the block-local minScore filter and
+ * costBySimilarity cost. Pure data — it compiles no C#, so it expresses similarity
+ * filtering without writing a fragment. The Subgraph screen does not use this block: there
+ * the thresholds live on the vertex-filter slots themselves (feature
+ * subgraph-semantic-thresholds).
+ * Full rules: features/done/element-embeddings README.
+ *
+ * Controlled: the parent owns the SemanticDraft and derives which delegate slots to
+ * disable from semanticOwnsVertex{Filter,Cost}.
+ */
+export declare function SemanticBlockEditor({ draft, onChange, allowCost, costDisabledReason, providerEnabled, embeddingNames, idPrefix, disabled, disabledReason, }: {
+    draft: SemanticDraft;
+    onChange: (patch: Partial<SemanticDraft>) => void;
+    /** costBySimilarity is a path concept; false disables the cost slot entirely. */
+    allowCost: boolean;
+    /** When set (e.g. algorithm is BLS, which ignores costs), the cost checkbox is disabled
+     *  with this reason — distinct from the internal DotProduct rule. */
+    costDisabledReason?: string;
+    /** Resolved provider state; null = unknown (no graph shape computed yet). */
+    providerEnabled: boolean | null;
+    embeddingNames: string[];
+    idPrefix: string;
+    /** e.g. a stored template is selected — the block cannot apply. */
+    disabled?: boolean;
+    disabledReason?: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,15 @@
+import type { SemanticQueryDraft } from "../lib/semantic";
+/**
+ * The semantic QUERY fields (source, vector/text, embedding name, metric) — the one query
+ * every semantic decision of a request scores against. Extracted so the Path screen's
+ * block editor and the Subgraph screen's per-request query section render exactly one
+ * implementation. Pure data — it compiles no C#.
+ */
+export declare function SemanticQueryEditor({ query, onChange, providerEnabled, embeddingNames, idPrefix, }: {
+    query: SemanticQueryDraft;
+    onChange: (patch: Partial<SemanticQueryDraft>) => void;
+    /** Resolved provider state; null = unknown (no graph shape computed yet). */
+    providerEnabled: boolean | null;
+    embeddingNames: string[];
+    idPrefix: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,15 @@
+import type { SettingREST } from "../api/types";
+/** The environment-variable spelling an operator has to remove to manage a key here instead. */
+export declare function environmentSpelling(key: string): string;
+export declare function isEnvironmentLocked(setting: SettingREST): boolean;
+/** A stable, key-derived handle: Fallen8:Plugins:MaxCount -> config-setting-fallen8-plugins-maxcount. */
+export declare function settingTestId(key: string): string;
+export declare const SettingRow: import("react").NamedExoticComponent<{
+    setting: SettingREST;
+    /** The unsaved value, or undefined when this row is untouched. */
+    draft?: string | null;
+    onChange: (key: string, value: string) => void;
+    onClear: (key: string) => void;
+    /** True when the whole editable region is gated off (an embed host locked it). */
+    disabled?: boolean;
+}>;

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

@@ -0,0 +1,10 @@
+/**
+ * One labeled stat cell (Dashboard counts, benchmark results, Graph shape numbers, and
+ * value tiles fed user/algorithm-controlled strings such as the embedding model id or an
+ * analytics statistic key). Both lines truncate with a full-value title so an unbounded
+ * label or value can never overflow the fixed-width tile.
+ */
+export declare function Stat({ label, value }: {
+    label: string;
+    value: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,14 @@
+import type { StoredQueryKind } from "../api/types";
+/**
+ * Kind-scoped stored-query management (concept spec §5.3): a stored query is unique to its
+ * scenario — Path or SubGraph — so its management home lives on that scenario's screen, next
+ * to the fragments it captures. The panel lists ONLY entries of `kind`, with read-only source,
+ * recompile diagnostics, delete (immutable entries: delete + re-register is the edit flow),
+ * and a **Use** action that selects the entry into this screen's own filter picker. Capture
+ * ("Save as stored query…") lives in the inline advanced tier of the same screen.
+ */
+export declare function StoredQueriesPanel({ kind, onUse, }: {
+    kind: StoredQueryKind;
+    /** Select this entry into the host screen's filter picker (stored source + name). */
+    onUse: (name: string) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,29 @@
+import type { StoredPathQueryBlock, StoredQueryKind, StoredSubGraphQueryBlock } from "../api/types";
+import type { InstanceConfig } from "../instances/types";
+import type { FilterSource } from "../state/instanceStore";
+/**
+ * Stored-query surfaces shared by Path and Subgraph (concept spec §5.1/5.2): the
+ * inline|stored source toggle, the kind-filtered picker with a read-only fragment
+ * preview, and the "Save as stored query…" capture dialog. Management (list, source,
+ * delete) lives in the kind-scoped Stored queries panel below on the same screen — the
+ * picker only points there.
+ */
+export declare const REGISTRATION_401 = "registration requires the instance's API key \u2014 configure it on the Connect screen";
+export declare function FilterSourceToggle({ value, onChange, }: {
+    value: FilterSource;
+    onChange: (source: FilterSource) => void;
+}): import("react").JSX.Element;
+export declare function StoredQueryPicker({ instance, kind, value, onChange, }: {
+    instance: InstanceConfig;
+    kind: StoredQueryKind;
+    value: string;
+    onChange: (name: string) => void;
+}): import("react").JSX.Element;
+export declare function SaveAsStoredQuery({ instance, kind, buildBlock, disabled, disabledReason, onSaved, }: {
+    instance: InstanceConfig;
+    kind: StoredQueryKind;
+    buildBlock: () => StoredPathQueryBlock | StoredSubGraphQueryBlock;
+    disabled?: boolean;
+    disabledReason?: string;
+    onSaved: (name: string) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,17 @@
+/**
+ * Renders a possibly-unbounded, user-controlled string clipped so it cannot blow out the
+ * view, with the FULL value in the native title tooltip so nothing is lost. The one home for
+ * "don't let user text destroy the layout" (feature graph-namespaces follow-up).
+ *
+ * Two modes:
+ * - `max` given → a deterministic CHAR cap via {@link truncateChars} (chrome, headings,
+ *   table cells without a fixed layout). Pass `middle` for path/URL-shaped values.
+ * - `max` omitted → CSS ellipsis (`truncate`): the element must sit in a width-bounded flex
+ *   parent (`min-w-0`, and usually `flex-1`), which adapts to the available space.
+ */
+export declare function Truncated({ text, max, middle, className, }: {
+    text: string;
+    max?: number;
+    middle?: boolean;
+    className?: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+/** The one truncation indicator: an amber chip stating what was cut and where. */
+export declare function TruncationBadge({ children, testId }: {
+    children: ReactNode;
+    testId?: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,13 @@
+import { type TypedValue } from "../lib/literals";
+import type { FieldHelpKey } from "../lib/fieldHelp";
+/**
+ * Typed-literal input (FR-9): a type selector + a validated value field, replacing
+ * free-text JSON everywhere the API takes { value | propertyValue, fullQualifiedTypeName }.
+ */
+export declare function TypedLiteralEditor({ label, value, onChange, idPrefix, helpKey, }: {
+    label: string;
+    value: TypedValue;
+    onChange: (value: TypedValue) => void;
+    idPrefix: string;
+    helpKey?: FieldHelpKey;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,25 @@
+import type { InstanceConfig } from "../instances/types";
+import { type SemanticMetric, type SlotMode } from "../lib/semantic";
+/**
+ * A vertex-filter SLOT with its three fill modes (feature subgraph-semantic-thresholds):
+ * match everything, a compiled C# fragment, or a declarative semantic threshold against
+ * the request's semantic query. One owner per slot is structural here — the mode chooser
+ * replaces the old "disabled with a reason" dance, and an inert semantic configuration
+ * cannot be expressed. Used for the subgraph top-level vertex pre-filter and for every
+ * Vertex pattern step.
+ */
+export declare function VertexFilterSlot({ instance, idPrefix, label, contextLabel, mode, onModeChange, fragment, onFragmentChange, minScore, onMinScoreChange, metric, }: {
+    instance: InstanceConfig;
+    idPrefix: string;
+    label: string;
+    contextLabel: string;
+    mode: SlotMode;
+    onModeChange: (mode: SlotMode) => void;
+    fragment: string;
+    onFragmentChange: (fragment: string) => void;
+    /** Threshold text (parsed on build; non-finite blocks submit upstream). */
+    minScore: string;
+    onMinScoreChange: (minScore: string) => void;
+    /** The request's semantic metric — decides whether the threshold is a floor or a ceiling. */
+    metric: SemanticMetric;
+}): import("react").JSX.Element;

package/dist-lib/types/delegate/DelegateEditor.d.ts

@@ -0,0 +1,10 @@
+import type { DelegateKind } from "../api/types";
+import type { InstanceConfig } from "../instances/types";
+export declare function DelegateEditor({ instance, delegateKind, contextLabel, initialFragment, onCommit, onCancel, }: {
+    instance: InstanceConfig;
+    delegateKind: DelegateKind;
+    contextLabel: string;
+    initialFragment: string;
+    onCommit: (fragment: string) => void;
+    onCancel: () => void;
+}): import("react").JSX.Element;

package/dist-lib/types/delegate/DelegateSlot.d.ts

@@ -0,0 +1,18 @@
+import type { DelegateKind } from "../api/types";
+import type { InstanceConfig } from "../instances/types";
+/**
+ * A fragment slot (FR-13/16): shows the committed fragment (or "empty = match all") and
+ * opens the shared editor modal. Slots only ever hold fragments that passed validation
+ * (or empty) because the editor blocks commit otherwise (FR-25).
+ */
+export declare function DelegateSlot({ instance, delegateKind, label, contextLabel, value, onChange, disabled, disabledReason, }: {
+    instance: InstanceConfig;
+    delegateKind: DelegateKind;
+    label: string;
+    contextLabel: string;
+    value: string;
+    onChange: (fragment: string) => void;
+    /** When true (the semantic block owns this slot), the slot is inert with a reason. */
+    disabled?: boolean;
+    disabledReason?: string;
+}): import("react").JSX.Element;

package/dist-lib/types/delegate/editorOptions.d.ts

@@ -0,0 +1,25 @@
+import type { editor } from "monaco-editor";
+/**
+ * The monaco options shared by every Studio editor surface (the delegate fragment editor and
+ * the plugin source editor). One home: the two option blocks were byte-identical and must not
+ * drift. Module scope also gives them a stable identity, so the react wrapper does not re-run
+ * updateOptions on every render.
+ *
+ * `occurrencesHighlight: "off"` is load-bearing, not cosmetic. monaco 0.52 through 0.55 arm a
+ * 50 ms `Delayer` for that feature on every cursor move and DISCARD the promise it returns
+ * (wordHighlighter.js:184 and :192); disposing the editor inside that window rejects the
+ * orphaned promise with a `CancellationError` whose name and message are both "Canceled"
+ * (async.js:219). Nothing outside monaco holds that promise, so nothing can catch it: it
+ * escapes as an unhandled rejection into the page - and Studio embeds into someone else's
+ * page, whose error reporting then owns our noise. Upstream calls it a bug
+ * (microsoft/monaco-editor#4702, #4859) and fixed it in 0.56.0 by attaching the handler those
+ * two lines forgot. With the option "off" both trigger sites early-return
+ * (wordHighlighter.js:179 and :187), so the promise is never created and disposing the delayer
+ * is a no-op. Measured before the change: closing the editor 31-50 ms after a keystroke leaked
+ * the rejection in 16 of 20 runs; after it, 0 of 40. It also costs nothing to lose: these
+ * editors hold a one-to-three line lambda or a single plugin type, where highlighting the
+ * other occurrences of the word under the cursor buys nothing, and it drops a debounce plus a
+ * full-model findMatches per cursor move. Keep the option when monaco is upgraded past 0.56.0;
+ * delete the upstream half of this note then.
+ */
+export declare const F8_EDITOR_OPTIONS: editor.IStandaloneEditorConstructionOptions;

package/dist-lib/types/delegate/kinds.d.ts

@@ -0,0 +1,19 @@
+import type { DelegateKind } from "../api/types";
+/**
+ * Per-kind editing contract (spec §6.1): parameter name/type, lambda shape, usings, and
+ * the opening snippet. Every subgraph/path filter slot is typed (feature
+ * subgraph-typed-filters); GraphElementFilter is no longer produced by any slot but stays
+ * validatable on /delegates/validate — removal trigger in that feature's spec.
+ */
+export interface KindInfo {
+    kind: DelegateKind;
+    parameterName: string;
+    parameterType: "VertexModel" | "EdgeModel" | "AGraphElementModel" | "string";
+    returnType: "bool" | "double";
+    lambdaShape: string;
+    usings: string[];
+    openingSnippet: string;
+}
+export declare const KIND_INFO: Record<DelegateKind, KindInfo>;
+/** The canonical property-access idiom taught via snippets and the NL prompt (spec §6.2). */
+export declare const TRY_GET_PROPERTY_IDIOM = "return (v) => v.TryGetProperty(out int age, \"age\") && age > 30;";

package/dist-lib/types/delegate/markers.d.ts

@@ -0,0 +1,21 @@
+import type { DelegateDiagnostic } from "../api/types";
+/**
+ * Converts server diagnostics into Monaco marker data. The server already mapped
+ * positions to fragment coordinates (backend DelegateValidationHelper), so lines and
+ * columns pass through VERBATIM - re-mapping here is the off-by-N bug FR-24 forbids.
+ * Severity constants match monaco.MarkerSeverity (Error=8, Warning=4, Info=2).
+ */
+export declare const MARKER_SEVERITY: {
+    readonly error: 8;
+    readonly warning: 4;
+    readonly info: 2;
+};
+export interface MarkerData {
+    startLineNumber: number;
+    startColumn: number;
+    endLineNumber: number;
+    endColumn: number;
+    message: string;
+    severity: number;
+}
+export declare function diagnosticsToMarkers(diagnostics: DelegateDiagnostic[]): MarkerData[];

package/dist-lib/types/delegate/monacoSetup.d.ts

@@ -0,0 +1,3 @@
+import * as monaco from "monaco-editor";
+export declare function setupMonaco(): void;
+export { monaco };

package/dist-lib/types/delegate/nl/NlAssistPanel.d.ts

@@ -0,0 +1,10 @@
+import type { DelegateKind, DelegateValidationResult } from "../../api/types";
+interface NlAssistPanelProps {
+    delegateKind: DelegateKind;
+    currentFragment: string;
+    onDraft: (code: string) => void;
+    validateDraft: (code: string) => Promise<DelegateValidationResult | null>;
+    drivingRef: React.MutableRefObject<boolean>;
+}
+export declare const NlAssistPanel: (props: NlAssistPanelProps) => import("react").ReactElement<NlAssistPanelProps, string | import("react").JSXElementConstructor<any>> | null;
+export {};

package/dist-lib/types/delegate/nl/NlBackendConfig.d.ts

@@ -0,0 +1,12 @@
+import { type NlAssistConfig } from "./config";
+/**
+ * The model-backend configuration form (nl-assist spec §4 / nl-assist-ux). Extracted so the
+ * fragment editor (NlAssistPanel) and the whole-type plugin editor (PluginNlAssistPanel) share
+ * ONE backend config UI over the same persisted store — the "one home per explanation" rule.
+ * Presentational only: it renders the instance/custom switch, presets, endpoint/api/model/temp,
+ * and the optional key, and reports changes back through {@link setConfig}.
+ */
+export declare function NlBackendConfig({ config, setConfig, }: {
+    config: NlAssistConfig;
+    setConfig: (patch: Partial<NlAssistConfig>) => void;
+}): import("react").JSX.Element;

package/dist-lib/types/delegate/nl/NlDraftList.d.ts

@@ -0,0 +1,42 @@
+import type { ReactNode } from "react";
+import type { Verdict } from "./feedback";
+/**
+ * The single home for the NL-assist draft list, shared by the delegate editor
+ * (NlAssistPanel) and the plugin authoring editor (PluginNlAssistPanel). It renders the
+ * small-model's drafts (the "results") with three review affordances:
+ *
+ *  - **newest on top** — drafts arrive in generation order but display reversed, so the draft
+ *    just produced (and loaded into the editor) is where the eye lands; "draft N" numbering
+ *    stays in generation order and callbacks carry the original index, so nothing else shifts.
+ *  - **its own scrollbar** — a fixed max height keeps a long run of drafts from pushing the
+ *    export affordance (and, in the delegate sidebar, the rest of the panel) off screen.
+ *  - **unrated drafts stand out** — a draft with no 👍/👎 verdict gets a warn-toned left bar and
+ *    full-strength thumbs (a call to judge it, which feeds the fine-tune corpus); the highlight
+ *    clears the instant it is rated, and returns if the rating is cleared.
+ *
+ * The panel-specific bits (label suffix, load-button title, per-attempt stats/detail slots, and
+ * the data-testid prefixes) are passed in so both panels behave identically.
+ */
+/** One drafted candidate, as the hosting panel wants it shown. */
+export interface NlDraftView {
+    /** Server validation outcome: true = valid, false = invalid, null = not (yet) known. */
+    valid: boolean | null;
+    /** The user's 👍/👎 on this draft, or null until judged. */
+    verdict: Verdict | null;
+    /** True when this draft's body is the text currently loaded in the editor. */
+    active: boolean;
+    /** Hover title for the load button (e.g. the fragment text, or a generic hint). */
+    loadTitle: string;
+    /** Text appended after "draft N" — e.g. " (2 error(s))" or " (invalid)". Omit when valid. */
+    labelSuffix?: string;
+    /** Content shown below the row (the delegate panel's collapsible raw stats). */
+    below?: ReactNode;
+}
+export declare function NlDraftList({ testid, verdictTestidPrefix, drafts, onLoad, onRate, }: {
+    testid: string;
+    verdictTestidPrefix: string;
+    drafts: NlDraftView[];
+    /** Called with the draft's original (generation-order) index, not its display position. */
+    onLoad: (index: number) => void;
+    onRate: (index: number, verdict: Verdict) => void;
+}): import("react").JSX.Element;

package/dist-lib/types/delegate/nl/config.d.ts

@@ -0,0 +1,105 @@
+import { type ComponentType } from "react";
+/**
+ * NL-assist model backend config (nl-assist spec FR-26.4, nl-assist-ux spec §2, feature
+ * instance-config). GLOBAL scope (not per-instance): it is a single browser preference for
+ * WHERE model calls go, and instance mode targets whichever instance is active.
+ *
+ * Two modes:
+ * - "instance" (default): the call is proxied THROUGH the active Fallen-8 instance
+ *   (browser -> POST /chat -> the instance's model backend, e.g. the Ollama sidecar). The
+ *   model is server-owned (Fallen8:Chat); nothing is configured here, and the prompt travels
+ *   to the same instance the user already trusts with their graph, so there is no egress
+ *   notice. This replaces the old browser-direct "builtin" mode (feature instance-config
+ *   retired the "never through the instance" default; see docs/studio.md).
+ * - "custom": the browser calls a model endpoint DIRECTLY (Ollama-native or OpenAI-compatible),
+ *   with any API key held only in the browser and never sent to a Fallen-8 instance (FR-26.11).
+ *   A non-loopback custom endpoint shows the "text leaves this machine" notice.
+ */
+export type NlBackendMode = "instance" | "custom";
+export interface NlAssistConfig {
+    mode: NlBackendMode;
+    endpoint: string;
+    apiKind: "ollama" | "openai";
+    model: string;
+    apiKey?: string;
+    temperature: number;
+    maxRetries: number;
+}
+/**
+ * The default model the compose stack pulls for the instance's chat backend (produced by
+ * nl-assist-finetune). Shown as a hint only; in instance mode the server owns the model, and
+ * in custom mode the user picks one (see NL_PRESETS). If the chosen model is absent on the
+ * backend, calls 404 - create it with the training pipeline or pick the stock phi4-mini preset.
+ */
+export declare const DEFAULT_NL_MODEL = "phi4-f8-mini";
+export declare const DEFAULT_NL_CONFIG: NlAssistConfig;
+/** Convenience prefills for custom mode (nl-assist-ux FR-3) — not recommendations. */
+export interface NlPreset {
+    name: string;
+    endpoint: string;
+    apiKind: "ollama" | "openai";
+    model: string;
+}
+export declare const NL_PRESETS: NlPreset[];
+interface NlAssistState {
+    config: NlAssistConfig;
+    /** FR-26.10: non-loopback CUSTOM endpoints show the "text leaves this machine" notice once. */
+    leaveNoticeAccepted: boolean;
+    setConfig: (patch: Partial<NlAssistConfig>) => void;
+    acceptLeaveNotice: () => void;
+}
+/**
+ * Persist migration. The legacy browser-direct "builtin" mode becomes "instance" (feature
+ * instance-config): those users now route through the active instance rather than a fixed
+ * localhost Ollama. A pre-mode config with a stored endpoint stays "custom"; everyone else
+ * lands on the instance default.
+ */
+export declare function migrateNlState(persisted: unknown): Partial<NlAssistState>;
+export declare const useNlAssist: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<NlAssistState>, "setState" | "persist"> & {
+    setState(partial: NlAssistState | Partial<NlAssistState> | ((state: NlAssistState) => NlAssistState | Partial<NlAssistState>), replace?: false | undefined): unknown;
+    setState(state: NlAssistState | ((state: NlAssistState) => NlAssistState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<NlAssistState, NlAssistState, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: NlAssistState) => void) => () => void;
+        onFinishHydration: (fn: (state: NlAssistState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<NlAssistState, NlAssistState, unknown>>;
+    };
+}>;
+/**
+ * The embed-policy resolution (StudioConfig.nlAssist, documented on app/studioConfig.ts):
+ * under "instance-only" a custom config is forced back to instance mode with its key
+ * cleared. Applied at THREE altitudes so the policy holds structurally: the persist merge
+ * above (the store never holds a violating config), the transport (generateChat, plus the
+ * browser-direct functions refusing outright), and as a belt inside NlBackendConfig's
+ * locked rendering.
+ */
+export declare function resolveNlConfig(config: NlAssistConfig): NlAssistConfig;
+/**
+ * The one panel gate (StudioConfig.nlAssist === "disabled"): both NL panels wrap their
+ * inner component with this, so the affordance disappears identically everywhere and the
+ * early return cannot trip the rules of hooks inside the inner component. Presentation
+ * only - the transport refuses independently.
+ */
+export declare function withNlAssistPolicyGate<P extends object>(Inner: ComponentType<P>): (props: P) => import("react").ReactElement<P, string | import("react").JSXElementConstructor<any>> | null;
+/**
+ * The config to actually call a CUSTOM endpoint with. Instance mode does not go through this
+ * path (the transport routes to the active instance's /chat); it returns the config unchanged
+ * with any stray key cleared, so a status/probe read is harmless.
+ */
+export declare function effectiveNlConfig(config: NlAssistConfig): NlAssistConfig;
+/**
+ * `enabled` is derived, not stored: instance mode is configured as long as an instance is
+ * active (checked by the caller); custom needs an endpoint and model (FR-26.8).
+ */
+export declare function isNlConfigured(config: NlAssistConfig): boolean;
+/**
+ * FR-26.12: the native Ollama path never authenticates - the Ollama transport sends no
+ * Authorization header. Only OpenAI-compatible custom endpoints can carry a key.
+ */
+export declare function usesApiKey(config: NlAssistConfig): boolean;
+/** FR-26.10: loopback endpoints never show the privacy notice - nothing leaves. */
+export declare function isLoopbackEndpoint(endpoint: string): boolean;
+export {};

package/dist-lib/types/delegate/nl/feedback.d.ts

@@ -0,0 +1,30 @@
+import type { DelegateKind } from "../../api/types";
+/**
+ * FL-2 of the nl-assist-feedback-loop feature: opt-in, LOCAL capture of labelled
+ * (intent -> fragment) pairs for later fine-tuning. Nothing here touches the network - the
+ * parent NL-assist spec forbids server-side prompt storage, so capture is a file the operator
+ * exports and moves deliberately; the FL-3 consolidation tool ingests these lines and folds
+ * the good ones into the training corpus (never the held-out eval set).
+ */
+export type Verdict = "up" | "down";
+export interface TrainingExample {
+    delegateKind: DelegateKind;
+    /** The plain-language request the draft was generated from. */
+    intent: string;
+    /** The drafted fragment being labelled (a 👍 marks it a good intent->fragment pair). */
+    fragment: string;
+    verdict: Verdict | null;
+    /** Capture time (ms since epoch) — lets the consolidation tool order/dedupe. */
+    ts: number;
+}
+/**
+ * One compact JSON object per line — the JSONL the FL-3 consolidation tool reads. A trailing
+ * newline keeps concatenating multiple exports valid; an empty set yields an empty string.
+ */
+export declare function toTrainingJsonl<T>(examples: T[]): string;
+/**
+ * Trigger a browser download of `text`. Opt-in capture only: it builds an in-memory blob and
+ * clicks a link — it never calls an endpoint, so a captured example leaves the machine only
+ * when the operator moves the downloaded file.
+ */
+export declare function downloadText(filename: string, text: string): void;

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

@@ -0,0 +1,6 @@
+export declare function formatFragment(fragment: string): string;
+/**
+ * Index of the first statement-terminating `;` (top level, outside literals), or -1.
+ * Used by extractFragment to cut trailing prose a model appends after the fragment.
+ */
+export declare function firstTopLevelSemicolon(text: string): number;

package/dist-lib/types/delegate/nl/generate.d.ts

@@ -0,0 +1,57 @@
+import { type NlAssistConfig } from "./config";
+import type { NlPrompt } from "./prompt";
+import type { InstanceConfig } from "../../instances/types";
+/**
+ * Model transport (nl-assist spec §4, feature instance-config). Two paths, chosen by mode:
+ * - INSTANCE (default): browser -> the active Fallen-8 instance (POST /chat) -> its model
+ *   backend. Auth is the instance's own credential (the shared api client); no third-party
+ *   key is involved.
+ * - CUSTOM: browser DIRECTLY to an Ollama-native or OpenAI-compatible endpoint; F8 is never
+ *   in this path and the API key (if any) goes only here (FR-26.11).
+ * Either path surfaces the provider's generation statistics (nl-assist-ux FR-5).
+ */
+/**
+ * Studio's own ceiling on ONE model call, and the LAST bound to fire in a normal setup.
+ *
+ * `fetch` has no timeout, so without this a browser-direct custom endpoint (custom mode, which has
+ * no Fallen-8 in front of it) can hang forever, and an instance whose connection wedges without
+ * answering never resolves either. Minutes are the right order of magnitude because a local model
+ * on CPU genuinely needs them.
+ *
+ * It is deliberately generous so that in instance mode `Fallen8:Chat:TimeoutSeconds` stays the
+ * deadline the user actually meets, and they get the server's 504 naming the setting they can
+ * change. Be honest about the consequence though: this is a hard ceiling, so a chat budget raised
+ * ABOVE it is capped here and the editor stops waiting first. That is stated in the give-up message
+ * and on the troubleshooting page rather than left for someone to discover.
+ */
+export declare const NL_REQUEST_TIMEOUT_MS: number;
+export interface ChatTurn {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface NlGenerationStats {
+    promptTokens?: number;
+    completionTokens?: number;
+    durationMs?: number;
+    tokensPerSecond?: number;
+    /** The provider's stats fields verbatim, for the expandable raw view. */
+    raw: Record<string, unknown>;
+}
+export interface NlChatResult {
+    content: string;
+    stats: NlGenerationStats | null;
+}
+/**
+ * The single entry point both NL panels call. Routes to the instance gateway or a
+ * browser-direct custom endpoint per {@link NlAssistConfig.mode}.
+ */
+export declare function generateChat(config: NlAssistConfig, instance: InstanceConfig | null, messages: ChatTurn[], signal?: AbortSignal): Promise<NlChatResult>;
+/** Instance-gateway path: browser -> F8 POST /chat -> the server's model backend. */
+export declare function chatViaInstance(instance: InstanceConfig, messages: ChatTurn[], temperature: number, signal?: AbortSignal): Promise<NlChatResult>;
+export declare function chatWithModel(config: NlAssistConfig, messages: ChatTurn[], signal?: AbortSignal): Promise<NlChatResult>;
+/**
+ * Reachability probe (nl-assist-ux FR-2): informational only, never gates generation.
+ * Ollama exposes GET /api/version; OpenAI-compatible endpoints expose GET /v1/models.
+ */
+export declare function probeEndpoint(config: NlAssistConfig, signal?: AbortSignal): Promise<boolean>;
+export declare function initialMessages(prompt: NlPrompt): ChatTurn[];

package/dist-lib/types/delegate/nl/prompt.d.ts

@@ -0,0 +1,21 @@
+import type { DelegateDiagnostic, DelegateKind } from "../../api/types";
+/**
+ * Generation-prompt assembly (nl-assist spec FR-26.5). The contract fixes the order:
+ * (a) emit-only-a-fragment instruction, (b) the slot's exact lambda shape, (c) the
+ * available usings, (d) the reachable member surface incl. the TryGetProperty idiom,
+ * (e) matching few-shot examples from the snippet library (required - they carry the
+ * Python-to-C# gap), (f) the user's plain-language intent.
+ */
+export interface NlPrompt {
+    system: string;
+    user: string;
+}
+export declare function buildGenerationPrompt(kind: DelegateKind, intent: string, priorDrafts?: string[]): NlPrompt;
+/** Follow-up turn for the refine loop (FR-26.7): failed fragment + its diagnostics. */
+export declare function buildRefinePrompt(kind: DelegateKind, fragment: string, diagnostics: DelegateDiagnostic[]): string;
+/**
+ * Output handling (FR-26.6): strip markdown fences and stray prose. A fenced block wins;
+ * otherwise cut leading prose before the first "return" and trailing prose after the
+ * statement's closing `;` (models append parenthetical notes there - seen in the field).
+ */
+export declare function extractFragment(raw: string): string;

package/dist-lib/types/delegate/nl/useNlRun.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Run lifecycle shared by both NL panels (the delegate editor's and the plugin editor's).
+ * It exists because the two panels had the same two defects in duplicate:
+ *
+ * - The panel held an AbortController but nothing aborted it on unmount, so closing the editor
+ *   mid-draft left the model call running. On a slow backend a second generation then queued
+ *   behind the orphan instead of starting.
+ * - Nothing aborted a previous run when a new one began.
+ *
+ * Both are lifecycle concerns rather than presentation, so they live here once.
+ */
+export declare function useNlRun(): {
+    begin: () => AbortController;
+    cancel: () => void;
+};
+/**
+ * Whole seconds since `active` last became true, and 0 whenever it is false.
+ *
+ * This is the panels' only progress signal, and it is load-bearing rather than decorative: a
+ * local model on CPU can need minutes for one draft (see the troubleshooting page), so without
+ * an advancing number a working call is indistinguishable from a hung one, which is exactly how
+ * the original hang was reported.
+ */
+export declare function useElapsedSeconds(active: boolean): number;

package/dist-lib/types/delegate/providers.d.ts

@@ -0,0 +1,26 @@
+import type * as Monaco from "monaco-editor";
+import type { DelegateKind } from "../api/types";
+/**
+ * Static IntelliSense (FR-22): completions, hovers, and signature help driven entirely by
+ * the checked-in type model - the server's validate endpoint stays the only compile
+ * authority. Members are scoped to the slot's parameter type: after `v.` a VertexFilter
+ * offers AGraphElementModel + VertexModel members; an EdgePropertyFilter's `p.` offers
+ * string members only and no graph model.
+ */
+interface ModelMember {
+    name: string;
+    kind: string;
+    signature: string;
+    doc: string;
+    /**
+     * False = the member exists on the engine type but a fragment cannot CALL it. Offered anyway as a
+     * discovery aid, sorted last, struck through, and withheld from the NL-assist prompt. Which
+     * members and why: docs/src/content/docs/delegates.mdx, "Accessor surface".
+     */
+    compilable?: boolean;
+}
+export declare function membersForType(typeName: string): ModelMember[];
+export declare function memberByName(name: string): ModelMember | undefined;
+/** Registers all providers for one editor session; returns a dispose function. */
+export declare function registerDelegateProviders(monaco: typeof Monaco, delegateKind: DelegateKind): () => void;
+export {};