@burdenoff/microfe-bigconsole 2026.1101.1 → 2026.1103.1

package/dist/bigconsole/utils/dataSinkSetup.d.ts

@@ -0,0 +1,15 @@
+import { DataSink, DataSinkSetupState } from '../types';
+/** What is still missing before a data sink counts as set up. */
+export type DataSinkSetupGap = 'data' | 'ttl';
+type SetupInput = Pick<DataSink, 'setupState' | 'ttl' | 'sizeBytes' | 'fluidGridsWorkflowId'>;
+export declare function resolveSetupState(sink: SetupInput): DataSinkSetupState;
+/**
+ * The missing pieces behind an incomplete setup; empty once the sink is set up.
+ * Also empty while its workflow is running: the workflow is producing the data,
+ * so "no data yet" would send the user to fill in what is already on its way.
+ */
+export declare function getSetupGaps(sink: SetupInput): DataSinkSetupGap[];
+type Translate = (key: string, fallback: string, params?: Record<string, string | number>) => string;
+/** "Setup incomplete: no data yet, no cache TTL set", or the bare label when no gap is known. */
+export declare function describeSetupGaps(gaps: readonly DataSinkSetupGap[], t: Translate): string;
+export {};

package/dist/bigconsole/utils/dataSinkSetup.js

@@ -0,0 +1,23 @@
+import { hasDataSinkPayload as e } from "./dataSinkPayload.js";
+//#region src/bigconsole/utils/dataSinkSetup.ts
+var t = [
+	"workflow_pending",
+	"workflow_running",
+	"workflow_completed",
+	"configuration_pending",
+	"completed"
+], n = (e) => typeof e.ttl == "number" && e.ttl > 0;
+function r(r) {
+	return t.includes(r.setupState) ? r.setupState : e(r) ? n(r) ? "completed" : "configuration_pending" : r.fluidGridsWorkflowId ? "workflow_running" : "workflow_pending";
+}
+function i(t) {
+	let i = r(t);
+	if (i === "completed" || i === "workflow_running") return [];
+	let a = [];
+	return e(t) || a.push("data"), n(t) || a.push("ttl"), a;
+}
+function a(e, t) {
+	return e.length === 0 ? t("bigconsole.dataSinks.setup.incomplete", "Setup incomplete") : t("bigconsole.dataSinks.setup.incompleteWithGaps", "Setup incomplete: {{gaps}}", { gaps: e.map((e) => e === "data" ? t("bigconsole.dataSinks.setup.gapData", "no data yet") : t("bigconsole.dataSinks.setup.gapTtl", "no cache TTL set")).join(", ") });
+}
+//#endregion
+export { a as describeSetupGaps, i as getSetupGaps, r as resolveSetupState };

package/dist/bigconsole/utils/pipelineExecutionTimeline.d.ts

@@ -0,0 +1,47 @@
+import { PipelineExecution, PipelineExecutionStatus, PipelineStage, StageExecutionStatus } from '../types';
+/** Visual tone shared by run and stage statuses. */
+export type ExecutionTone = 'success' | 'danger' | 'warning' | 'info' | 'neutral';
+export interface StageTimelineRow {
+    id: string;
+    /** 1-based position in the run. */
+    step: number;
+    name: string;
+    status: StageExecutionStatus;
+    tone: ExecutionTone;
+    durationMs: number | null;
+    /** Bar start as a percentage of the run's summed stage time (0–100). */
+    offsetPercent: number;
+    /** Bar width as a percentage of the run's summed stage time (0–100). */
+    widthPercent: number;
+    inputKey: string | null;
+    outputKey: string | null;
+    error: string | null;
+    output: unknown;
+    hasOutput: boolean;
+}
+export interface StageTimeline {
+    rows: StageTimelineRow[];
+    /** Sum of recorded stage durations, used as the bar scale. */
+    totalStageMs: number;
+    counts: Record<'success' | 'skipped' | 'failed' | 'other', number>;
+}
+export declare function runStatusTone(status: PipelineExecutionStatus): ExecutionTone;
+export declare function stageStatusTone(status: StageExecutionStatus): ExecutionTone;
+/** Runs that belong to `pipelineId`, newest first (stable for equal timestamps). */
+export declare function orderExecutionsForPipeline(executions: readonly PipelineExecution[], pipelineId: string | undefined): PipelineExecution[];
+/**
+ * Keep the user's selected run if it is still in the list, otherwise select
+ * the newest one (or nothing when the pipeline has no runs).
+ */
+export declare function pickSelectedExecution(ordered: readonly PipelineExecution[], selectedId: string | null | undefined): PipelineExecution | null;
+/** Duration of a run: the recorded total, else completedAt − startedAt, else null. */
+export declare function runDurationMs(execution: PipelineExecution): number | null;
+/** Human duration: "—", "850 ms", "1.25 s", "2 m 05 s". */
+export declare function formatDurationMs(ms: number | null | undefined): string;
+/**
+ * Who started the run, from the viewer's perspective. Returns `null` for the
+ * viewer themselves so the caller can render a translated "You".
+ */
+export declare function triggeredByLabel(executedBy: string, currentActorId: string | null | undefined): string | null;
+/** Build the waterfall rows for one run against the pipeline's current stages. */
+export declare function buildStageTimeline(execution: PipelineExecution, stages: readonly PipelineStage[] | null | undefined): StageTimeline;

package/dist/bigconsole/utils/pipelineExecutionTimeline.js

@@ -0,0 +1,87 @@
+//#region src/bigconsole/utils/pipelineExecutionTimeline.ts
+var e = {
+	completed: "success",
+	failed: "danger",
+	running: "info",
+	pending: "neutral"
+}, t = {
+	success: "success",
+	failed: "danger",
+	skipped: "warning",
+	running: "info",
+	pending: "neutral"
+}, n = 2;
+function r(t) {
+	return e[t] ?? "neutral";
+}
+function i(e) {
+	return t[e] ?? "neutral";
+}
+function a(e) {
+	let t = Date.parse(e.startedAt ?? e.createdAt);
+	return Number.isNaN(t) ? 0 : t;
+}
+function o(e, t) {
+	return t ? e.map((e, t) => ({
+		execution: e,
+		index: t
+	})).filter(({ execution: e }) => e.pipelineId === t).sort((e, t) => a(t.execution) - a(e.execution) || e.index - t.index).map(({ execution: e }) => e) : [];
+}
+function s(e, t) {
+	if (t) {
+		let n = e.find((e) => e.id === t);
+		if (n) return n;
+	}
+	return e[0] ?? null;
+}
+function c(e) {
+	if (e.totalExecutionTimeMs != null) return e.totalExecutionTimeMs;
+	if (!e.startedAt || !e.completedAt) return null;
+	let t = Date.parse(e.completedAt) - Date.parse(e.startedAt);
+	return Number.isFinite(t) && t >= 0 ? t : null;
+}
+function l(e) {
+	if (e == null || !Number.isFinite(e) || e < 0) return "—";
+	if (e < 1e3) return `${Math.round(e)} ms`;
+	if (e < 6e4) return `${(e / 1e3).toFixed(2).replace(/\.?0+$/, "")} s`;
+	let t = Math.floor(e / 6e4), n = Math.round(e % 6e4 / 1e3);
+	return `${t} m ${String(n).padStart(2, "0")} s`;
+}
+function u(e, t) {
+	return t && e === t ? null : e.length > 12 ? `${e.slice(0, 8)}…` : e;
+}
+function d(e, t, n) {
+	return e.stageName || t?.parserName || `Stage ${n}`;
+}
+function f(e, t) {
+	let r = new Map((t ?? []).map((e) => [e.id, e])), a = e.stageResults ?? [], o = a.map((e) => e.executionTimeMs != null && Number.isFinite(e.executionTimeMs) && e.executionTimeMs > 0 ? e.executionTimeMs : 0), s = o.reduce((e, t) => e + t, 0), c = {
+		success: 0,
+		skipped: 0,
+		failed: 0,
+		other: 0
+	}, l = 0;
+	return {
+		rows: a.map((e, t) => {
+			let u = r.get(e.stageId), f = o[t] ?? 0, p = s > 0 ? l / s * 100 : t / a.length * 100, m = s > 0 ? f / s * 100 : 100 / a.length, h = Math.min(100 - Math.min(p, 100 - n), Math.max(m, n));
+			return l += f, e.status === "success" || e.status === "skipped" || e.status === "failed" ? c[e.status] += 1 : c.other += 1, {
+				id: e.id,
+				step: t + 1,
+				name: d(e, u, t + 1),
+				status: e.status,
+				tone: i(e.status),
+				durationMs: e.executionTimeMs ?? null,
+				offsetPercent: Math.min(p, 100 - n),
+				widthPercent: h,
+				inputKey: u?.inputKey ?? null,
+				outputKey: u?.outputKey ?? null,
+				error: e.error,
+				output: e.output,
+				hasOutput: e.output !== null && e.output !== void 0
+			};
+		}),
+		totalStageMs: s,
+		counts: c
+	};
+}
+//#endregion
+export { f as buildStageTimeline, l as formatDurationMs, o as orderExecutionsForPipeline, s as pickSelectedExecution, c as runDurationMs, r as runStatusTone, i as stageStatusTone, u as triggeredByLabel };

package/dist/bigconsole/utils/pipelineStages.d.ts

@@ -0,0 +1,41 @@
+import { ParserType, PipelineStage, StageErrorHandling } from '../types';
+/** Editable stage state held by the pipeline builder. */
+export interface PipelineStageForm {
+    id?: string;
+    parserId: string;
+    parserName: string;
+    parserType: ParserType | null;
+    /** Inline expression stages carry no parser; kept so a save cannot drop it. */
+    expression: string;
+    inputKey: string;
+    outputKey: string;
+    enabled: boolean;
+    onError: StageErrorHandling;
+    /** JSON text; empty means "no fallback". */
+    fallbackValue: string;
+    description: string;
+}
+/** Stage payload accepted by both CreatePipelineStageInput and UpdatePipelineStageInput. */
+export interface PipelineStagePayload {
+    parserId: string;
+    parserName?: string;
+    parserType?: ParserType;
+    expression?: string;
+    inputKey: string;
+    outputKey: string;
+    enabled: boolean;
+    onError: StageErrorHandling;
+    fallbackValue?: unknown;
+    description?: string;
+}
+/** Thrown when a stage's fallback value is not valid JSON. */
+export declare class InvalidFallbackValueError extends Error {
+    readonly stageIndex: number;
+    constructor(stageIndex: number, cause: unknown);
+}
+/** Seed builder form rows from persisted stages, preserving their order. */
+export declare function stagesToForm(stages: readonly PipelineStage[] | null | undefined): PipelineStageForm[];
+/** A stage can run when it has a parser or an inline expression, and both keys. */
+export declare function isStageFormComplete(stage: PipelineStageForm): boolean;
+/** Map builder rows to the stage payload, in display order. */
+export declare function formToStageInputs(stages: readonly PipelineStageForm[]): PipelineStagePayload[];

package/dist/bigconsole/utils/pipelineStages.js

@@ -0,0 +1,49 @@
+//#region src/bigconsole/utils/pipelineStages.ts
+var e = class extends Error {
+	stageIndex;
+	constructor(e, t) {
+		super(`Stage ${e + 1}: the fallback value is not valid JSON (${t instanceof Error ? t.message : String(t)}).`), this.stageIndex = e, this.name = "InvalidFallbackValueError";
+	}
+};
+function t(e) {
+	return [...e ?? []].sort((e, t) => e.position - t.position).map((e) => ({
+		id: e.id,
+		parserId: e.parserId ?? "",
+		parserName: e.parserName ?? "",
+		parserType: e.parserType ?? null,
+		expression: e.expression ?? "",
+		inputKey: e.inputKey,
+		outputKey: e.outputKey,
+		enabled: e.enabled,
+		onError: e.onError,
+		fallbackValue: e.fallbackValue == null ? "" : JSON.stringify(e.fallbackValue),
+		description: e.description ?? ""
+	}));
+}
+function n(e) {
+	return !!((e.parserId || e.expression.trim()) && e.inputKey.trim() && e.outputKey.trim());
+}
+function r(t) {
+	return t.map((t, n) => {
+		let r;
+		if (t.fallbackValue.trim() !== "") try {
+			r = JSON.parse(t.fallbackValue);
+		} catch (t) {
+			throw new e(n, t);
+		}
+		return {
+			parserId: t.parserId,
+			parserName: t.parserName || void 0,
+			parserType: t.parserType ?? void 0,
+			expression: t.expression.trim() ? t.expression : void 0,
+			inputKey: t.inputKey,
+			outputKey: t.outputKey,
+			enabled: t.enabled,
+			onError: t.onError,
+			fallbackValue: r,
+			description: t.description || void 0
+		};
+	});
+}
+//#endregion
+export { e as InvalidFallbackValueError, r as formToStageInputs, n as isStageFormComplete, t as stagesToForm };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/microfe-bigconsole",
-  "version": "2026.1101.1",
+  "version": "2026.1103.1",
   "description": "BigConsole - AI-powered analytics and dashboard platform",
   "type": "module",
   "files": [