@burdenoff/fluidgrids-fe-sdk 2026.1111.16 → 2026.1111.18

package/dist/feature-flags-DM5myWaD.js

@@ -0,0 +1,296 @@
+"use client";
+import { useMemo } from "react";
+import { useOptionalFeatureFlags } from "@burdenoff/fe-libs/shared/feature-flags";
+
+// src/feature-flags/index.ts
+/**
+* FluidGrids feature flags evaluated in the builder.
+*
+* Keys are registered in global-tenant-svc (`DEFAULT_PLATFORM_FLAGS`, category
+* `fluidgrids`, so tenant-svc scopes them to FluidGrids) and toggled per
+* workspace from admin.burdenoff.com. wspace-workflow-svc enforces the same
+* keys with `requireFeatureEnabled`, so hiding a control here only mirrors a
+* server-side gate; it is never the gate itself.
+*
+* The SDK runs inside many app shells and only some of them mount
+* `FeatureFlagProvider`, so it reads the optional flag context rather than
+* `useFeatureFlag`, which throws without one. Each flag falls back to its own
+* default (see `FLUIDGRIDS_FLAG_DEFAULTS`).
+*/
+const FLUIDGRIDS_FLAGS = {
+	/**
+	* Operational kill switch for log stream destinations (webhook, syslog,
+	* Sentry). Defaults on; an admin turning it off hides the Log streaming
+	* settings and the backend rejects destination writes with FEATURE_DISABLED.
+	*/
+	logStreams: "fluidgrids.log-streams",
+	/**
+	* Code-first workflows (BOFF-9902): the builder's Code view, Export as
+	* TypeScript / Python and TypeScript import. A rollout gate, not a kill
+	* switch, so it defaults OFF: the controls stay hidden until tenant-svc
+	* evaluates the flag on for the workspace, including when the shell mounts
+	* no FeatureFlagProvider or the evaluation is still loading.
+	*/
+	codeFirst: "fluidgrids.code-first",
+	/**
+	* Durable functions (BOFF-9905): the Code Workflow and Wait for Signal
+	* nodes, run history, signals and the source editor. A rollout gate like
+	* `codeFirst`, so it defaults OFF and fails closed. The durable nodes are
+	* shown in the palette only while both this flag and `codeFirst` are on.
+	*/
+	durableFunctions: "fluidgrids.durable-functions",
+	/**
+	* Durable-function parity (BOFF-9905, spec code-first 11): workflow ids and
+	* run chains, run metadata, what a run is waiting on, run counts,
+	* completion callbacks, versioning (rollouts, drainage, per-run overrides)
+	* and the history caps. A rollout gate like `durableFunctions`, so it
+	* defaults OFF and fails closed; the parity surfaces show only while this
+	* flag, `durableFunctions` and `codeFirst` are all on.
+	*/
+	durableParity: "fluidgrids.durable-parity",
+	/**
+	* Phase C (BOFF-9906, PLAN-C §2.1): self-hosted task queues, worker tokens,
+	* the task-queue pages and the codec settings. A rollout gate that also
+	* needs `codeFirst` and `durableFunctions`, so it defaults OFF and fails
+	* closed (see {@link resolvePhaseCFlags}).
+	*/
+	selfHostedWorkers: "fluidgrids.self-hosted-workers",
+	/**
+	* Phase C run control: updates and queries, reset, activity pause and
+	* options, pause rules, signal tokens, batch operations and the Signal Run
+	* node. Needs `codeFirst`, plus `durableFunctions` for anything acting on a
+	* durable-function run. Defaults OFF, fails closed.
+	*/
+	runControl: "fluidgrids.run-control",
+	/**
+	* Phase C search attributes: definitions, the runs-list filter, the Set
+	* Search Attributes node. Needs `codeFirst`. Defaults OFF, fails closed.
+	*/
+	searchAttributes: "fluidgrids.search-attributes",
+	/** Phase C run archival: the archive destination settings. Needs `codeFirst`. */
+	runArchival: "fluidgrids.run-archival",
+	/**
+	* Phase C schedule policies: the schedule panel of a Schedule Trigger
+	* (overlap policy, trigger now, backfill, pause with a note). Needs
+	* `codeFirst`. Defaults OFF, fails closed.
+	*/
+	schedulePolicies: "fluidgrids.schedule-policies",
+	/**
+	* Phase C Python durable functions: editing Python sources in the browser
+	* editor. Needs `codeFirst` and `durableFunctions`. Defaults OFF.
+	*/
+	pythonDurableFunctions: "fluidgrids.python-durable-functions",
+	/**
+	* Workflow test suites (BOFF-9960): the builder's Tests panel, saving a run
+	* as a test case and the Assert node in the palette. A rollout gate, so it
+	* defaults OFF and fails closed; wspace-workflow-svc answers every test-suite
+	* field with FEATURE_DISABLED while it is off for the workspace.
+	*/
+	workflowTests: "fluidgrids.workflow-tests",
+	/**
+	* Continuous optimisation (BOFF-9969): the Suggestions panel on Insights
+	* (the per-workspace opt-in, the nightly suggestions, Apply, Dismiss and
+	* Snooze). A rollout gate, so it defaults OFF and fails closed;
+	* wspace-workflow-svc answers every suggestion field with FEATURE_DISABLED
+	* while it is off for the workspace.
+	*/
+	continuousOptimisation: "fluidgrids.continuous-optimisation"
+};
+/**
+* The value each flag takes when it cannot be evaluated (no provider, still
+* loading, or not returned). Kill switches default on so an outage of the
+* flag service never removes a shipped feature; rollout gates default off so
+* it never exposes an unreleased one.
+*/
+const FLUIDGRIDS_FLAG_DEFAULTS = {
+	[FLUIDGRIDS_FLAGS.logStreams]: true,
+	[FLUIDGRIDS_FLAGS.codeFirst]: false,
+	[FLUIDGRIDS_FLAGS.durableFunctions]: false,
+	[FLUIDGRIDS_FLAGS.durableParity]: false,
+	[FLUIDGRIDS_FLAGS.selfHostedWorkers]: false,
+	[FLUIDGRIDS_FLAGS.runControl]: false,
+	[FLUIDGRIDS_FLAGS.searchAttributes]: false,
+	[FLUIDGRIDS_FLAGS.runArchival]: false,
+	[FLUIDGRIDS_FLAGS.schedulePolicies]: false,
+	[FLUIDGRIDS_FLAGS.pythonDurableFunctions]: false,
+	[FLUIDGRIDS_FLAGS.workflowTests]: false,
+	[FLUIDGRIDS_FLAGS.continuousOptimisation]: false
+};
+/**
+* Each evaluations map the provider has published as settled (loaded, not
+* fetching), with the workspace it was settled for. The provider replaces the
+* map on every successful fetch and keeps it while a refetch is in flight, so
+* the map itself identifies one completed evaluation.
+*/
+const settledEvaluations = /* @__PURE__ */ new WeakMap();
+/**
+* Whether the context's evaluations can be read for the active workspace.
+*
+* Settled: yes, unless the map was settled for another workspace (the
+* provider keeps the old map for the first render after a workspace switch).
+* Fetching: only when this map was already seen settled for this same
+* workspace, i.e. a background refetch (`refreshInterval`, every 5 minutes by
+* default) rather than a first load or a workspace switch. The last known
+* evaluation then stays in force until the refetch settles, instead of the
+* rollout gates blinking off for its duration.
+*/
+function evaluationsUsable(context) {
+	const { evaluations } = context;
+	if (!evaluations) return !context.isLoading;
+	const workspace = context.workspaceId ?? null;
+	const settledFor = settledEvaluations.get(evaluations);
+	if (context.isLoading) return settledFor !== void 0 && settledFor === workspace;
+	if (settledFor === void 0) {
+		settledEvaluations.set(evaluations, workspace);
+		return true;
+	}
+	return settledFor === workspace;
+}
+/**
+* Resolves one FluidGrids flag from the optional flag context (exported for
+* tests).
+*
+* A kill switch (default on) keeps the resolution it has always had: the
+* evaluated value, else on, and on while the flags are loading.
+* A rollout gate (default off) fails closed, the way wspace-workflow-svc
+* resolves it: it is on only when the flags have loaded without a fetch error
+* and tenant-svc returned an evaluation for it that carries no `errorCode` and
+* the boolean value `true`. No provider, a first load or workspace switch
+* still in flight, a failed fetch, a missing evaluation or an evaluation error
+* all leave it off. A background refetch of the same workspace keeps the last
+* settled evaluation (see `evaluationsUsable`).
+*/
+function resolveFluidGridsFlag(context, flag) {
+	const fallback = FLUIDGRIDS_FLAG_DEFAULTS[flag];
+	if (!context) return fallback;
+	if (fallback) {
+		if (context.isLoading) return fallback;
+		const evaluation = context.getEvaluation(flag);
+		return evaluation ? Boolean(evaluation.value) : fallback;
+	}
+	if (context.error || !evaluationsUsable(context)) return false;
+	const evaluation = context.getEvaluation(flag);
+	return !!evaluation && !evaluation.errorCode && evaluation.value === true;
+}
+/** Whether a FluidGrids flag is on for the active workspace. */
+function useFluidGridsFlag(flag) {
+	const context = useOptionalFeatureFlags();
+	return useMemo(() => resolveFluidGridsFlag(context, flag), [context, flag]);
+}
+/**
+* Whether the durable-function nodes (`internal:code-workflow`,
+* `internal:wait-for-signal`) may appear in the builder palette: only while
+* both the code-first and the durable-functions rollout gates are on. Either
+* gate off, unevaluated or failing hides them.
+*/
+function useDurableFunctionNodesEnabled() {
+	const context = useOptionalFeatureFlags();
+	return useMemo(() => resolveFluidGridsFlag(context, FLUIDGRIDS_FLAGS.codeFirst) && resolveFluidGridsFlag(context, FLUIDGRIDS_FLAGS.durableFunctions), [context]);
+}
+/**
+* Whether the durable-function parity surfaces (BOFF-9905) are shown: only
+* while the code-first, durable-functions and durable-parity rollout gates
+* are all on, the same three flags wspace-workflow-svc checks before it
+* answers a parity field. Any of them off, unevaluated or failing hides them,
+* and the pages then send exactly the requests they sent before.
+*/
+function resolveDurableParity(context) {
+	return resolveFluidGridsFlag(context, FLUIDGRIDS_FLAGS.codeFirst) && resolveFluidGridsFlag(context, FLUIDGRIDS_FLAGS.durableFunctions) && resolveFluidGridsFlag(context, FLUIDGRIDS_FLAGS.durableParity);
+}
+/** {@link resolveDurableParity} for the active workspace. */
+function useDurableParityEnabled() {
+	const context = useOptionalFeatureFlags();
+	return useMemo(() => resolveDurableParity(context), [context]);
+}
+/** Every Phase C gate off: what a shell without the flags sees. */
+const PHASE_C_FLAGS_OFF = Object.freeze({
+	runControl: false,
+	runControlDurable: false,
+	selfHostedWorkers: false,
+	searchAttributes: false,
+	runArchival: false,
+	schedulePolicies: false,
+	pythonDurableFunctions: false
+});
+/** Resolves the Phase C gates from the optional flag context (exported for tests). */
+function resolvePhaseCFlags(context) {
+	const flag = (key) => resolveFluidGridsFlag(context, key);
+	if (!flag(FLUIDGRIDS_FLAGS.codeFirst)) return { ...PHASE_C_FLAGS_OFF };
+	const durable = flag(FLUIDGRIDS_FLAGS.durableFunctions);
+	const runControl = flag(FLUIDGRIDS_FLAGS.runControl);
+	return {
+		runControl,
+		runControlDurable: runControl && durable,
+		selfHostedWorkers: durable && flag(FLUIDGRIDS_FLAGS.selfHostedWorkers),
+		searchAttributes: flag(FLUIDGRIDS_FLAGS.searchAttributes),
+		runArchival: flag(FLUIDGRIDS_FLAGS.runArchival),
+		schedulePolicies: flag(FLUIDGRIDS_FLAGS.schedulePolicies),
+		pythonDurableFunctions: durable && flag(FLUIDGRIDS_FLAGS.pythonDurableFunctions)
+	};
+}
+/** {@link resolvePhaseCFlags} for the active workspace. */
+function usePhaseCFlags() {
+	const context = useOptionalFeatureFlags();
+	return useMemo(() => resolvePhaseCFlags(context), [context]);
+}
+/**
+* Whether the rollout gates have settled for the active workspace, so that an
+* off gate means "off" rather than "not evaluated yet" (exported for tests).
+*
+* Settled: no provider (the gates stay off for good), a failed fetch (they
+* fail closed), or evaluations that can be read for this workspace (see
+* `evaluationsUsable`, so a background refetch stays settled). Not settled:
+* the provider's first load, or the first render after a workspace switch.
+* A route that redirects away when its gate is off waits for this, so a deep
+* link to a gated page is not bounced during the first load.
+*/
+function resolveFluidGridsFlagsSettled(context) {
+	if (!context) return true;
+	if (context.error) return true;
+	return evaluationsUsable(context);
+}
+/** {@link resolveFluidGridsFlagsSettled} for the active workspace. */
+function useFluidGridsFlagsSettled() {
+	const context = useOptionalFeatureFlags();
+	return useMemo(() => resolveFluidGridsFlagsSettled(context), [context]);
+}
+/** Whether the self-hosted workers surfaces (task queues, worker tokens) show. */
+function useSelfHostedWorkersEnabled() {
+	return usePhaseCFlags().selfHostedWorkers;
+}
+/**
+* Whether the workflow test suites (BOFF-9960) are shown: the Tests panel,
+* "Save as test case" on a run and the Assert node. Fails closed.
+*/
+function useWorkflowTestsEnabled() {
+	return useFluidGridsFlag(FLUIDGRIDS_FLAGS.workflowTests);
+}
+/**
+* Whether the continuous-optimisation Suggestions panel (BOFF-9969) is shown
+* on Insights. Fails closed: with the flag off the page sends none of the
+* optimisation operations.
+*/
+function useContinuousOptimisationEnabled() {
+	return useFluidGridsFlag(FLUIDGRIDS_FLAGS.continuousOptimisation);
+}
+/**
+* The gates the builder palettes apply (durable-function nodes, the two
+* run-control nodes of Phase C and the Assert node of the workflow test
+* suites).
+*/
+function resolvePaletteGates(context) {
+	const phaseC = resolvePhaseCFlags(context);
+	return {
+		durableFunctions: resolveFluidGridsFlag(context, FLUIDGRIDS_FLAGS.codeFirst) && resolveFluidGridsFlag(context, FLUIDGRIDS_FLAGS.durableFunctions),
+		runControl: phaseC.runControl,
+		searchAttributes: phaseC.searchAttributes,
+		workflowTests: resolveFluidGridsFlag(context, FLUIDGRIDS_FLAGS.workflowTests)
+	};
+}
+/** {@link resolvePaletteGates} for the active workspace. */
+function usePaletteGates() {
+	const context = useOptionalFeatureFlags();
+	return useMemo(() => resolvePaletteGates(context), [context]);
+}
+
+export { resolvePhaseCFlags as a, useDurableParityEnabled as c, usePaletteGates as d, usePhaseCFlags as f, resolveFluidGridsFlagsSettled as i, useFluidGridsFlag as l, useWorkflowTestsEnabled as m, FLUIDGRIDS_FLAG_DEFAULTS as n, useContinuousOptimisationEnabled as o, useSelfHostedWorkersEnabled as p, PHASE_C_FLAGS_OFF as r, useDurableFunctionNodesEnabled as s, FLUIDGRIDS_FLAGS as t, useFluidGridsFlagsSettled as u };

package/dist/flags.d.ts

@@ -0,0 +1,3 @@
+
+import { a as PhaseCFlags, c as useContinuousOptimisationEnabled, d as useFluidGridsFlag, f as useFluidGridsFlagsSettled, g as useWorkflowTestsEnabled, h as useSelfHostedWorkersEnabled, l as useDurableFunctionNodesEnabled, m as usePhaseCFlags, n as FLUIDGRIDS_FLAG_DEFAULTS, r as FluidGridsFlagKey, t as FLUIDGRIDS_FLAGS } from "./index-BcdtKBM-.js";
+export { FLUIDGRIDS_FLAGS, FLUIDGRIDS_FLAG_DEFAULTS, type FluidGridsFlagKey, type PhaseCFlags, useContinuousOptimisationEnabled, useDurableFunctionNodesEnabled, useFluidGridsFlag, useFluidGridsFlagsSettled, usePhaseCFlags, useSelfHostedWorkersEnabled, useWorkflowTestsEnabled };

package/dist/flags.js

@@ -0,0 +1,4 @@
+"use client";
+import { f as usePhaseCFlags, l as useFluidGridsFlag, m as useWorkflowTestsEnabled, n as FLUIDGRIDS_FLAG_DEFAULTS, o as useContinuousOptimisationEnabled, p as useSelfHostedWorkersEnabled, s as useDurableFunctionNodesEnabled, t as FLUIDGRIDS_FLAGS, u as useFluidGridsFlagsSettled } from "./feature-flags-DM5myWaD.js";
+
+export { FLUIDGRIDS_FLAGS, FLUIDGRIDS_FLAG_DEFAULTS, useContinuousOptimisationEnabled, useDurableFunctionNodesEnabled, useFluidGridsFlag, useFluidGridsFlagsSettled, usePhaseCFlags, useSelfHostedWorkersEnabled, useWorkflowTestsEnabled };