@burdenoff/fluidgrids-fe-sdk 2026.1111.16 → 2026.1111.17

package/dist/{ai-usage-D5p7ZeRR.js → ai-usage-glCwHyQz.js}

@@ -1,5 +1,5 @@
 "use client";
-import { HC as OptimisationDismissReason, UC as OptimisationKind } from "./graphql-types-XcDLtFwU.js";
+import { HC as OptimisationDismissReason, UC as OptimisationKind } from "./graphql-types-CDKVWH2R.js";
 
 // src/modules/observability/optimisation.ts
 /** The look-back window the detectors use when the evidence does not say. */

package/dist/api-BrCHB5oA.js

@@ -0,0 +1,224 @@
+"use client";
+import { d as readTyped, f as writeTyped } from "./shared-CMfn30xT.js";
+import { C as CompleteActivityByIdDocument, E as CreateActivityPauseRuleDocument, Fn as StartBatchExportDocument, In as StartBatchOperationDocument, It as PauseActivityDocument, J as DeleteWorkflowSearchAttributeDocument, Jn as TriggerWorkflowScheduleDocument, Kt as QueryWorkflowRunDocument, Ln as StartBatchTerminateDocument, N as CreateWorkflowSearchAttributeDocument, P as CreateWorkflowSignalTokenDocument, Rt as PauseWorkflowScheduleDocument, S as CodecServerSettingsDocument, Sr as WorkflowBatchOperationsDocument, V as DeleteActivityPauseRuleDocument, Xn as UnpauseActivityDocument, Xr as WorkflowRunHistoryArchiveDocument, Zn as UnpauseWorkflowScheduleDocument, _ as CancelBatchOperationDocument, br as WorkflowBatchOperationDocument, ci as WorkflowSearchAttributesDocument, di as WorkflowSignalTokensDocument, dr as UpsertWorkflowRunSearchAttributesDocument, er as UpdateActivityOptionsDocument, f as BackfillWorkflowScheduleDocument, ft as FailActivityByIdDocument, gr as WorkflowActivityPauseRulesDocument, ii as WorkflowScheduleDescribeDocument, in as ResetWorkflowRunToLastCleanTaskDocument, ln as RevokeWorkflowSignalTokenDocument, lr as UpdateWorkflowRunDocument, nn as ResetActivityDocument, nr as UpdateCodecServerSettingsDocument, pn as RunControlFieldsDocument, rn as ResetWorkflowRunDocument, ti as WorkflowRunUpdateDocument, tr as UpdateArchiveSettingsDocument, u as ArchiveSettingsDocument, wr as WorkflowCodeBundleSdkDocument } from "./graphql-operation-types-kX-MMjgW.js";
+
+// src/modules/run-control/api.ts
+/**
+* Phase C run control (BOFF-9906): the reads and writes the run page, the
+* Runs list, Settings and the builder's schedule panel send. Each is a plain
+* network call through the shared FluidGrids client; the callers send them
+* only while the matching Phase C flag is on (usePhaseCFlags), so with every
+* flag off none of these operations is ever sent.
+*/
+/**
+* A JSON scalar argument. Codegen types every JSON scalar as an object
+* record, but the service takes any JSON value (a string, a number, an
+* array); the value is sent as is, so this is the one place the generated
+* record type is widened.
+*/
+function jsonArg(value) {
+	if (value === void 0) return null;
+	return value;
+}
+async function fetchRunControlFields(runId) {
+	return (await readTyped(RunControlFieldsDocument, { id: runId })).workflowRun ?? null;
+}
+async function fetchRunHistoryArchive(runId) {
+	return (await readTyped(WorkflowRunHistoryArchiveDocument, { runId })).workflowRunHistory;
+}
+async function queryRun(input) {
+	return (await readTyped(QueryWorkflowRunDocument, {
+		runId: input.runId,
+		name: input.name,
+		args: jsonArg(input.args),
+		rejectCondition: input.rejectCondition ?? null
+	})).queryWorkflowRun;
+}
+async function sendRunUpdate(input) {
+	return (await writeTyped(UpdateWorkflowRunDocument, {
+		runId: input.runId,
+		name: input.name,
+		args: jsonArg(input.args),
+		updateId: input.updateId,
+		waitFor: input.waitFor,
+		timeoutMs: input.timeoutMs ?? null
+	})).updateWorkflowRun;
+}
+async function fetchRunUpdate(runId, updateId) {
+	return (await readTyped(WorkflowRunUpdateDocument, {
+		runId,
+		updateId
+	})).workflowRunUpdate;
+}
+async function pauseActivities(input) {
+	await writeTyped(PauseActivityDocument, input);
+}
+async function unpauseActivities(input) {
+	await writeTyped(UnpauseActivityDocument, {
+		runId: input.runId,
+		selector: input.selector,
+		resetAttempts: input.resetAttempts ?? false,
+		resetHeartbeat: input.resetHeartbeat ?? false
+	});
+}
+async function resetActivities(input) {
+	await writeTyped(ResetActivityDocument, {
+		runId: input.runId,
+		selector: input.selector,
+		resetHeartbeat: input.resetHeartbeat ?? false
+	});
+}
+async function updateActivityOptions(input) {
+	await writeTyped(UpdateActivityOptionsDocument, input);
+}
+async function completeActivityById(input) {
+	return (await writeTyped(CompleteActivityByIdDocument, {
+		runId: input.runId,
+		activityId: input.activityId,
+		result: jsonArg(input.result)
+	})).completeActivityById;
+}
+async function failActivityById(input) {
+	return (await writeTyped(FailActivityByIdDocument, input)).failActivityById;
+}
+/** The run the reset forked (the original is terminated with RESET). */
+async function resetRun(input) {
+	return (await writeTyped(ResetWorkflowRunDocument, {
+		runId: input.runId,
+		to: input.to,
+		reason: input.reason?.trim() || null,
+		reapplySignals: input.reapplySignals ?? true,
+		reapplyUpdates: input.reapplyUpdates ?? true
+	})).resetWorkflowRun;
+}
+async function resetRunToLastCleanTask(input) {
+	return (await writeTyped(ResetWorkflowRunToLastCleanTaskDocument, {
+		runId: input.runId,
+		reason: input.reason?.trim() || null
+	})).resetWorkflowRunToLastCleanTask;
+}
+async function fetchSignalTokens(runId) {
+	return (await readTyped(WorkflowSignalTokensDocument, { runId })).workflowSignalTokens;
+}
+async function createSignalToken(input) {
+	return (await writeTyped(CreateWorkflowSignalTokenDocument, { input })).createWorkflowSignalToken;
+}
+async function revokeSignalToken(id) {
+	return (await writeTyped(RevokeWorkflowSignalTokenDocument, { id })).revokeWorkflowSignalToken;
+}
+async function fetchSearchAttributes() {
+	return (await readTyped(WorkflowSearchAttributesDocument, {})).workflowSearchAttributes;
+}
+async function createSearchAttribute(input) {
+	return (await writeTyped(CreateWorkflowSearchAttributeDocument, { input: {
+		name: input.name.trim(),
+		type: input.type,
+		description: input.description?.trim() || null
+	} })).createWorkflowSearchAttribute;
+}
+async function deleteSearchAttribute(id) {
+	return (await writeTyped(DeleteWorkflowSearchAttributeDocument, { id })).deleteWorkflowSearchAttribute;
+}
+async function upsertRunSearchAttributes(runId, attributes) {
+	return (await writeTyped(UpsertWorkflowRunSearchAttributesDocument, {
+		runId,
+		attributes
+	})).upsertWorkflowRunSearchAttributes.searchAttributes;
+}
+async function fetchPauseRules() {
+	return (await readTyped(WorkflowActivityPauseRulesDocument, {})).workflowActivityPauseRules;
+}
+async function createPauseRule(input) {
+	return (await writeTyped(CreateActivityPauseRuleDocument, { input })).createActivityPauseRule;
+}
+async function deletePauseRule(id) {
+	return (await writeTyped(DeleteActivityPauseRuleDocument, { id })).deleteActivityPauseRule;
+}
+async function fetchCodecServerSettings() {
+	return (await readTyped(CodecServerSettingsDocument, {})).workflowExecutionSettings ?? {
+		__typename: "WorkflowExecutionSettings",
+		codecServerUrl: null,
+		codecServerIncludeCredentials: false
+	};
+}
+async function saveCodecServerSettings(input) {
+	return (await writeTyped(UpdateCodecServerSettingsDocument, input)).updateWorkflowExecutionSettings;
+}
+async function fetchArchiveSettings() {
+	return (await readTyped(ArchiveSettingsDocument, {})).workflowExecutionSettings?.archive ?? null;
+}
+async function saveArchiveSettings(archive) {
+	return (await writeTyped(UpdateArchiveSettingsDocument, {
+		archive,
+		clearArchive: null
+	})).updateWorkflowExecutionSettings.archive ?? null;
+}
+async function clearArchiveSettings() {
+	await writeTyped(UpdateArchiveSettingsDocument, {
+		archive: null,
+		clearArchive: true
+	});
+}
+async function startBatchOperation(input) {
+	return (await writeTyped(StartBatchOperationDocument, { input })).startBatchOperation;
+}
+async function startBatchTerminate(input) {
+	return (await writeTyped(StartBatchTerminateDocument, { input })).startBatchTerminate;
+}
+async function startBatchExport(input) {
+	return (await writeTyped(StartBatchExportDocument, { input })).startBatchExport;
+}
+async function cancelBatchOperation(id) {
+	return (await writeTyped(CancelBatchOperationDocument, { id })).cancelBatchOperation;
+}
+async function fetchBatchOperation(id) {
+	return (await readTyped(WorkflowBatchOperationDocument, { id })).workflowBatchOperation;
+}
+async function fetchBatchOperations(input) {
+	const page = (await readTyped(WorkflowBatchOperationsDocument, {
+		status: input.status ?? null,
+		first: input.first ?? 20,
+		after: input.after ?? null
+	})).workflowBatchOperations;
+	return {
+		items: page.items,
+		nextCursor: page.nextCursor ?? null
+	};
+}
+async function describeSchedule(workflowKey, triggerNodeId) {
+	return (await readTyped(WorkflowScheduleDescribeDocument, {
+		workflowKey,
+		triggerNodeId
+	})).workflowScheduleDescribe;
+}
+async function triggerSchedule(input) {
+	return (await writeTyped(TriggerWorkflowScheduleDocument, {
+		workflowKey: input.workflowKey,
+		triggerNodeId: input.triggerNodeId,
+		overlapPolicy: input.overlapPolicy ?? null
+	})).triggerWorkflowSchedule;
+}
+async function backfillSchedule(input) {
+	return (await writeTyped(BackfillWorkflowScheduleDocument, {
+		...input,
+		overlapPolicy: input.overlapPolicy ?? null
+	})).backfillWorkflowSchedule;
+}
+async function pauseSchedule(input) {
+	return (await writeTyped(PauseWorkflowScheduleDocument, {
+		workflowKey: input.workflowKey,
+		triggerNodeId: input.triggerNodeId,
+		note: input.note?.trim() || null
+	})).pauseWorkflowSchedule;
+}
+async function unpauseSchedule(input) {
+	return (await writeTyped(UnpauseWorkflowScheduleDocument, input)).unpauseWorkflowSchedule;
+}
+async function fetchCodeBundleSdk(workflowKey, version) {
+	return (await readTyped(WorkflowCodeBundleSdkDocument, {
+		workflowKey,
+		version
+	})).workflowCodeBundle ?? null;
+}
+
+export { revokeSignalToken as A, updateActivityOptions as B, jsonArg as C, resetActivities as D, queryRun as E, startBatchOperation as F, startBatchTerminate as I, triggerSchedule as L, saveCodecServerSettings as M, sendRunUpdate as N, resetRun as O, startBatchExport as P, unpauseActivities as R, fetchSignalTokens as S, pauseSchedule as T, upsertRunSearchAttributes as V, fetchPauseRules as _, createPauseRule as a, fetchRunUpdate as b, deletePauseRule as c, failActivityById as d, fetchArchiveSettings as f, fetchCodecServerSettings as g, fetchCodeBundleSdk as h, completeActivityById as i, saveArchiveSettings as j, resetRunToLastCleanTask as k, deleteSearchAttribute as l, fetchBatchOperations as m, cancelBatchOperation as n, createSearchAttribute as o, fetchBatchOperation as p, clearArchiveSettings as r, createSignalToken as s, backfillSchedule as t, describeSchedule as u, fetchRunControlFields as v, pauseActivities as w, fetchSearchAttributes as x, fetchRunHistoryArchive as y, unpauseSchedule as z };

package/dist/api-C8e0iV-Q.js

@@ -0,0 +1,55 @@
+"use client";
+import { d as readTyped, f as writeTyped } from "./shared-CMfn30xT.js";
+import { Ci as WorkflowWorkersDocument, H as DeleteTaskQueueDocument, O as CreateTaskQueueDocument, U as DeleteWorkerTokenDocument, Un as TaskQueueStatsDocument, Wn as TaskQueuesDocument, ar as UpdateTaskQueueDocument, k as CreateWorkerTokenDocument, kn as SetWorkerTokenConnectionAllowlistDocument, mr as WorkerTokensDocument, un as RotateWorkerTokenDocument } from "./graphql-operation-types-kX-MMjgW.js";
+
+// src/modules/task-queues/api.ts
+/**
+* Task queues and self-hosted workers (BOFF-9906, spec code-first 04 §8 and
+* 08 §3): the queue CRUD and stats of wspace-workflow-svc, and the workers
+* and worker tokens of wspace-sandbox-svc, both through the workspace
+* gateway. Sent only while fluidgrids.self-hosted-workers is on.
+*/
+async function fetchTaskQueues() {
+	return (await readTyped(TaskQueuesDocument, {})).taskQueues;
+}
+async function fetchTaskQueueStats(name, environment) {
+	return (await readTyped(TaskQueueStatsDocument, {
+		name,
+		environment: environment ?? null
+	})).taskQueueStats;
+}
+async function createTaskQueue(input) {
+	return (await writeTyped(CreateTaskQueueDocument, { input })).createTaskQueue;
+}
+async function updateTaskQueue(id, input) {
+	return (await writeTyped(UpdateTaskQueueDocument, {
+		id,
+		input
+	})).updateTaskQueue;
+}
+async function deleteTaskQueue(id) {
+	return (await writeTyped(DeleteTaskQueueDocument, { id })).deleteTaskQueue;
+}
+async function fetchWorkflowWorkers(filter) {
+	return (await readTyped(WorkflowWorkersDocument, { filter: filter ?? null })).workflowWorkers;
+}
+async function fetchWorkerTokens() {
+	return (await readTyped(WorkerTokensDocument, {})).workerTokens;
+}
+async function createWorkerToken(input) {
+	return (await writeTyped(CreateWorkerTokenDocument, input)).createWorkerToken;
+}
+async function rotateWorkerToken(id) {
+	return (await writeTyped(RotateWorkerTokenDocument, { id })).rotateWorkerToken;
+}
+async function deleteWorkerToken(id) {
+	return (await writeTyped(DeleteWorkerTokenDocument, { id })).deleteWorkerToken;
+}
+async function setWorkerTokenConnectionAllowlist(id, names) {
+	return (await writeTyped(SetWorkerTokenConnectionAllowlistDocument, {
+		id,
+		names
+	})).setWorkerTokenConnectionAllowlist;
+}
+
+export { fetchTaskQueueStats as a, fetchWorkflowWorkers as c, updateTaskQueue as d, deleteWorkerToken as i, rotateWorkerToken as l, createWorkerToken as n, fetchTaskQueues as o, deleteTaskQueue as r, fetchWorkerTokens as s, createTaskQueue as t, setWorkerTokenConnectionAllowlist as u };

package/dist/button-DG7y_FVJ.js

@@ -0,0 +1,48 @@
+"use client";
+import { t as cn } from "./cn-QqidFIgr.js";
+import "react";
+import { jsx } from "react/jsx-runtime";
+import { Slot } from "@radix-ui/react-slot";
+import { cva } from "class-variance-authority";
+
+// src/ui/button.tsx
+const buttonVariants = cva("inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*=\"size-\"])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]", {
+	variants: {
+		variant: {
+			default: "bg-primary text-primary-foreground hover:bg-primary/90",
+			destructive: "bg-action-danger-bg text-action-danger-text hover:bg-action-danger-bgHover",
+			outline: "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground",
+			secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+			ghost: "hover:bg-accent hover:text-accent-foreground",
+			link: "text-primary underline-offset-4 hover:underline"
+		},
+		size: {
+			default: "h-9 px-4 py-2 has-[>svg]:px-3",
+			xs: "h-7 rounded-md gap-1 px-2 text-xs has-[>svg]:px-1.5",
+			sm: "h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",
+			lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
+			icon: "size-9",
+			"icon-sm": "size-8",
+			"icon-lg": "size-10"
+		}
+	},
+	defaultVariants: {
+		variant: "default",
+		size: "default"
+	}
+});
+function Button({ className, variant = "default", size = "default", asChild = false, ...props }) {
+	return /* @__PURE__ */ jsx(asChild ? Slot : "button", {
+		"data-slot": "button",
+		"data-variant": variant,
+		"data-size": size,
+		className: cn(buttonVariants({
+			variant,
+			size,
+			className
+		})),
+		...props
+	});
+}
+
+export { buttonVariants as n, Button as t };

package/dist/{canvasNoteTools-D3zUdEeg.js → canvasNoteTools-CQIc7Oxg.js}

@@ -1,8 +1,8 @@
 "use client";
 import { n as useAgentMarksStore, r as toPlainText } from "./marksStore-DGCXjTmZ.js";
-import { J as paramsFromOperation, K as nodeTitle, Y as selectedOperationOf } from "./FluidGridsProvider-DmvFADFa.js";
+import { J as paramsFromOperation, K as nodeTitle, Y as selectedOperationOf } from "./FluidGridsProvider-dvZSNtSW.js";
 import { H as useFlowStore } from "./node-operation-selection--oy-yEq_.js";
-import { g as notesKeyOf } from "./flow-builder-DEzT8TQu.js";
+import { g as notesKeyOf } from "./flow-builder-y2Y1iG4Y.js";
 import { AgentToolError, defineAgentTool } from "@burdenoff/fe-libs/shared/agent-tools";
 import { z } from "zod";