@fusedio/widget-sdk 0.1.0 → 0.2.0

package/dist/hooks/use-duckdb-sql.js

@@ -1,3 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDuckDbSqlQueryPreprocessing = useDuckDbSqlQueryPreprocessing;
+exports.useDuckDbSqlQuery = useDuckDbSqlQuery;
+exports.useVfsRegistration = useVfsRegistration;
 /**
  * DuckDB SQL execution against UDF Parquet outputs.
  *
@@ -13,13 +18,14 @@
  * the host side via the bridge. Both hooks work identically in the
  * workbench, the catalog-template test harness, or any other host.
  */
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { useFusedWidgetBridge } from "../bridge";
-import { useFormParams } from "../form";
-import { useJsonUiLog } from "./use-json-ui-log";
-import { useJsonUiEdgeAnimation } from "./use-json-ui-edge-animation";
-import { useCanvasParams } from "./use-canvas-params";
-import { computePlaceholderKey, extractSignableUrls, extractSqlParams, parseSqlUdfPlaceholders, resolveOverrideValue, rewriteSignedUrls, substituteSqlParams, getDollarRefName, } from "../utils/sql-placeholders";
+const react_1 = require("react");
+const bridge_1 = require("../bridge");
+const form_1 = require("../form");
+const use_json_ui_log_1 = require("./use-json-ui-log");
+const use_json_ui_edge_animation_1 = require("./use-json-ui-edge-animation");
+const use_canvas_params_1 = require("./use-canvas-params");
+const sql_source_overrides_1 = require("./sql-source-overrides");
+const sql_placeholders_1 = require("../utils/sql-placeholders");
 const DEFAULT_MAX_ROWS = 500;
 const EMPTY_ROWS = Object.freeze([]);
 const EMPTY_COLUMNS = Object.freeze([]);
@@ -63,53 +69,67 @@ function buildProcessedSql(sql, resolved, fileNameMap, sourceOverrides, sqlParam
                 processedSql.slice(raw.end);
     }
     processedSql = appendLimitIfMissing(processedSql, maxRows);
-    return substituteSqlParams(processedSql, sqlParamValues);
+    return (0, sql_placeholders_1.substituteSqlParams)(processedSql, sqlParamValues);
 }
 /**
  * Preprocess SQL: resolve placeholders, register UDFs via the bridge,
  * substitute params, sign URLs, append LIMIT. Returns the prepared SQL.
  */
-export function useDuckDbSqlQueryPreprocessing({ sql, enabled = true, maxRows = DEFAULT_MAX_ROWS, sourceOverrides, }) {
-    const bridge = useFusedWidgetBridge();
-    const { startLoading: startEdgeLoading, stopLoading: stopEdgeLoading } = useJsonUiEdgeAnimation();
-    const { log } = useJsonUiLog();
-    const [processedSql, setProcessedSql] = useState("");
-    const [loading, setLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const [fetchKey, setFetchKey] = useState(0);
-    const sourcePlaceholders = useMemo(() => {
+function useDuckDbSqlQueryPreprocessing({ sql, enabled = true, maxRows = DEFAULT_MAX_ROWS, sourceOverrides: explicitSourceOverrides, }) {
+    const bridge = (0, bridge_1.useFusedWidgetBridge)();
+    // Auto-detect host-provided source overrides (e.g. the workbench's
+    // sql-runner exposes in-memory relations to descendants) and merge them with
+    // any explicit option. Explicit overrides win on key collision. Component
+    // authors never thread this manually.
+    const contextSourceOverrides = (0, sql_source_overrides_1.useSqlSourceOverrides)();
+    const sourceOverrides = (0, react_1.useMemo)(() => {
+        const hasContext = Object.keys(contextSourceOverrides).length > 0;
+        if (!explicitSourceOverrides) {
+            return hasContext ? contextSourceOverrides : undefined;
+        }
+        if (!hasContext)
+            return explicitSourceOverrides;
+        return { ...contextSourceOverrides, ...explicitSourceOverrides };
+    }, [contextSourceOverrides, explicitSourceOverrides]);
+    const { startLoading: startEdgeLoading, stopLoading: stopEdgeLoading } = (0, use_json_ui_edge_animation_1.useJsonUiEdgeAnimation)();
+    const { log } = (0, use_json_ui_log_1.useJsonUiLog)();
+    const [processedSql, setProcessedSql] = (0, react_1.useState)("");
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [fetchKey, setFetchKey] = (0, react_1.useState)(0);
+    const sourcePlaceholders = (0, react_1.useMemo)(() => {
         if (!sql)
             return [];
-        return parseSqlUdfPlaceholders(sql);
+        return (0, sql_placeholders_1.parseSqlUdfPlaceholders)(sql);
     }, [sql]);
     // Skip placeholders that have a sourceOverride active (workbench-only path).
-    const placeholdersAfterOverride = useMemo(() => {
+    const placeholdersAfterOverride = (0, react_1.useMemo)(() => {
         if (!sourceOverrides)
             return sourcePlaceholders;
         return sourcePlaceholders.filter((p) => p.overrides !== null || !sourceOverrides[p.name]);
     }, [sourcePlaceholders, sourceOverrides]);
     // Override values may reference $params — collect those names so we can
     // subscribe to the same canvas/form param map the SQL body uses.
-    const overrideParamNames = useMemo(() => {
+    const overrideParamNames = (0, react_1.useMemo)(() => {
         const set = new Set();
         for (const p of placeholdersAfterOverride) {
             if (!p.overrides)
                 continue;
             for (const v of Object.values(p.overrides)) {
-                const name = getDollarRefName(v);
+                const name = (0, sql_placeholders_1.getDollarRefName)(v);
                 if (name)
                     set.add(name);
             }
         }
         return Array.from(set);
     }, [placeholdersAfterOverride]);
-    const sqlParamNames = useMemo(() => {
+    const sqlParamNames = (0, react_1.useMemo)(() => {
         if (!sql)
             return [];
-        return extractSqlParams(sql);
+        return (0, sql_placeholders_1.extractSqlParams)(sql);
     }, [sql]);
     // Subscribe to canvas + form params for both the SQL body and override refs.
-    const allParamNames = useMemo(() => {
+    const allParamNames = (0, react_1.useMemo)(() => {
         const seen = new Set();
         const out = [];
         for (const n of sqlParamNames) {
@@ -126,10 +146,10 @@ export function useDuckDbSqlQueryPreprocessing({ sql, enabled = true, maxRows =
         }
         return out;
     }, [sqlParamNames, overrideParamNames]);
-    const canvasParamValues = useCanvasParams(allParamNames);
-    const { inForm, values: formParamValues } = useFormParams(allParamNames);
-    const sqlParamValues = useMemo(() => inForm ? { ...canvasParamValues, ...formParamValues } : canvasParamValues, [inForm, canvasParamValues, formParamValues]);
-    const resolvedPlaceholders = useMemo(() => {
+    const canvasParamValues = (0, use_canvas_params_1.useCanvasParams)(allParamNames);
+    const { inForm, values: formParamValues } = (0, form_1.useFormParams)(allParamNames);
+    const sqlParamValues = (0, react_1.useMemo)(() => inForm ? { ...canvasParamValues, ...formParamValues } : canvasParamValues, [inForm, canvasParamValues, formParamValues]);
+    const resolvedPlaceholders = (0, react_1.useMemo)(() => {
         return placeholdersAfterOverride.map((p) => {
             if (!p.overrides) {
                 return {
@@ -142,21 +162,21 @@ export function useDuckDbSqlQueryPreprocessing({ sql, enabled = true, maxRows =
             const resolvedOverrides = {};
             let unresolved = false;
             for (const [paramKey, rawValue] of Object.entries(p.overrides)) {
-                const r = resolveOverrideValue(rawValue, sqlParamValues);
+                const r = (0, sql_placeholders_1.resolveOverrideValue)(rawValue, sqlParamValues);
                 if (r.unresolved)
                     unresolved = true;
                 resolvedOverrides[paramKey] = r.value;
             }
             return {
                 raw: p,
-                key: computePlaceholderKey(p.name, resolvedOverrides),
+                key: (0, sql_placeholders_1.computePlaceholderKey)(p.name, resolvedOverrides),
                 resolvedOverrides,
                 unresolved,
             };
         });
     }, [placeholdersAfterOverride, sqlParamValues]);
     // Deduplicate refs we need to pass to the bridge for VFS registration.
-    const vfsRefs = useMemo(() => {
+    const vfsRefs = (0, react_1.useMemo)(() => {
         const seen = new Set();
         const out = [];
         for (const rp of resolvedPlaceholders) {
@@ -175,7 +195,7 @@ export function useDuckDbSqlQueryPreprocessing({ sql, enabled = true, maxRows =
     }, [resolvedPlaceholders]);
     // Stable key for the refs list — avoids re-running the resolve effect when
     // the underlying refs are structurally identical.
-    const refsKey = useMemo(() => {
+    const refsKey = (0, react_1.useMemo)(() => {
         return vfsRefs
             .map((r) => `${r.key}|${r.name}|${r.overrides
             ? Object.entries(r.overrides)
@@ -185,12 +205,12 @@ export function useDuckDbSqlQueryPreprocessing({ sql, enabled = true, maxRows =
             : ""}`)
             .join("\n");
     }, [vfsRefs]);
-    const refetch = useCallback(() => {
+    const refetch = (0, react_1.useCallback)(() => {
         setFetchKey((k) => k + 1);
     }, []);
     // Subscribe to UDF output changes for every referenced UDF — `resolveVfsFilenames`
     // doesn't auto-rerun when a UDF re-executes, so we trigger a refetch.
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         if (!enabled || vfsRefs.length === 0)
             return;
         const unsubs = vfsRefs.map((ref) => bridge.udfs.subscribeOutput(ref.name, () => {
@@ -201,14 +221,14 @@ export function useDuckDbSqlQueryPreprocessing({ sql, enabled = true, maxRows =
         };
     }, [bridge, enabled, vfsRefs]);
     // Edge animation mirrors loading.
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         if (loading)
             startEdgeLoading();
         else
             stopEdgeLoading();
     }, [loading, startEdgeLoading, stopEdgeLoading]);
     // Watch for sourceOverride errors / loading so the preprocessing reflects them.
-    const sourceOverrideError = useMemo(() => {
+    const sourceOverrideError = (0, react_1.useMemo)(() => {
         if (!sourceOverrides)
             return null;
         for (const p of sourcePlaceholders) {
@@ -220,13 +240,13 @@ export function useDuckDbSqlQueryPreprocessing({ sql, enabled = true, maxRows =
         }
         return null;
     }, [sourcePlaceholders, sourceOverrides]);
-    const sourceOverrideLoading = useMemo(() => {
+    const sourceOverrideLoading = (0, react_1.useMemo)(() => {
         if (!sourceOverrides)
             return false;
         return sourcePlaceholders.some((p) => p.overrides === null && sourceOverrides[p.name]?.loading);
     }, [sourcePlaceholders, sourceOverrides]);
     const hasUnresolvedOverride = resolvedPlaceholders.some((rp) => rp.unresolved);
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         if (!enabled || !sql) {
             setProcessedSql("");
             setLoading(false);
@@ -338,7 +358,7 @@ export function useDuckDbSqlQueryPreprocessing({ sql, enabled = true, maxRows =
                 log(`SQL preprocessing failed: ${msg}`, "error");
                 return;
             }
-            const urls = extractSignableUrls(nextProcessedSql);
+            const urls = (0, sql_placeholders_1.extractSignableUrls)(nextProcessedSql);
             if (urls.length === 0) {
                 if (cancelled)
                     return;
@@ -356,7 +376,7 @@ export function useDuckDbSqlQueryPreprocessing({ sql, enabled = true, maxRows =
                 urls.forEach((u, i) => {
                     signedMap[u] = signed[i].signed;
                 });
-                const signedSql = rewriteSignedUrls(nextProcessedSql, signedMap);
+                const signedSql = (0, sql_placeholders_1.rewriteSignedUrls)(nextProcessedSql, signedMap);
                 setProcessedSql(signedSql);
                 setError(null);
                 setLoading(false);
@@ -402,15 +422,15 @@ export function useDuckDbSqlQueryPreprocessing({ sql, enabled = true, maxRows =
  * `useDuckDbSqlQueryPreprocessing` to prepare the SQL string, then runs
  * it via the bridge.
  */
-export function useDuckDbSqlQuery({ sql, enabled = true, maxRows = DEFAULT_MAX_ROWS, sourceOverrides, }) {
-    const bridge = useFusedWidgetBridge();
-    const { startLoading: startEdgeLoading, stopLoading: stopEdgeLoading } = useJsonUiEdgeAnimation();
-    const { log } = useJsonUiLog();
-    const [rows, setRows] = useState(EMPTY_ROWS);
-    const [columns, setColumns] = useState(EMPTY_COLUMNS);
-    const [queryLoading, setQueryLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const [fetchKey, setFetchKey] = useState(0);
+function useDuckDbSqlQuery({ sql, enabled = true, maxRows = DEFAULT_MAX_ROWS, sourceOverrides, }) {
+    const bridge = (0, bridge_1.useFusedWidgetBridge)();
+    const { startLoading: startEdgeLoading, stopLoading: stopEdgeLoading } = (0, use_json_ui_edge_animation_1.useJsonUiEdgeAnimation)();
+    const { log } = (0, use_json_ui_log_1.useJsonUiLog)();
+    const [rows, setRows] = (0, react_1.useState)(EMPTY_ROWS);
+    const [columns, setColumns] = (0, react_1.useState)(EMPTY_COLUMNS);
+    const [queryLoading, setQueryLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [fetchKey, setFetchKey] = (0, react_1.useState)(0);
     const { processedSql, loading: preprocessingLoading, error: preprocessingError, refetch: refetchPreprocessing, } = useDuckDbSqlQueryPreprocessing({
         sql,
         enabled,
@@ -419,7 +439,7 @@ export function useDuckDbSqlQuery({ sql, enabled = true, maxRows = DEFAULT_MAX_R
     });
     // Bridges the single-frame gap between preprocessing completing and the
     // query effect starting — keeps `loading` true through that frame.
-    const consumedSqlRef = useRef("");
+    const consumedSqlRef = (0, react_1.useRef)("");
     const awaitingExecution = enabled &&
         !!sql &&
         !!processedSql &&
@@ -427,18 +447,18 @@ export function useDuckDbSqlQuery({ sql, enabled = true, maxRows = DEFAULT_MAX_R
         !preprocessingError &&
         processedSql !== consumedSqlRef.current;
     const loading = preprocessingLoading || queryLoading || awaitingExecution;
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         if (loading)
             startEdgeLoading();
         else
             stopEdgeLoading();
     }, [loading, startEdgeLoading, stopEdgeLoading]);
-    const refetch = useCallback(() => {
+    const refetch = (0, react_1.useCallback)(() => {
         consumedSqlRef.current = "";
         refetchPreprocessing();
         setFetchKey((k) => k + 1);
     }, [refetchPreprocessing]);
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         if (!enabled || !sql) {
             consumedSqlRef.current = "";
             setRows(EMPTY_ROWS);
@@ -524,11 +544,11 @@ export function useDuckDbSqlQuery({ sql, enabled = true, maxRows = DEFAULT_MAX_R
  * Resolve UDF names to VFS filenames, registering them in DuckDB if needed.
  * Exposed for advanced use cases (e.g. building your own query string).
  */
-export function useVfsRegistration(udfNames, enabled = true) {
-    const bridge = useFusedWidgetBridge();
-    const [state, setState] = useState({ filenames: new Map(), loading: false });
-    const namesKey = useMemo(() => udfNames.slice().sort().join("|"), [udfNames]);
-    useEffect(() => {
+function useVfsRegistration(udfNames, enabled = true) {
+    const bridge = (0, bridge_1.useFusedWidgetBridge)();
+    const [state, setState] = (0, react_1.useState)({ filenames: new Map(), loading: false });
+    const namesKey = (0, react_1.useMemo)(() => udfNames.slice().sort().join("|"), [udfNames]);
+    (0, react_1.useEffect)(() => {
         if (!enabled || udfNames.length === 0) {
             setState({ filenames: new Map(), loading: false });
             return;

package/dist/hooks/use-fused-param-with-form.d.ts

@@ -0,0 +1,18 @@
+import type { UseFusedParamOptions, UseFusedParamReturn } from "../types";
+/**
+ * Form-aware variant of {@link useFusedParam}.
+ *
+ * When the component is rendered inside a built-in Form, the field becomes
+ * local state (its value is NOT broadcast to the canvas) and its live value is
+ * mirrored into the form's subscription store, so sibling components (a
+ * dropdown's SQL options, a chart, a text binding, …) can react to it before
+ * the form is submitted. Outside a form it behaves exactly like
+ * `useFusedParam` — two-way canvas binding with debounced broadcast.
+ *
+ * Requires a `FusedWidgetBridgeContext` ancestor (like `useFusedParam`) and a
+ * `FormContext` ancestor for the in-form behavior (the built-in Form component
+ * provides one).
+ */
+export declare function useFusedParamWithForm<T extends string | number>(options: UseFusedParamOptions<T>): UseFusedParamReturn<T> & {
+    isInForm: boolean;
+};

package/dist/hooks/use-fused-param-with-form.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFusedParamWithForm = useFusedParamWithForm;
+const react_1 = require("react");
+const form_1 = require("../form");
+const use_fused_param_1 = require("./use-fused-param");
+/**
+ * Form-aware variant of {@link useFusedParam}.
+ *
+ * When the component is rendered inside a built-in Form, the field becomes
+ * local state (its value is NOT broadcast to the canvas) and its live value is
+ * mirrored into the form's subscription store, so sibling components (a
+ * dropdown's SQL options, a chart, a text binding, …) can react to it before
+ * the form is submitted. Outside a form it behaves exactly like
+ * `useFusedParam` — two-way canvas binding with debounced broadcast.
+ *
+ * Requires a `FusedWidgetBridgeContext` ancestor (like `useFusedParam`) and a
+ * `FormContext` ancestor for the in-form behavior (the built-in Form component
+ * provides one).
+ */
+function useFusedParamWithForm(options) {
+    const formContext = (0, form_1.useFormContext)();
+    const param = options.param;
+    const isFormField = Boolean(formContext.isInForm && param);
+    // Hook handles both cases: with param (canvas sync) or without (local state).
+    // Disable canvas messaging when inside a form by withholding the param.
+    const { value, setValue, broadcastNow, clearValue } = (0, use_fused_param_1.useFusedParam)({
+        ...options,
+        param: isFormField ? undefined : options.param,
+    });
+    // Mirror the live value into the form's subscription store so sibling
+    // components can react to it. Value updates use a dedicated effect so we
+    // don't briefly remove the field from the store between renders —
+    // unregistration runs only when the binding (store/param) actually changes
+    // or on unmount.
+    const store = formContext.store;
+    (0, react_1.useEffect)(() => {
+        if (!isFormField || !param || !store)
+            return;
+        store.setField(param, value);
+    }, [value, isFormField, param, store]);
+    (0, react_1.useEffect)(() => {
+        if (!isFormField || !param || !store)
+            return;
+        return () => {
+            store.removeField(param);
+        };
+    }, [isFormField, param, store]);
+    return {
+        value,
+        setValue,
+        broadcastNow,
+        clearValue,
+        isInForm: formContext.isInForm,
+    };
+}

package/dist/hooks/use-fused-param.js

@@ -1,7 +1,10 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { useFusedWidgetBridge, useJsonUiNode } from "../bridge";
-import { useFormParams } from "../form";
-import { ParameterMessageType } from "../protocol";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFusedParam = useFusedParam;
+const react_1 = require("react");
+const bridge_1 = require("../bridge");
+const form_1 = require("../form");
+const protocol_1 = require("../protocol");
 /**
  * Two-way bind a component to a named canvas parameter.
  *
@@ -40,9 +43,9 @@ import { ParameterMessageType } from "../protocol";
  * const { clearValue } = useFusedParam({ param: "selection", defaultValue: null });
  * <button onClick={() => clearValue(null)}>Reset</button>
  */
-export function useFusedParam({ param, debounceMs = 300, readOnly = false, defaultValue, broadcastDefaultValue = true, validate, preprocess, }) {
-    const bridge = useFusedWidgetBridge();
-    const { configHash } = useJsonUiNode();
+function useFusedParam({ param, debounceMs = 300, readOnly = false, defaultValue, broadcastDefaultValue = true, validate, preprocess, }) {
+    const bridge = (0, bridge_1.useFusedWidgetBridge)();
+    const { configHash } = (0, bridge_1.useJsonUiNode)();
     const enabled = !!param;
     // Stable log helper — entries appear in the workbench's runtime logs panel.
     // configHash is passed through so nested JsonUiConfigHashOverride subtrees
@@ -61,20 +64,20 @@ export function useFusedParam({ param, debounceMs = 300, readOnly = false, defau
     // Stable validator and preprocessor. We deliberately omit `defaultValue`
     // from the deps so a parent re-render passing a new defaultValue literal
     // doesn't churn these. The type semantics only depend on the original.
-    const preprocessor = useMemo(() => preprocess ?? createDefaultPreprocessor(defaultValue), 
+    const preprocessor = (0, react_1.useMemo)(() => preprocess ?? createDefaultPreprocessor(defaultValue), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [preprocess]);
-    const validator = useMemo(() => validate ?? createDefaultValidator(defaultValue), 
+    const validator = (0, react_1.useMemo)(() => validate ?? createDefaultValidator(defaultValue), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [validate]);
     // Form-scoped value shadows canvas value when inside a form.
-    const paramNamesForForm = useMemo(() => (param ? [param] : []), [param]);
-    const { inForm, values: formParams } = useFormParams(paramNamesForForm);
+    const paramNamesForForm = (0, react_1.useMemo)(() => (param ? [param] : []), [param]);
+    const { inForm, values: formParams } = (0, form_1.useFormParams)(paramNamesForForm);
     const formValue = param ? formParams[param] : undefined;
     // ── Initial value resolution ────────────────────────────────────────────
     // Read snapshot once to seed local state — subsequent updates come via the
     // sync effect below. Reading the bridge here is safe (synchronous).
-    const initialCanvasValue = useMemo(() => {
+    const initialCanvasValue = (0, react_1.useMemo)(() => {
         if (!enabled || !param)
             return undefined;
         return bridge.params.getSnapshot(param);
@@ -86,24 +89,24 @@ export function useFusedParam({ param, debounceMs = 300, readOnly = false, defau
         const processed = preprocessor(raw);
         return validator(processed) ? processed : defaultValue;
     };
-    const [value, setValueState] = useState(computeInitialValue);
-    const valueRef = useRef(value);
+    const [value, setValueState] = (0, react_1.useState)(computeInitialValue);
+    const valueRef = (0, react_1.useRef)(value);
     valueRef.current = value;
-    const debounceRef = useRef(null);
-    const isLocalChangeRef = useRef(false);
-    const didBroadcastOnMountRef = useRef(false);
+    const debounceRef = (0, react_1.useRef)(null);
+    const isLocalChangeRef = (0, react_1.useRef)(false);
+    const didBroadcastOnMountRef = (0, react_1.useRef)(false);
     // Stable closure over the latest binding for the unmount cleanup.
     // bridge is captured by ref too so the cleanup effect's deps can stay `[]`
     // — otherwise any bridge identity flip would re-run the effect and
     // broadcast a stray CLEAR for every bound input, cascading through the
     // canvas-param listener fan-out.
-    const latestBindingRef = useRef({ enabled, param });
+    const latestBindingRef = (0, react_1.useRef)({ enabled, param });
     latestBindingRef.current = { enabled, param };
-    const bridgeRef = useRef(bridge);
+    const bridgeRef = (0, react_1.useRef)(bridge);
     bridgeRef.current = bridge;
     // ── Clear bound param when name changes (carry-over avoidance) ──────────
-    const prevParamRef = useRef(param);
-    useEffect(() => {
+    const prevParamRef = (0, react_1.useRef)(param);
+    (0, react_1.useEffect)(() => {
         const prev = prevParamRef.current;
         prevParamRef.current = param;
         if (prev && prev !== param) {
@@ -111,7 +114,7 @@ export function useFusedParam({ param, debounceMs = 300, readOnly = false, defau
         }
     }, [bridge, param]);
     // ── Subscribe to canvas (and form) updates ──────────────────────────────
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         if (!enabled || !param)
             return;
         if (isLocalChangeRef.current)
@@ -131,7 +134,7 @@ export function useFusedParam({ param, debounceMs = 300, readOnly = false, defau
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [bridge, param, enabled, inForm, formValue, preprocessor, validator]);
     // Subscribe to bridge canvas updates so changes from other nodes flow in.
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         if (!enabled || !param)
             return;
         const unsub = bridge.params.subscribe(param, () => {
@@ -150,16 +153,16 @@ export function useFusedParam({ param, debounceMs = 300, readOnly = false, defau
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [bridge, param, enabled, preprocessor, validator]);
     // ── Broadcast plumbing ──────────────────────────────────────────────────
-    const broadcast = useCallback((newValue) => {
+    const broadcast = (0, react_1.useCallback)((newValue) => {
         if (!enabled || !param)
             return;
-        bridge.params.set(param, newValue, ParameterMessageType.PARAM);
+        bridge.params.set(param, newValue, protocol_1.ParameterMessageType.PARAM);
         bridge.edges.stopLoading();
         logPreview("Broadcast", newValue);
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [bridge, enabled, param]);
-    const broadcastNow = useCallback(() => {
+    const broadcastNow = (0, react_1.useCallback)(() => {
         if (!enabled || readOnly)
             return;
         if (debounceRef.current) {
@@ -170,7 +173,7 @@ export function useFusedParam({ param, debounceMs = 300, readOnly = false, defau
         broadcast(valueRef.current);
         isLocalChangeRef.current = false;
     }, [bridge, broadcast, enabled, readOnly]);
-    const clearValue = useCallback((newValue) => {
+    const clearValue = (0, react_1.useCallback)((newValue) => {
         if (debounceRef.current) {
             clearTimeout(debounceRef.current);
             debounceRef.current = null;
@@ -187,11 +190,11 @@ export function useFusedParam({ param, debounceMs = 300, readOnly = false, defau
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [bridge, enabled, param, readOnly]);
     // Reset one-time mount broadcast guard when binding changes.
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         didBroadcastOnMountRef.current = false;
     }, [param, enabled]);
     // Broadcast default value on mount when no canvas value exists.
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         if (!enabled || !param || readOnly)
             return;
         if (!broadcastDefaultValue)
@@ -211,7 +214,7 @@ export function useFusedParam({ param, debounceMs = 300, readOnly = false, defau
         broadcast(valueRef.current);
         didBroadcastOnMountRef.current = true;
     }, [bridge, enabled, param, readOnly, broadcastDefaultValue, broadcast]);
-    const setValue = useCallback((newValue) => {
+    const setValue = (0, react_1.useCallback)((newValue) => {
         setValueState(newValue);
         if (!enabled || readOnly)
             return;
@@ -228,7 +231,7 @@ export function useFusedParam({ param, debounceMs = 300, readOnly = false, defau
     // type-swaps don't leave stale canvas state behind. Deps are `[]` so this
     // runs on unmount only — never on bridge identity flips. bridge is read
     // from the ref at cleanup time.
-    useEffect(() => {
+    (0, react_1.useEffect)(() => {
         return () => {
             if (debounceRef.current)
                 clearTimeout(debounceRef.current);

package/dist/hooks/use-json-ui-edge-animation.js

@@ -1,4 +1,7 @@
-import { useFusedWidgetBridge } from "../bridge";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useJsonUiEdgeAnimation = useJsonUiEdgeAnimation;
+const bridge_1 = require("../bridge");
 /**
  * Controls the edge-animation pellet for the current canvas node.
  *
@@ -17,8 +20,8 @@ import { useFusedWidgetBridge } from "../bridge";
  *   try { await heavyCompute(); } finally { stopLoading(); }
  * }
  */
-export function useJsonUiEdgeAnimation() {
-    const bridge = useFusedWidgetBridge();
+function useJsonUiEdgeAnimation() {
+    const bridge = (0, bridge_1.useFusedWidgetBridge)();
     return {
         startLoading: bridge.edges.startLoading,
         stopLoading: bridge.edges.stopLoading,

package/dist/hooks/use-json-ui-log.js

@@ -1,5 +1,10 @@
-import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";
-import { useFusedWidgetBridge, useJsonUiNode, } from "../bridge";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useJsonUiLog = useJsonUiLog;
+exports.useJsonUiLogs = useJsonUiLogs;
+exports.useJsonUiLogClear = useJsonUiLogClear;
+const react_1 = require("react");
+const bridge_1 = require("../bridge");
 const EMPTY_LOGS = Object.freeze([]);
 /**
  * Logging hook for json-ui components. Entries appear in the workbench's
@@ -16,22 +21,22 @@ const EMPTY_LOGS = Object.freeze([]);
  * log("Selected city: " + city);
  * log("Failed to load chart data", "error");
  */
-export function useJsonUiLog() {
-    const bridge = useFusedWidgetBridge();
-    const { configHash } = useJsonUiNode();
+function useJsonUiLog() {
+    const bridge = (0, bridge_1.useFusedWidgetBridge)();
+    const { configHash } = (0, bridge_1.useJsonUiNode)();
     // bridge and configHash are read from refs so the returned `log` callback
     // identity is stable across re-renders. Downstream effects with `log` in
     // their deps (e.g. use-duckdb-sql.ts's preprocessing effect) would
     // otherwise re-fire on every bridge flip / configHash change and cascade
     // setState across every SQL widget in the dashboard.
-    const bridgeRef = useRef(bridge);
+    const bridgeRef = (0, react_1.useRef)(bridge);
     bridgeRef.current = bridge;
-    const configHashRef = useRef(configHash);
+    const configHashRef = (0, react_1.useRef)(configHash);
     configHashRef.current = configHash;
-    const log = useCallback((message, level = "info") => {
+    const log = (0, react_1.useCallback)((message, level = "info") => {
         bridgeRef.current.log.log(message, level, configHashRef.current);
     }, []);
-    return useMemo(() => ({ log }), [log]);
+    return (0, react_1.useMemo)(() => ({ log }), [log]);
 }
 /**
  * Read-only hook returning the current log entries for a given node.
@@ -41,15 +46,15 @@ export function useJsonUiLog() {
  * rarely need to read logs they wrote, but the hook is exposed for
  * completeness (e.g. building a debug view component).
  */
-export function useJsonUiLogs(nodeId) {
-    const bridge = useFusedWidgetBridge();
-    const subscribe = useCallback((cb) => {
+function useJsonUiLogs(nodeId) {
+    const bridge = (0, bridge_1.useFusedWidgetBridge)();
+    const subscribe = (0, react_1.useCallback)((cb) => {
         if (!nodeId)
             return () => { };
         return bridge.log.subscribeLogs(nodeId, cb);
     }, [bridge, nodeId]);
-    const snapshotRef = useRef(EMPTY_LOGS);
-    const getSnapshot = useCallback(() => {
+    const snapshotRef = (0, react_1.useRef)(EMPTY_LOGS);
+    const getSnapshot = (0, react_1.useCallback)(() => {
         if (!nodeId)
             return EMPTY_LOGS;
         const next = bridge.log.getLogsSnapshot(nodeId);
@@ -58,15 +63,15 @@ export function useJsonUiLogs(nodeId) {
         snapshotRef.current = next;
         return next;
     }, [bridge, nodeId]);
-    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    return (0, react_1.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
 }
 /**
  * Returns a stable callback that clears all log entries for the given node.
  * Returns a no-op function when `nodeId` is undefined.
  */
-export function useJsonUiLogClear(nodeId) {
-    const bridge = useFusedWidgetBridge();
-    return useCallback(() => {
+function useJsonUiLogClear(nodeId) {
+    const bridge = (0, bridge_1.useFusedWidgetBridge)();
+    return (0, react_1.useCallback)(() => {
         if (!nodeId)
             return;
         bridge.log.clearLogs(nodeId);