@fallen-8/studio 0.0.33 → 0.0.35

package/dist-lib/{javascript-CK1z7Ynl.js → javascript-DvuxCyB4.js}

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

package/dist-lib/{jsonMode-C4Q3fVvV.js → jsonMode-BU3w8kmM.js}

@@ -1,4 +1,4 @@
-import { m as Et } from "./index-DFm6T7Un.js";
+import { m as Et } from "./index-B9b5xEwe.js";
 var Lt = Object.defineProperty, Ot = Object.getOwnPropertyDescriptor, Nt = Object.getOwnPropertyNames, Rt = Object.prototype.hasOwnProperty, Mt = (e, r, i, n) => {
   if (r && typeof r == "object" || typeof r == "function")
     for (let t of Nt(r))

package/dist-lib/{liquid-BnCUERBj.js → liquid-r_J0hX64.js}

@@ -1,4 +1,4 @@
-import { m as l } from "./index-DFm6T7Un.js";
+import { m as l } from "./index-B9b5xEwe.js";
 var d = Object.defineProperty, s = Object.getOwnPropertyDescriptor, c = Object.getOwnPropertyNames, u = Object.prototype.hasOwnProperty, m = (t, e, r, n) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let i of c(e))

package/dist-lib/{mdx-D2enmFMs.js → mdx-5vg3Qy8b.js}

@@ -1,4 +1,4 @@
-import { m as s } from "./index-DFm6T7Un.js";
+import { m as s } from "./index-B9b5xEwe.js";
 var d = Object.defineProperty, c = Object.getOwnPropertyDescriptor, p = Object.getOwnPropertyNames, a = Object.prototype.hasOwnProperty, k = (n, e, i, r) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let o of p(e))

package/dist-lib/{python-DJvSF53q.js → python-DlLCDuTf.js}

@@ -1,4 +1,4 @@
-import { m as o } from "./index-DFm6T7Un.js";
+import { m as o } from "./index-B9b5xEwe.js";
 var a = Object.defineProperty, l = Object.getOwnPropertyDescriptor, p = Object.getOwnPropertyNames, c = Object.prototype.hasOwnProperty, g = (t, e, n, s) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let r of p(e))

package/dist-lib/{razor-RerkagjP.js → razor-D-OmEXY0.js}

@@ -1,4 +1,4 @@
-import { m } from "./index-DFm6T7Un.js";
+import { m } from "./index-B9b5xEwe.js";
 var s = Object.defineProperty, c = Object.getOwnPropertyDescriptor, l = Object.getOwnPropertyNames, d = Object.prototype.hasOwnProperty, p = (t, e, o, n) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let r of l(e))

package/dist-lib/{tsMode-C-6d-f_-.js → tsMode-Dophy2cR.js}

@@ -1,4 +1,4 @@
-import { t as O, m as I } from "./index-DFm6T7Un.js";
+import { t as O, m as I } from "./index-B9b5xEwe.js";
 var N = Object.defineProperty, M = Object.getOwnPropertyDescriptor, R = Object.getOwnPropertyNames, K = Object.prototype.hasOwnProperty, E = (e, t, i, o) => {
   if (t && typeof t == "object" || typeof t == "function")
     for (let n of R(t))

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

@@ -126,6 +126,12 @@ export interface BulkImportResultREST {
     verticesCreated: number;
     edgesCreated: number;
     linesRead: number;
+    /**
+     * Whether every committed batch reached the write-ahead log (platform-integrity-audit W5).
+     * `false` means the counts above are real but a restart would lose part of the import, so the
+     * graph needs a checkpoint. Optional because an older server does not send it.
+     */
+    durable?: boolean;
 }
 /**
  * GET /ns/{ns}/generate - what a benchmark-graph generation created. Generation is ADDITIVE, so
@@ -965,7 +971,7 @@ export interface DelegateValidationResult {
     diagnostics: DelegateDiagnostic[];
 }
 /** What kind of value a provider setting takes, which is all a form needs to render it. */
-export type SettingKind = "Text" | "Number" | "Boolean" | "Url" | "Credential";
+export type SettingKind = "Text" | "Number" | "Boolean" | "Url" | "Credential" | "File";
 /** One setting, as data. `help` says where to find the value in the source system. */
 export interface IntegrationSetting {
     key: string;
@@ -974,6 +980,11 @@ export interface IntegrationSetting {
     required: boolean;
     help: string;
     defaultValue?: string | null;
+    /**
+     * `File` settings only: the extensions the picker offers, as the HTML attribute spells them.
+     * A hint, not a rule - a browser ignores it for a dropped file and the runtime never checks it.
+     */
+    accept?: string | null;
 }
 /**
  * What an integration IS, as data that is true before any run exists. A form is rendered from
@@ -998,9 +1009,17 @@ export interface IntegrationDiagnostic {
     message: string;
     subject?: string | null;
 }
+/** One file a job carries: its own name, and its bytes base64. */
+export interface IntegrationJobFile {
+    /** The file's own name, used verbatim in the run's messages. Never a path. */
+    name: string;
+    /** The file's BYTES, base64 - not its text, so a UTF-16 extract survives the trip. */
+    contentBase64: string;
+}
 /**
  * The whole configuration of one run. A credential setting's value arrives in `credentialValues` and
- * never in `settings`: the runtime leases and redacts the first and treats the second as ordinary data.
+ * a file setting's file in `files`, never in `settings`: the runtime leases and redacts the first,
+ * holds the second for the run and drops it, and treats `settings` as ordinary data.
  */
 export interface IntegrationJobRequest {
     providerId: string;
@@ -1009,6 +1028,11 @@ export interface IntegrationJobRequest {
     settings: Record<string, string>;
     /** Secrets. Held for the run and dropped; never persisted here, never echoed back. */
     credentialValues: Record<string, string>;
+    /**
+     * Files, by the file setting each was supplied for. Held for the run and dropped: the runtime
+     * mounts no directory, so this is the only way a file reaches a provider.
+     */
+    files?: Record<string, IntegrationJobFile>;
     embedSummaries?: boolean;
 }
 /** The only account of a job, because the runtime keeps none. */

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

@@ -0,0 +1,42 @@
+import type { ApiError } from "../api/client";
+import type { ObservabilityConfigREST, PendingRestartREST, SettingREST } from "../api/types";
+/**
+ * The configuration surface (feature configuration-surface): one dialog holding everything this
+ * instance binds, reached from the single Configure button on the Connect screen's configuration card.
+ *
+ * It exists because the card used to render all hundred-odd catalogued settings as ONE flat list,
+ * inline, in a twelve-row window. Here they are sectioned, searchable and filterable, and one section
+ * shows at a time.
+ *
+ * It deliberately owns NO server state: the draft, the mutation, the poll suspension and the lock
+ * gating all stay on the card, which outlives this dialog. Two observers on the config query would let
+ * react-query take the shortest refetch interval, and the card polling every ten seconds would replace
+ * a value under a half-typed field here, which is exactly what the poll suspension exists to prevent.
+ * What this component does own is where you are looking: the section, the query and the filter. Those
+ * live under Dialog.Content, which Radix unmounts on close, so they reset without an effect.
+ */
+export interface ConfigurationSurfaceProps {
+    open: boolean;
+    onClose: () => void;
+    /** Named in the header, because the settings behind it belong to one instance and not the next. */
+    instanceName: string;
+    settings: readonly SettingREST[];
+    pendingRestart: readonly PendingRestartREST[];
+    observability: ObservabilityConfigREST;
+    draft: Record<string, string | null>;
+    dirtyCount: number;
+    onChange: (key: string, value: string) => void;
+    onClear: (key: string) => void;
+    onSave: () => void;
+    saving: boolean;
+    writeError: ApiError | Error | null;
+    /** Whether the server accepts PATCH /config at all (both operator acts are in place). */
+    writesAllowed: boolean;
+    /** False when an embed host locked the instance, which gates the whole editable region. */
+    editable: boolean;
+    /** Per key, because the namespace lock narrows to one prefix rather than the whole surface. */
+    isRowDisabled: (key: string) => boolean;
+    /** A blanked numeric field the server would refuse the whole batch over, if there is one. */
+    blankNumericKey?: string;
+}
+export declare function ConfigurationSurface(props: ConfigurationSurfaceProps): import("react").JSX.Element;

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

@@ -0,0 +1,23 @@
+import { type ReactNode } from "react";
+/**
+ * The drop half of taking a file from the user: the dashed target, the drag highlight, and the one
+ * rule that is easy to get wrong (`preventDefault` on drag-over, or the browser navigates to the
+ * file instead). Shared by the Knowledge screen's document ingest and the Integrations screen's
+ * file settings, because a second copy of the drag handlers is a second thing to get wrong.
+ *
+ * What each screen keeps is what differs: Knowledge INGESTS on drop, Integrations STAGES for a run
+ * that also needs an identity, and each owns its own file picker so the button next to it can mean
+ * what that screen needs it to mean.
+ */
+export declare function FileDropzone(props: {
+    /** Called with the dropped file. */
+    onFile: (file: File) => void;
+    /** Greys the target out and refuses drops, for a screen that is not ready to take one. */
+    disabled?: boolean;
+    /** What the target says when nothing is being dragged over it. */
+    children: ReactNode;
+    /** Defaults to `dropzone`. */
+    testId?: string;
+    /** Extra classes, for a screen whose layout needs its own margins. */
+    className?: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,23 @@
+import type { InstanceConfig } from "../instances/types";
+/**
+ * The health cell of an Instances row (feature instance-level-health). An instance is a COLLECTION
+ * of namespaces, so this cell reports the collection; the per-namespace view is the Namespaces
+ * panel one section below.
+ *
+ * Two requests, each answering the question only it can:
+ *
+ * - `/status` is the PROBE. It is the one `[AllowAnonymous]` route, so it is the only thing that can
+ *   tell "unreachable" from "unauthorized" on a key-secured instance. Its counts, though, are
+ *   namespace-scoped, and this row addresses instances it has not activated, so unbound means they
+ *   are the reserved `default` alone: reporting them as the instance is the defect this component
+ *   was rewritten to remove.
+ * - `/ns` is the SIZE: the only route that reports every namespace. It is not anonymous, so it is
+ *   fetched only once the probe says the credential is good, and the row never fires a request it
+ *   knows will 401.
+ *
+ * The probe's counts survive as the two degraded readings only, both labelled for what they are
+ * (see `describeWholeGraph` / `describeDefaultOnly`).
+ */
+export declare function InstanceHealth({ instance }: {
+    instance: InstanceConfig;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,11 @@
+import type { ObservabilityConfigREST, SettingREST } from "../api/types";
+export interface ObservabilitySectionProps {
+    observability: ObservabilityConfigREST;
+    /** The section's descriptors. Empty on an instance that publishes no settings inventory. */
+    settings: readonly SettingREST[];
+    draft: Record<string, string | null>;
+    onChange: (key: string, value: string) => void;
+    onClear: (key: string) => void;
+    isRowDisabled: (key: string) => boolean;
+}
+export declare function ObservabilitySection({ observability, settings, draft, onChange, onClear, isRowDisabled, }: ObservabilitySectionProps): import("react").JSX.Element;

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

@@ -1,9 +1,4 @@
 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. */

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

@@ -0,0 +1,95 @@
+import type { SettingREST } from "../api/types";
+/**
+ * The client's view of the server's setting catalog (feature configuration-surface): how the
+ * instance's settings are grouped for a reader, how a query and a filter select among them, and the
+ * two per-key rules Studio derives from a descriptor.
+ *
+ * It exists because GET /config publishes a FLAT list of about a hundred descriptors in the server's
+ * own declaration order, and one flat list is what made the old inline panel unreadable. Everything
+ * here is pure: no React, no API call, so the grouping is testable on its own, which matters because
+ * a key this module silently dropped would be editable nowhere and invisible in a screenshot.
+ *
+ * It deliberately carries NO description of what an individual key means. That lives on the server's
+ * own catalog reason and on each feature's docs page; a second copy here would drift. The one thing
+ * this module does explain is what a SECTION governs, in one line, because no server field says that.
+ */
+/** A nav heading over a run of sections. */
+export type ConfigGroupId = "graph" | "workloads" | "semantic" | "operations" | "reference" | "ungrouped";
+export declare const CONFIG_GROUPS: readonly {
+    id: ConfigGroupId;
+    label: string;
+}[];
+export interface ConfigSection {
+    id: string;
+    group: ConfigGroupId;
+    label: string;
+    /** One line on what the section governs. Never what a single key does. */
+    blurb: string;
+    /**
+     * The raw config sections (a key's SECOND segment) this entry collects, in render order. The first
+     * is the primary: its own keys render without a sub-group header.
+     */
+    raw: readonly string[];
+    /** True when the pane renders its rows without sub-group headers at all. */
+    flat?: boolean;
+}
+/** Where an unmapped raw section lands, so a section this version does not know is still readable. */
+export declare const OTHER_SECTION_ID = "other";
+/**
+ * The ordered sections. Not alphabetical and not the server's order: the read/write sections come
+ * first in rough tuning order and the two entirely read-only ones last, because the reason to open
+ * this surface is almost always to change something.
+ *
+ * `raw` is a section NAME, never a key list: the server encodes the grouping in the key itself, and a
+ * key list would silently miss the next key added under a section.
+ */
+export declare const CONFIG_SECTIONS: readonly ConfigSection[];
+/**
+ * The section a key belongs to, from its SECOND segment, which is the same rule the server states for
+ * itself. Exact-case on purpose: a mis-cased key is not the key the server publishes, and normalising
+ * it here would hide that rather than showing it under "Other".
+ */
+export declare function sectionOf(key: string): ConfigSection;
+/** A run of rows under one header inside a section pane. `label` is "" for the section's own keys. */
+export interface SettingGroup {
+    label: string;
+    settings: SettingREST[];
+}
+export interface SectionGroup {
+    section: ConfigSection;
+    /** Every setting in the section, in render order. */
+    settings: SettingREST[];
+    /** The sub-groups, direct keys first; a single unlabelled group when the section renders flat. */
+    groups: SettingGroup[];
+}
+/**
+ * Buckets the published settings into the ordered sections, preserving the server's order within a
+ * raw section: the catalog authors related keys adjacently (an index switch is followed by the index
+ * id it governs) and an alphabetical re-sort would split those pairs.
+ *
+ * Every input setting comes out in exactly one section. Nothing is filtered here, so a key this
+ * version does not recognise lands in "Other" rather than disappearing.
+ */
+export declare function groupSettings(settings: readonly SettingREST[] | undefined): SectionGroup[];
+/**
+ * Whether a setting matches a search. Covers the key, the exclusion rule and the reason, and
+ * deliberately NOT the value: a value here can be an endpoint or a filesystem path, and a value
+ * search would turn the box into a way to fish for one.
+ */
+export declare function matchesQuery(setting: SettingREST, query: string): boolean;
+/** 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 type ConfigFilterId = "all" | "writable" | "restartPending" | "notWritable" | "setHere" | "environment";
+/**
+ * The filter strip. Each one answers a question an operator actually arrives with, and none of them
+ * hides a row silently: the pane always states how many of how many it is showing.
+ */
+export declare const CONFIG_FILTERS: readonly {
+    id: ConfigFilterId;
+    label: string;
+    title: string;
+}[];
+export declare function matchesFilter(setting: SettingREST, filter: ConfigFilterId): boolean;

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

@@ -0,0 +1,47 @@
+import type { NamespaceEntry } from "../api/types";
+/**
+ * Instance-level size, summed over the namespace inventory (feature instance-level-health): an
+ * INSTANCE is a collection of namespaces, so a number that describes one must cover all of them.
+ * The rules that make this honest live here rather than in the component that renders them.
+ */
+export interface NamespaceTotals {
+    /** Inventory size. Exact: `GET /ns` lists the catalog, not the residency filter. */
+    namespaces: number;
+    /**
+     * Summed over the entries that report counts, or null when NONE does. Never a stand-in zero:
+     * a namespace this server did not load reports null (feature namespace-startup-load), and
+     * folding that into the sum as 0 would claim an empty graph over data still on disk.
+     */
+    vertices: number | null;
+    /** Summed like {@link vertices}. */
+    edges: number | null;
+    /** How many entries reported no counts, i.e. how much the sums are missing. */
+    unreported: number;
+}
+/** A rendered total: the cell's text, plus the tooltip that states which namespaces it covers. */
+export interface TotalsDisplay {
+    label: string;
+    title: string;
+}
+/**
+ * Sums an inventory. An entry counts as reporting only when BOTH counts are numbers - the server
+ * moves them together (both null for a namespace it did not load), and a half-reported entry is
+ * unknown either way, so it belongs in `unreported` rather than in a sum of one dimension.
+ */
+export declare function summarizeInventory(entries: NamespaceEntry[]): NamespaceTotals;
+/**
+ * The instance total: `N ns · V v · E e`. The tooltip always names the scope, because the bug this
+ * replaced was a count whose scope was unstated (it silently meant the reserved `default`).
+ */
+export declare function describeTotals(totals: NamespaceTotals): TotalsDisplay;
+/**
+ * A server that predates namespaces (`GET /ns` 404s): its bare routes ARE the whole graph, so the
+ * probe's counts are already instance-level and carry no `ns` segment.
+ */
+export declare function describeWholeGraph(vertices: number | null, edges: number | null): TotalsDisplay;
+/**
+ * The degraded reading: the inventory could not be read, so all we have is the probe, which is
+ * namespace-scoped and aliases `default`. The label SAYS `default:` rather than passing one
+ * namespace off as the instance - that substitution is the defect this feature exists to remove.
+ */
+export declare function describeDefaultOnly(vertices: number | null, edges: number | null, reason: string): TotalsDisplay;

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

@@ -1,4 +1,4 @@
-import { m as s } from "./index-DFm6T7Un.js";
+import { m as s } from "./index-B9b5xEwe.js";
 var c = Object.defineProperty, a = Object.getOwnPropertyDescriptor, p = Object.getOwnPropertyNames, g = Object.prototype.hasOwnProperty, l = (t, e, o, i) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let n of p(e))

package/dist-lib/{xml-CSt-F-dl.js → xml-pmqwhaBA.js}

@@ -1,4 +1,4 @@
-import { m as r } from "./index-DFm6T7Un.js";
+import { m as r } from "./index-B9b5xEwe.js";
 var m = Object.defineProperty, c = Object.getOwnPropertyDescriptor, l = Object.getOwnPropertyNames, d = Object.prototype.hasOwnProperty, p = (t, e, o, i) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let n of l(e))

package/dist-lib/{yaml-kSsc3ru_.js → yaml-DN1I59zm.js}

@@ -1,4 +1,4 @@
-import { m as l } from "./index-DFm6T7Un.js";
+import { m as l } from "./index-B9b5xEwe.js";
 var i = Object.defineProperty, c = Object.getOwnPropertyDescriptor, u = Object.getOwnPropertyNames, s = Object.prototype.hasOwnProperty, d = (n, e, r, o) => {
   if (e && typeof e == "object" || typeof e == "function")
     for (let t of u(e))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fallen-8/studio",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "F8 Studio - browser frontend for Fallen-8 instances, and its graph canvas as a standalone component",
   "license": "MIT",
   "author": "Henning Rauch",