@fallen-8/studio 0.0.35 → 0.0.37

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

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

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

@@ -1,4 +1,4 @@
-import { m as Et } from "./index-B9b5xEwe.js";
+import { m as Et } from "./index-BQbFjItv.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-r_J0hX64.js → liquid-DLrt4Cls.js}

@@ -1,4 +1,4 @@
-import { m as l } from "./index-B9b5xEwe.js";
+import { m as l } from "./index-BQbFjItv.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-5vg3Qy8b.js → mdx-DePkemui.js}

@@ -1,4 +1,4 @@
-import { m as s } from "./index-B9b5xEwe.js";
+import { m as s } from "./index-BQbFjItv.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-DlLCDuTf.js → python-CUe0bWsE.js}

@@ -1,4 +1,4 @@
-import { m as o } from "./index-B9b5xEwe.js";
+import { m as o } from "./index-BQbFjItv.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-D-OmEXY0.js → razor-DD_zUh3z.js}

@@ -1,4 +1,4 @@
-import { m } from "./index-B9b5xEwe.js";
+import { m } from "./index-BQbFjItv.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-Dophy2cR.js → tsMode-Ae3UtOmp.js}

@@ -1,4 +1,4 @@
-import { t as O, m as I } from "./index-B9b5xEwe.js";
+import { t as O, m as I } from "./index-BQbFjItv.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/client.d.ts

@@ -33,11 +33,35 @@ export declare class ApiError extends Error {
     readonly body: string;
     constructor(status: number, url: string, body: string);
 }
+/**
+ * A request that was accepted and never answered. Distinct from {@link ApiError}, which carries a
+ * status the server chose: this one exists because there was no answer at all.
+ *
+ * It has a status of 0 so a caller can still branch on `status`, and it is what turns "the spinner
+ * never stops" into a stated failure. That distinction is not theoretical - a broken IPv6 loopback
+ * forward on one published port left the Connect screen reading "checking..." indefinitely, with no
+ * error anywhere, because a hung fetch never settles and so never becomes an error at all.
+ */
+export declare class ApiTimeoutError extends Error {
+    readonly status = 0;
+    readonly url: string;
+    readonly timeoutMs: number;
+    constructor(url: string, timeoutMs: number);
+}
 export interface RequestOptions {
     method?: "GET" | "POST" | "PUT" | "DELETE" | "HEAD" | "PATCH";
     body?: unknown;
     query?: Record<string, string | number | boolean | undefined>;
     signal?: AbortSignal;
+    /**
+     * Abort after this long and fail with {@link ApiTimeoutError}.
+     *
+     * OPT-IN, per call, and deliberately not a default: a job run over a 100 MiB extract legitimately
+     * takes half a minute, and a blanket timeout would abort exactly the long operations this API
+     * exists for. It belongs on the REACHABILITY probes, whose whole question is "is it there?" and
+     * whose answer arrives in milliseconds or not at all.
+     */
+    timeoutMs?: number;
     /**
      * Namespace scoping (feature graph-namespaces). "namespace" (the default) prefixes the
      * path with /ns/{namespace} when the instance is namespace-bound - the namespace is
@@ -72,6 +96,22 @@ export declare function resolveAuthHeaders(instance: InstanceConfig): Promise<Re
  * Shared by {@link apiRequest} and the raw-fetch bulk endpoints so every failure looks the same.
  */
 export declare function throwIfNotOk(response: Response, url: string): Promise<void>;
+/**
+ * One request's deadline: a signal that aborts when the caller's does OR when the timeout expires,
+ * and a flag saying which of the two happened.
+ *
+ * Built by hand rather than with `AbortSignal.any`, which jsdom does not implement - a test suite
+ * that cannot run the code is not covering it.
+ *
+ * `timeoutMs` undefined or 0 means no deadline at all: the caller's own signal passes through
+ * unchanged and `expired` never becomes true. Exported so a caller with its own timeout budget
+ * (nl-assist's model-call ceiling, generate.ts) reuses this rather than re-deriving it.
+ */
+export declare function startDeadline(caller: AbortSignal | undefined, timeoutMs: number | undefined): {
+    signal: AbortSignal | undefined;
+    expired: boolean;
+    done: () => void;
+};
 export declare function apiRequest<T>(instance: InstanceConfig, path: string, options?: RequestOptions): Promise<T | null>;
 /**
  * Multipart POST (feature unstructured-ingestion: the document upload). Same URL scoping,

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

@@ -1,5 +1,13 @@
 import type { InstanceConfig } from "../instances/types";
-import type { AnalyticsResultREST, DocumentBinding, DocumentDetail, DocumentEntityList, DocumentList, DocumentSearchResult, DocumentSearchSpecification, DocumentSummary, IngestTextSpecification, IntegrationJobReport, IntegrationJobRequest, IntegrationProvider, NamespaceActivationREST, NamespaceEntry, NamespacesResponse, NamespaceTriState, AnalyticsSpecification, BenchmarkResult, BulkImportResultREST, GraphGenerationResult, AlgorithmPluginRegistration, DelegateKind, DelegateValidationResult, EdgeREST, EmbedElementSpecification, FunctionPluginRegistration, GraphFunctionResultREST, PluginAuthoringCategory, PluginDetailREST, PluginSummaryREST, PluginValidationResult, PluginValidationSpecification, ConfigREST, ConfigWriteREST, ConfigWriteSpec, ChatCompletionSpec, ChatCompletionResultREST, EmbeddingSearchSpecification, EmbeddingWriteSpecification, SaveGame, EdgeSpecification, FulltextIndexScanSpecification, FulltextSearchResultREST, GraphREST, GraphStatisticsREST, IndexAddToSpecification, IndexKeySpecification, IndexScanSpecification, PartitionMembersREST, PathREST, PathSpecification, PluginSpecification, PropertySearchSpecification, PropertySpecification, RangeIndexScanSpecification, ScanSpecification, SearchDistanceSpecification, GraphElementBatchREST, StatusREST, StoredQueryDetailREST, StoredQuerySpecification, StoredQuerySummaryREST, SubGraphSpecification, SubGraphSummary, VectorIndexAddSpecification, VectorIndexScanSpecification, VectorSearchResultREST, VertexREST, VertexSpecification } from "./types";
+import type { AnalyticsResultREST, DocumentBinding, DocumentDetail, DocumentEntityList, DocumentList, DocumentSearchResult, DocumentSearchSpecification, DocumentSummary, IngestTextSpecification, IntegrationJobRequest, IntegrationRunAccepted, IntegrationRunState, IntegrationProvider, NamespaceActivationREST, NamespaceEntry, NamespacesResponse, NamespaceTriState, AnalyticsSpecification, BenchmarkResult, BulkImportResultREST, GraphGenerationResult, AlgorithmPluginRegistration, DelegateKind, DelegateValidationResult, EdgeREST, EmbedElementSpecification, FunctionPluginRegistration, GraphFunctionResultREST, PluginAuthoringCategory, PluginDetailREST, PluginSummaryREST, PluginValidationResult, PluginValidationSpecification, ConfigREST, ConfigWriteREST, ConfigWriteSpec, ChatCompletionSpec, ChatCompletionResultREST, EmbeddingSearchSpecification, EmbeddingWriteSpecification, SaveGame, EdgeSpecification, FulltextIndexScanSpecification, FulltextSearchResultREST, GraphREST, GraphStatisticsREST, IndexAddToSpecification, IndexKeySpecification, IndexScanSpecification, PartitionMembersREST, PathREST, PathSpecification, PluginSpecification, PropertySearchSpecification, PropertySpecification, RangeIndexScanSpecification, ScanSpecification, SearchDistanceSpecification, GraphElementBatchREST, StatusREST, StoredQueryDetailREST, StoredQuerySpecification, StoredQuerySummaryREST, SubGraphSpecification, SubGraphSummary, VectorIndexAddSpecification, VectorIndexScanSpecification, VectorSearchResultREST, VertexREST, VertexSpecification } from "./types";
+/**
+ * The reachability probe, and the ONE call with a deadline (see `RequestOptions.timeoutMs`).
+ *
+ * `/status` answers in milliseconds or the instance is not usable, so a probe still pending after
+ * ten seconds has told us what we needed to know. Without the deadline a hung connection leaves the
+ * promise pending for ever, and every screen that renders "checking..." until this succeeds says
+ * "checking..." for ever - which is worse than an error, because an error names an address.
+ */
 export declare const getStatus: (i: InstanceConfig, signal?: AbortSignal) => Promise<StatusREST | null>;
 /**
  * Instance configuration (feature instance-config): the read-only operator view of the
@@ -194,4 +202,22 @@ export declare const listEntities: (i: InstanceConfig, options?: {
 /** The integrations this instance's runtime ships. A 403 or 401 means the capability is off. */
 export declare const listIntegrationProviders: (i: InstanceConfig, signal?: AbortSignal) => Promise<IntegrationProvider[] | null>;
 /** Runs one job and returns its report. A job that RAN and failed still answers 200. */
-export declare const submitIntegrationJob: (i: InstanceConfig, job: IntegrationJobRequest) => Promise<IntegrationJobReport | null>;
+/**
+ * Starts a run. Answers a run id, NOT a report: the report is read afterwards from
+ * getIntegrationRun, because any real source outlives the connection that would have carried it.
+ * Everything that can reject the job still fails this call, so a resolved promise means it started.
+ */
+export declare const submitIntegrationJob: (i: InstanceConfig, job: IntegrationJobRequest) => Promise<IntegrationRunAccepted | null>;
+/**
+ * One identity's current or most recent run: the phase while it runs, the report once it ends.
+ * Answers 404 when the runtime has no slot for that identity, which a caller should read as "not
+ * this process" rather than as an error.
+ */
+export declare const getIntegrationRun: (i: InstanceConfig, instanceId: string) => Promise<IntegrationRunState | null>;
+/**
+ * Asks the run in flight under one identity to stop. Answers 202 and not 200 because a stop is a
+ * REQUEST honoured at the run's next safe point, so the run as answered here is the run as it was
+ * when the stop was recorded, and getIntegrationRun is what shows it taking effect. A 404 means
+ * nothing is in flight: a run that already ended is not cancellable. Cancelling twice is not an error.
+ */
+export declare const cancelIntegrationRun: (i: InstanceConfig, instanceId: string) => Promise<IntegrationRunState | null>;

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

@@ -189,7 +189,8 @@ export interface StatusREST {
  * a single outcome. The reason it is on the cheap status surface at all: a client that reconciles
  * against the graph and then deletes what nothing asserts any more would otherwise draw that
  * conclusion from truncated history with no way to know. The integrations runtime does exactly
- * that and defers deletion on this block; a human watching a dashboard deserves the same signal.
+ * that and defers deletion on this block; the human watching deserves the same signal, which is
+ * why the app shell renders it too (see DurabilityNotice).
  */
 export interface DurabilityREST {
     walEnabled: boolean;
@@ -985,6 +986,13 @@ export interface IntegrationSetting {
      * A hint, not a rule - a browser ignores it for a dropped file and the runtime never checks it.
      */
     accept?: string | null;
+    /**
+     * `File` settings only: whether the setting takes SEVERAL files rather than one. A statement
+     * about the source and not a convenience - a vehicle network arrives as one extract per domain,
+     * and the files reference each other, so only the whole set describes it. The runtime refuses the
+     * flag on any other kind at startup, so a form can trust it wherever it appears.
+     */
+    multiple?: boolean;
 }
 /**
  * What an integration IS, as data that is true before any run exists. A form is rendered from
@@ -1003,6 +1011,68 @@ export interface IntegrationProvider {
     readOnly: boolean;
     entitySummaryTemplate?: string | null;
 }
+/**
+ * The phases a run passes through, in order. Mirrors RunPhases in the integrations runtime, which is
+ * the one place they are defined; the Studio renders a row per phase, so a name that drifts is a
+ * silently missing row rather than a failure.
+ */
+export declare const RUN_PHASES: readonly ["observe", "validate", "resolve", "write-elements", "write-edges", "embed-summaries", "reconcile"];
+/** What the job route answers when it ACCEPTS a run rather than waiting for it. */
+export interface IntegrationRunAccepted {
+    runId: string;
+    providerId: string;
+    integrationInstanceId: string;
+    /** Where to watch it, as the runtime spells it. */
+    progress: string;
+}
+/**
+ * One identity's current or most recent run.
+ *
+ * Deliberately not a run history. The runtime's RunTracker states exactly how narrow that is, and
+ * why a report has to be readable after the run at all.
+ */
+export interface IntegrationRunState {
+    runId: string;
+    providerId: string;
+    integrationInstanceId: string;
+    namespace?: string | null;
+    startedAt: string;
+    finishedAt?: string | null;
+    running: boolean;
+    elapsedMilliseconds: number;
+    /**
+     * Whether this run was PICKED UP after a restart of the runtime rather than started in this
+     * process. It changes what the fields around it mean: `runId` and `startedAt` are the original
+     * ones, so the elapsed figure spans the outage, `completedPhases` already holds what the earlier
+     * attempt got through, and a report's counts cover only the part after the pickup.
+     */
+    resumed?: boolean;
+    /** The phase now, or null once the run has ended. */
+    phase?: string | null;
+    /** How far through the current phase, where it counts. Zero when it does not. */
+    phaseDone: number;
+    phaseTotal: number;
+    completedPhases: string[];
+    /** The phase a run STOPPED in when it did not finish cleanly; null for a clean or in-flight run. */
+    stoppedInPhase?: string | null;
+    /** Whether the JOB asked for summary embedding. A fact about the run, not about this component. */
+    embedRequested?: boolean;
+    /**
+     * Whether a stop has been ASKED FOR. It stays true after the run ends, which is what separates the
+     * two outcomes a request can have: with `cancelled` the run stopped because of it, without it the
+     * run had already passed its last safe point and finished normally.
+     */
+    cancelRequested?: boolean;
+    /**
+     * Whether the run ENDED because it was cancelled. A third terminal state beside succeeded and
+     * failed, not a kind of failure.
+     */
+    cancelled?: boolean;
+    /** Present once there is one, for a failed run as well as a successful one. */
+    report?: IntegrationJobReport | null;
+    /** Set only when the run produced no report at all because it threw. */
+    error?: string | null;
+}
 /** Something a run needs a reader to know, with a stable code to grep for and alert on. */
 export interface IntegrationDiagnostic {
     code: string;
@@ -1031,9 +1101,27 @@ export interface IntegrationJobRequest {
     /**
      * 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.
+     *
+     * A setting the descriptor declares `multiple` takes an ORDERED list, and the order is part of
+     * the meaning: a provider that composes its files resolves references across the union and gives
+     * a re-declared path to the file listed first. Any other setting takes the bare object, which is
+     * what the runtime requires there - it refuses a list of one for a setting that takes one file.
+     */
+    files?: Record<string, IntegrationJobFile | IntegrationJobFile[]>;
+    /**
+     * Whether the run should embed one summary per entity, rendered from the provider's
+     * `entitySummaryTemplate`. Default off in the runtime: embedding every element of every run is
+     * cost and noise in equal measure. Needs an embedding provider on the target, and needs the
+     * provider to declare a template - without either, the run still succeeds and simply embeds
+     * nothing, with a diagnostic saying so.
      */
-    files?: Record<string, IntegrationJobFile>;
     embedSummaries?: boolean;
+    /**
+     * Which named embedding the summaries are written to. Omitted means the runtime's own default,
+     * `"default"`, which is also the name the document layer binds its index to - so out of the box
+     * integration summaries and document chunks share one bound index.
+     */
+    embeddingName?: string;
 }
 /** The only account of a job, because the runtime keeps none. */
 export interface IntegrationJobReport {
@@ -1049,6 +1137,12 @@ export interface IntegrationJobReport {
     deletionsDeferred: number;
     issuedMutations: boolean;
     summariesEmbedded?: number;
+    /**
+     * Whether the run was stopped on request at a safe point. A flag of its own rather than an
+     * `errorKind`, because nothing is wrong: the counts above are what really landed, and a cancelled
+     * report never carries an errorKind.
+     */
+    cancelled?: boolean;
     error?: string | null;
     errorKind?: string | null;
     credentialFingerprint?: string | null;

package/dist-lib/types/app/namespaceSignals.d.ts

@@ -0,0 +1,41 @@
+import type { DurabilityREST } from "../api/types";
+/**
+ * What the shell knows about the ACTIVE namespace, read from the one /status cache row every
+ * screen already shares.
+ *
+ * Two shell-level surfaces consume this and are COUPLED, which is why one hook answers both: the
+ * durability banner (AppShell) and the first-run auto-show (FirstRunOverlay). A namespace that is
+ * empty BECAUSE its recovery was truncated must get the warning, not a welcome tour - on the old
+ * Dashboard that was ordering (the notice rendered above the show), and a modal cannot be ordered
+ * behind its own scrim, so the warning suppresses the show instead.
+ */
+export interface NamespaceSignals {
+    /** The durability block for this namespace; null/undefined from a server that does not report. */
+    durability: DurabilityREST | null | undefined;
+    /** True when the block names at least one of the three exceptional states. */
+    durabilityUnhealthy: boolean;
+    /**
+     * Strictly 0 vertices, and KNOWN to be 0. /status answers for a namespace the server catalogs
+     * but did not load with null counts, and reading that as empty would greet an operator with
+     * "get started" over a graph that holds data.
+     *
+     * LIVE: it follows the change feed within ~300ms of any mutation. Anything that must not fire
+     * mid-operation has to latch it rather than derive from it - a sample load is a tabula rasa
+     * followed by an import, so this is briefly true in the middle of one.
+     */
+    empty: boolean;
+    /** Non-zero vertex count, i.e. the graph is known to hold data (re-arms the first-run show). */
+    populated: boolean;
+    /**
+     * Whether /status has answered for this namespace at all. `empty` and `populated` are both false
+     * while it has not, which is indistinguishable from a not-loaded namespace without this.
+     */
+    known: boolean;
+    /**
+     * The per-namespace key both the first-run store and the caches use: `<instanceId>/<ns>`, or the
+     * bare instance id on a server that predates namespaces (see boundInstance). Null with no
+     * active instance.
+     */
+    key: string | null;
+}
+export declare function useNamespaceSignals(): NamespaceSignals;

package/dist-lib/types/app/nav.d.ts

@@ -13,11 +13,6 @@ export declare const NAV: readonly [{
     readonly label: "Connect";
     readonly icon: "◉";
     readonly scoped: false;
-}, {
-    readonly leaf: "dashboard";
-    readonly label: "Dashboard";
-    readonly icon: "▦";
-    readonly scoped: true;
 }, {
     readonly leaf: "samples";
     readonly label: "Samples";
@@ -44,15 +39,10 @@ export declare const NAV: readonly [{
     readonly icon: "⌗";
     readonly scoped: true;
 }, {
-    readonly leaf: "path";
-    readonly label: "Path";
+    readonly leaf: "traverse";
+    readonly label: "Traverse";
     readonly icon: "↝";
     readonly scoped: true;
-}, {
-    readonly leaf: "subgraphs";
-    readonly label: "Subgraph";
-    readonly icon: "◫";
-    readonly scoped: true;
 }, {
     readonly leaf: "analytics";
     readonly label: "Analytics";