@growthub/cli 0.9.10 → 0.9.12

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/adapters/integrations/growthub-connection-normalizer.js

@@ -1,15 +1,12 @@
-const providerAliases = {
-  ga4: "google-analytics",
-  google_analytics: "google-analytics",
-  google_drive: "google-drive",
-  ghl: "go-high-level",
-  gohighlevel: "go-high-level",
-  meta: "meta-ads",
-  meta_ads: "meta-ads"
-};
 function normalizeProviderId(provider) {
-  const normalized = provider.trim().toLowerCase().replaceAll("_", "-");
-  return providerAliases[normalized] || normalized;
+  return provider.trim().toLowerCase().replaceAll("_", "-");
+}
+function providerLabel(provider) {
+  return normalizeProviderId(provider)
+    .split("-")
+    .filter(Boolean)
+    .map((part) => part.slice(0, 1).toUpperCase() + part.slice(1))
+    .join(" ");
 }
 function isHostedRecord(row) {
   return "provider" in row && ("ready" in row || "connectedAt" in row || "scopes" in row || "handle" in row);
@@ -41,10 +38,10 @@ function normalizeMcpAccount(account) {
   const isVerified = account.isVerified === true;
   const isConnected = isActive;
   return {
-    id: provider,
-    provider,
-    label: account.connectionName || void 0,
-    name: account.connectionName || void 0,
+	    id: provider,
+	    provider,
+	    label: providerLabel(provider),
+	    name: providerLabel(provider),
     authType: normalizeConnectionType(account.connectionType),
     status: isConnected ? "connected" : "needs-connection",
     isConnected,
@@ -54,7 +51,6 @@ function normalizeMcpAccount(account) {
     setupMode: "hosted-authority",
     connectionMetadata: {
       source: "growthub-mcp-accounts",
-      accountId: account.id,
       connectionName: account.connectionName,
       connectionType: account.connectionType,
       isVerified,

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/adapters/integrations/index.js

@@ -1,6 +1,7 @@
 import { readAdapterConfig } from "@/lib/adapters/env";
 import {
-  governedWorkspaceIntegrationCatalog
+  governedWorkspaceIntegrationCatalog,
+  normalizeIntegrationEntities
 } from "@/lib/domain/integrations";
 import {
   normalizeGrowthubBridgePayload
@@ -136,10 +137,10 @@ function mergeBridgeRows(rows) {
     });
     if (!row) return catalogItem;
     seenProviders.add(row.provider || row.id || catalogItem.provider);
-    return {
-      ...catalogItem,
-      label: row.label || row.name || catalogItem.label,
-      name: row.name || row.label || catalogItem.name,
+	  return {
+	    ...catalogItem,
+	    label: catalogItem.label,
+	    name: catalogItem.name,
       icon: row.icon || catalogItem.icon,
       description: row.description || catalogItem.description,
       category: row.category || catalogItem.category,
@@ -150,7 +151,6 @@ function mergeBridgeRows(rows) {
       setupMode: row.setupMode || catalogItem.setupMode,
       status: row.status || (row.isConnected || row.isActive ? "connected" : catalogItem.status),
       connectionId: row.connectionId,
-      accountId: row.accountId,
       secretEnvName: row.secretEnvName,
       connectionMetadata: row.connectionMetadata || row.metadata,
       metadata: row.metadata || row.connectionMetadata
@@ -167,8 +167,9 @@ function mergeBridgeRows(rows) {
 function toDiscoveredIntegration(row) {
   const provider = row.provider || row.id || "unknown-provider";
   const label = row.label || row.name || provider;
-  const isDataPipeline = ["windsor-ai", "google-sheets", "google-analytics", "shopify", "meta-ads"].includes(provider);
   const isConnected = row.isConnected ?? row.status === "connected";
+  const lane = typeof row.lane === "string" && row.lane ? row.lane : "workspace-integration";
+  const objectType = typeof row.objectType === "string" && row.objectType ? row.objectType : "mcp-connection";
   return {
     id: row.id || provider,
     label,
@@ -180,19 +181,68 @@ function toDiscoveredIntegration(row) {
     authType: row.authType || "oauth_first_party",
     isConnected,
     isActive: row.isActive ?? isConnected,
-    lane: isDataPipeline ? "data-source" : "workspace-integration",
-    objectType: isDataPipeline ? "data-pipeline" : "mcp-connection",
+    lane,
+    objectType,
     status: row.status || (isConnected ? "connected" : "needs-connection"),
     authPath: row.authPath || "growthub-mcp-bridge",
     setupMode: row.setupMode || "hosted-authority",
     connectionId: row.connectionId,
-    accountId: row.accountId,
     secretEnvName: row.secretEnvName,
     connectionMetadata: row.connectionMetadata || row.metadata,
     metadata: row.metadata || row.connectionMetadata
   };
 }
+/**
+ * Governed Integration Reference Binding — entity metadata resolution.
+ *
+ * Returns NormalizedIntegrationEntity[] for the requested integration when a
+ * server-side object resolver is available. Bridge connection discovery alone
+ * does not fabricate provider objects.
+ *
+ * Authority invariant: this function runs server-side only (API route).
+ * The browser NEVER calls provider APIs, holds tokens, or resolves entities.
+ */
+async function listEntityMetadataForIntegration(integrationId) {
+  if (!integrationId) return [];
+  const config = readAdapterConfig();
+
+  if (config.integrationAdapter === "growthub-bridge" &&
+      config.growthubBridge?.baseUrl &&
+      process.env.GROWTHUB_BRIDGE_ACCESS_TOKEN) {
+    try {
+      const baseUrl = config.growthubBridge.baseUrl;
+      const entitiesPath = `/api/integrations/${encodeURIComponent(integrationId)}/entities`;
+      const url = new URL(entitiesPath, baseUrl);
+      const headers = {
+        accept: "application/json",
+        authorization: `Bearer ${process.env.GROWTHUB_BRIDGE_ACCESS_TOKEN}`
+      };
+      if (config.growthubBridge.userId) {
+        headers["x-user-id"] = config.growthubBridge.userId;
+      }
+      const response = await fetch(url, {
+        headers,
+        next: { revalidate: 30 }
+      });
+      if (response.ok) {
+        const payload = await response.json();
+        const entities = Array.isArray(payload.entities) ? payload.entities :
+          Array.isArray(payload.objects) ? payload.objects :
+            Array.isArray(payload.data) ? payload.data :
+              Array.isArray(payload) ? payload : [];
+        const normalized = normalizeIntegrationEntities(entities);
+        if (normalized.length) return normalized;
+      }
+    } catch {
+      // No fallback object data. The UI must surface the missing resolver.
+    }
+  }
+
+  return [];
+}
+
 export {
   describeIntegrationAdapter,
-  listGovernedWorkspaceIntegrations
+  listGovernedWorkspaceIntegrations,
+  listEntityMetadataForIntegration
 };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/domain/integrations.js

@@ -173,13 +173,43 @@ const workspaceIntegrations = [
   }
 ];
 const governedWorkspaceIntegrationCatalog = [...dataSources, ...workspaceIntegrations];
+
 function groupIntegrationsByLane(integrations) {
   return {
     dataSources: integrations.filter((item) => item.lane === "data-source"),
     workspaceIntegrations: integrations.filter((item) => item.lane === "workspace-integration")
   };
 }
+
+function normalizeIntegrationEntity(entity) {
+  if (!entity || typeof entity !== "object" || Array.isArray(entity)) return null;
+  const id = typeof entity.id === "string" ? entity.id.trim() : "";
+  const label = typeof entity.label === "string" && entity.label.trim()
+    ? entity.label.trim()
+    : id;
+  if (!id || !label) return null;
+  const normalized = {
+    id,
+    label,
+    secondaryLabel: typeof entity.secondaryLabel === "string" ? entity.secondaryLabel : id,
+    entityType: typeof entity.entityType === "string" ? entity.entityType : undefined,
+    provider: typeof entity.provider === "string" ? entity.provider : undefined,
+    lane: typeof entity.lane === "string" ? entity.lane : undefined,
+    status: typeof entity.status === "string" ? entity.status : undefined,
+    metadata: entity.metadata && typeof entity.metadata === "object" && !Array.isArray(entity.metadata)
+      ? entity.metadata
+      : undefined
+  };
+  return Object.fromEntries(Object.entries(normalized).filter(([, value]) => value !== undefined));
+}
+
+function normalizeIntegrationEntities(entities) {
+  if (!Array.isArray(entities)) return [];
+  return entities.map(normalizeIntegrationEntity).filter(Boolean);
+}
+
 export {
   governedWorkspaceIntegrationCatalog,
-  groupIntegrationsByLane
+  groupIntegrationsByLane,
+  normalizeIntegrationEntities
 };

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/workspace-config.js

@@ -93,6 +93,7 @@ function applyPatch(currentConfig, patch) {
   const next = { ...currentConfig };
   if (patch.dashboards !== undefined) next.dashboards = patch.dashboards;
   if (patch.widgetTypes !== undefined) next.widgetTypes = patch.widgetTypes;
+  if (patch.dataModel !== undefined) next.dataModel = patch.dataModel;
   if (patch.canvas !== undefined && patch.canvas !== null) {
     const patchCanvas = { ...patch.canvas };
     if (Array.isArray(patchCanvas.tabs)) {
@@ -140,7 +141,8 @@ async function writeWorkspaceConfig(patch) {
   validateWorkspaceConfig({
     dashboards: next.dashboards,
     widgetTypes: next.widgetTypes,
-    canvas: next.canvas
+    canvas: next.canvas,
+    dataModel: next.dataModel
   });
   const configPath = resolveWorkspaceConfigPath();
   const expectedDir = path.resolve(/*turbopackIgnore: true*/ process.cwd());

package/assets/worker-kits/growthub-custom-workspace-starter-v1/apps/workspace/lib/workspace-data-model.js

@@ -0,0 +1,433 @@
+function parseCsv(text) {
+  const lines = String(text || "").trim().split("\n").filter(Boolean);
+  if (!lines.length) return { columns: [], rows: [] };
+  const parseLine = (line) => {
+    const cells = [];
+    let value = "";
+    let quoted = false;
+    for (let index = 0; index < line.length; index += 1) {
+      const char = line[index];
+      if (char === '"') {
+        if (quoted && line[index + 1] === '"') {
+          value += '"';
+          index += 1;
+        } else {
+          quoted = !quoted;
+        }
+      } else if (char === "," && !quoted) {
+        cells.push(value);
+        value = "";
+      } else {
+        value += char;
+      }
+    }
+    cells.push(value);
+    return cells;
+  };
+  const columns = parseLine(lines[0]).map((cell) => cell.trim()).filter(Boolean);
+  const rows = lines.slice(1).map((line) => {
+    const cells = parseLine(line);
+    return columns.reduce((record, column, index) => {
+      record[column] = (cells[index] || "").trim();
+      return record;
+    }, {});
+  });
+  return { columns, rows };
+}
+
+function toCsv(columns, rows) {
+  const escape = (value) => {
+    const text = String(value ?? "");
+    return /[",\n\r]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+  };
+  const header = columns.map(escape).join(",");
+  const body = rows.map((row) => columns.map((column) => escape(row?.[column])).join(",")).join("\n");
+  return body ? `${header}\n${body}` : header;
+}
+
+function parseJsonRows(text) {
+  try {
+    const parsed = JSON.parse(text || "[]");
+    const rows = Array.isArray(parsed) ? parsed.filter((row) => row && typeof row === "object" && !Array.isArray(row)) : [];
+    const columns = Array.from(rows.reduce((set, row) => {
+      Object.keys(row).forEach((key) => set.add(key));
+      return set;
+    }, new Set()));
+    return { columns, rows };
+  } catch {
+    return { columns: [], rows: [] };
+  }
+}
+
+function listWidgetEntries(workspaceConfig) {
+  const entries = [];
+  const seen = new Set();
+  const push = (widget, location) => {
+    if (!widget?.id || seen.has(widget.id)) return;
+    seen.add(widget.id);
+    entries.push({ widget, location });
+  };
+
+  for (const dashboard of workspaceConfig?.dashboards || []) {
+    for (const tab of dashboard.tabs || []) {
+      for (const widget of tab.widgets || []) {
+        push(widget, {
+          dashboardId: dashboard.id,
+          dashboardName: dashboard.name,
+          tabId: tab.id,
+          tabName: tab.name,
+          widgetId: widget.id
+        });
+      }
+    }
+  }
+
+  const canvas = workspaceConfig?.canvas;
+  for (const tab of canvas?.tabs || []) {
+    for (const widget of tab.widgets || []) {
+      push(widget, { dashboardId: null, dashboardName: null, tabId: tab.id, tabName: tab.name, widgetId: widget.id });
+    }
+  }
+  for (const widget of canvas?.widgets || []) {
+    push(widget, { dashboardId: null, dashboardName: null, tabId: null, tabName: canvas.name || "Tab 1", widgetId: widget.id });
+  }
+
+  return entries;
+}
+
+function bindingColumns(binding) {
+  const fields = Array.isArray(binding?.fields) ? binding.fields : [];
+  return Array.from(new Set([...fields, "id", "label", "entityType", "provider", "lane", "status"])).filter(Boolean);
+}
+
+function deriveWidgetTable(widget, location) {
+  const config = widget.config || {};
+  const binding = config.binding && typeof config.binding === "object" && !Array.isArray(config.binding) ? config.binding : null;
+
+  if (widget.kind === "view") {
+    if (binding?.sourceType === "workspace-data-model") return null;
+    const source = config.source || widget.title || "Untitled";
+    const integration = binding?.mode === "integration";
+    const columns = integration ? bindingColumns(binding) : (Array.isArray(config.columns) ? config.columns : []);
+    const rows = integration && (binding.entityId || binding.entityLabel)
+      ? [{ id: binding.entityId || "", label: binding.entityLabel || binding.entityId || "", entityType: binding.entityType || "", provider: binding.provider || "", lane: binding.lane || "", status: binding.status || "" }]
+      : (Array.isArray(config.rows) ? config.rows : []);
+    return { source, columns, rows, binding: binding || { mode: "manual", source: "Manual rows" }, mutable: !integration, storage: "view" };
+  }
+
+  if (binding?.mode === "integration") {
+    const source = binding.entityLabel || binding.source || widget.title || "Integration reference";
+    const rows = binding.entityId || binding.entityLabel
+      ? [{ id: binding.entityId || "", label: binding.entityLabel || binding.entityId || "", entityType: binding.entityType || "", provider: binding.provider || "", lane: binding.lane || "", status: binding.status || "" }]
+      : [];
+    return { source, columns: bindingColumns(binding), rows, binding, mutable: false, storage: "integration" };
+  }
+
+  if (binding?.mode === "json" && typeof binding.json === "string") {
+    const parsed = parseJsonRows(binding.json);
+    return { source: binding.source || widget.title || "JSON binding", columns: parsed.columns, rows: parsed.rows, binding, mutable: true, storage: "json" };
+  }
+
+  if (binding?.mode === "csv" && typeof binding.csv === "string") {
+    const parsed = parseCsv(binding.csv);
+    return { source: binding.source || widget.title || "CSV binding", columns: parsed.columns, rows: parsed.rows, binding, mutable: true, storage: "csv" };
+  }
+
+  if (binding?.mode === "manual" && Array.isArray(binding.rows)) {
+    const columns = Array.from(binding.rows.reduce((set, row) => {
+      Object.keys(row || {}).forEach((key) => set.add(key));
+      return set;
+    }, new Set()));
+    return { source: binding.source || widget.title || "Manual rows", columns, rows: binding.rows, binding, mutable: true, storage: "manual-binding" };
+  }
+
+  if (widget.kind === "chart" && Array.isArray(config.values)) {
+    return {
+      source: widget.title || "Chart values",
+      columns: ["Index", "Value"],
+      rows: config.values.map((value, index) => ({ Index: index + 1, Value: value })),
+      binding: binding || { mode: "manual", source: "Chart values" },
+      mutable: true,
+      storage: "chart-values"
+    };
+  }
+
+  return null;
+}
+
+function tableId(source, columns) {
+  return `table:${source}:${columns.join("\0")}`;
+}
+
+function normalizeManualObjects(workspaceConfig) {
+  return Array.isArray(workspaceConfig?.dataModel?.objects) ? workspaceConfig.dataModel.objects : [];
+}
+
+function deriveManualObjectTable(object) {
+  const columns = Array.isArray(object.columns) ? object.columns.filter(Boolean) : [];
+  const rows = Array.isArray(object.rows) ? object.rows.filter((row) => row && typeof row === "object" && !Array.isArray(row)) : [];
+  const source = object.source || object.label || object.name || "Manual object";
+  return {
+    id: `manual-object:${object.id || source}`,
+    label: object.label || object.name || source,
+    source,
+    columns,
+    rows,
+    binding: object.binding || { mode: "manual", source: "Data Model" },
+    mutable: true,
+    storage: "manual-object",
+    objectId: object.id,
+    widgetRefs: [],
+    fieldSettings: {
+      hidden: Array.isArray(object.fieldSettings?.hidden) ? object.fieldSettings.hidden : [],
+      order: Array.isArray(object.fieldSettings?.order) ? object.fieldSettings.order : columns
+    }
+  };
+}
+
+function listWorkspaceDataModelTables(workspaceConfig) {
+  const widgetEntries = listWidgetEntries(workspaceConfig);
+  const refsByObjectId = widgetEntries.reduce((map, { widget, location }) => {
+    const binding = widget?.config?.binding;
+    if (binding?.sourceType !== "workspace-data-model" || !binding.objectId) return map;
+    const refs = map.get(binding.objectId) || [];
+    refs.push({
+      ...location,
+      widgetTitle: widget.title,
+      widgetKind: widget.kind
+    });
+    map.set(binding.objectId, refs);
+    return map;
+  }, new Map());
+  const manualObjects = normalizeManualObjects(workspaceConfig).map((object) => {
+    const table = deriveManualObjectTable(object);
+    return { ...table, widgetRefs: refsByObjectId.get(object.id) || [] };
+  });
+  const widgetTables = widgetEntries
+    .map(({ widget, location }) => {
+      const table = deriveWidgetTable(widget, location);
+      if (!table) return null;
+      return {
+        id: tableId(table.source, table.columns),
+        label: table.source,
+        source: table.source,
+        columns: table.columns,
+        rows: table.rows,
+        binding: table.binding,
+        mutable: table.mutable,
+        storage: table.storage,
+        widgetRefs: [{
+          ...location,
+          widgetTitle: widget.title,
+          widgetKind: widget.kind
+        }],
+        fieldSettings: {
+          hidden: Array.isArray(widget.config?.fieldSettings?.hidden) ? widget.config.fieldSettings.hidden : [],
+          order: Array.isArray(widget.config?.fieldSettings?.order) ? widget.config.fieldSettings.order : table.columns
+        }
+      };
+    })
+    .filter(Boolean);
+  return [...manualObjects, ...widgetTables];
+}
+
+function writeTableConfig(config, storage, columns, rows) {
+  if (storage === "view") {
+    const binding = config.binding?.mode === "manual" ? { ...config.binding, rows } : config.binding;
+    return { ...config, columns, rows, binding, fieldSettings: { hidden: config.fieldSettings?.hidden || [], order: columns } };
+  }
+  if (storage === "json") {
+    return { ...config, binding: { ...config.binding, json: JSON.stringify(rows, null, 2) } };
+  }
+  if (storage === "csv") {
+    return { ...config, binding: { ...config.binding, csv: toCsv(columns, rows) } };
+  }
+  if (storage === "manual-binding") {
+    return { ...config, binding: { ...config.binding, rows } };
+  }
+  if (storage === "chart-values") {
+    return { ...config, values: rows.map((row) => Number(row.Value)).filter((value) => Number.isFinite(value)) };
+  }
+  return config;
+}
+
+function applyTableMutation(workspaceConfig, table, mutate) {
+  if (table.storage === "manual-object") {
+    const objects = normalizeManualObjects(workspaceConfig);
+    const dataModel = workspaceConfig.dataModel && typeof workspaceConfig.dataModel === "object" && !Array.isArray(workspaceConfig.dataModel)
+      ? workspaceConfig.dataModel
+      : {};
+    return {
+      ...workspaceConfig,
+      dataModel: {
+        ...dataModel,
+        objects: objects.map((object) => {
+          if (object.id !== table.objectId) return object;
+          const current = deriveManualObjectTable(object);
+          const next = mutate({ columns: current.columns, rows: current.rows });
+          return {
+            ...object,
+            columns: next.columns,
+            rows: next.rows,
+            fieldSettings: { ...(object.fieldSettings || {}), order: next.columns }
+          };
+        })
+      }
+    };
+  }
+
+  const ids = new Set((table.widgetRefs || []).map((ref) => ref.widgetId));
+  const mutateWidgets = (widgets) => (widgets || []).map((widget) => {
+    if (!ids.has(widget.id)) return widget;
+    const current = deriveWidgetTable(widget, { widgetId: widget.id });
+    if (!current?.mutable) return widget;
+    const next = mutate({ columns: current.columns, rows: current.rows });
+    return { ...widget, config: writeTableConfig(widget.config || {}, current.storage, next.columns, next.rows) };
+  });
+
+  const dashboards = (workspaceConfig.dashboards || []).map((dashboard) => ({
+    ...dashboard,
+    tabs: (dashboard.tabs || []).map((tab) => ({ ...tab, widgets: mutateWidgets(tab.widgets) }))
+  }));
+  let canvas = workspaceConfig.canvas ? { ...workspaceConfig.canvas } : {};
+  if (Array.isArray(canvas.widgets)) canvas = { ...canvas, widgets: mutateWidgets(canvas.widgets) };
+  if (Array.isArray(canvas.tabs)) canvas = { ...canvas, tabs: canvas.tabs.map((tab) => ({ ...tab, widgets: mutateWidgets(tab.widgets) })) };
+  return { ...workspaceConfig, dashboards, canvas };
+}
+
+function slugifyObjectName(name) {
+  return String(name || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    || "object";
+}
+
+function uniqueObjectId(workspaceConfig, name) {
+  const base = slugifyObjectName(name);
+  const used = new Set(normalizeManualObjects(workspaceConfig).map((object) => object.id));
+  if (!used.has(base)) return base;
+  let index = 2;
+  while (used.has(`${base}-${index}`)) index += 1;
+  return `${base}-${index}`;
+}
+
+function createManualBusinessObject(workspaceConfig, { name, fields } = {}) {
+  const label = String(name || "").trim();
+  const columns = Array.from(new Set((Array.isArray(fields) ? fields : String(fields || "").split(","))
+    .map((field) => String(field || "").trim())
+    .filter(Boolean)));
+  if (!label || !columns.length) return workspaceConfig;
+  const dataModel = workspaceConfig.dataModel && typeof workspaceConfig.dataModel === "object" && !Array.isArray(workspaceConfig.dataModel)
+    ? workspaceConfig.dataModel
+    : {};
+  const id = uniqueObjectId(workspaceConfig, label);
+  const object = {
+    id,
+    label,
+    source: label,
+    columns,
+    rows: [],
+    binding: { mode: "manual", source: "Data Model" },
+    fieldSettings: { hidden: [], order: columns }
+  };
+  return {
+    ...workspaceConfig,
+    dataModel: {
+      ...dataModel,
+      objects: [...normalizeManualObjects(workspaceConfig), object]
+    }
+  };
+}
+
+function addTableField(workspaceConfig, table, fieldName) {
+  const name = String(fieldName || "").trim();
+  if (!name || !table.mutable) return workspaceConfig;
+  return applyTableMutation(workspaceConfig, table, ({ columns, rows }) => {
+    if (columns.includes(name)) return { columns, rows };
+    return { columns: [...columns, name], rows: rows.map((row) => ({ ...row, [name]: "" })) };
+  });
+}
+
+function addTableRow(workspaceConfig, table) {
+  if (!table.mutable) return workspaceConfig;
+  return applyTableMutation(workspaceConfig, table, ({ columns, rows }) => ({
+    columns,
+    rows: [...rows, Object.fromEntries(columns.map((column) => [column, ""]))]
+  }));
+}
+
+function updateTableCell(workspaceConfig, table, rowIndex, fieldName, value) {
+  if (!table.mutable) return workspaceConfig;
+  return applyTableMutation(workspaceConfig, table, ({ columns, rows }) => ({
+    columns,
+    rows: rows.map((row, index) => index === rowIndex ? { ...row, [fieldName]: value } : row)
+  }));
+}
+
+function deleteTableRow(workspaceConfig, table, rowIndex) {
+  if (!table.mutable) return workspaceConfig;
+  return applyTableMutation(workspaceConfig, table, ({ columns, rows }) => ({
+    columns,
+    rows: rows.filter((_, index) => index !== rowIndex)
+  }));
+}
+
+function duplicateTableRow(workspaceConfig, table, rowIndex) {
+  if (!table.mutable) return workspaceConfig;
+  return applyTableMutation(workspaceConfig, table, ({ columns, rows }) => {
+    const next = [...rows];
+    if (rows[rowIndex]) next.splice(rowIndex + 1, 0, { ...rows[rowIndex] });
+    return { columns, rows: next };
+  });
+}
+
+function appendRowsToTable(workspaceConfig, table, rowsToAppend) {
+  if (!table.mutable || !Array.isArray(rowsToAppend)) return workspaceConfig;
+  return applyTableMutation(workspaceConfig, table, ({ columns, rows }) => ({ columns, rows: [...rows, ...rowsToAppend] }));
+}
+
+function replaceTableContent(workspaceConfig, table, { columns = [], rows = [] } = {}) {
+  if (!table.mutable) return workspaceConfig;
+  return applyTableMutation(workspaceConfig, table, () => ({ columns, rows }));
+}
+
+function exportTableAsCsv(table) {
+  return toCsv(table.columns || [], table.rows || []);
+}
+
+function importTableFromCsv(text) {
+  return parseCsv(text);
+}
+
+function describeBindingLane(binding) {
+  if (binding?.mode === "integration" && binding.lane === "data-source") return "data-source";
+  if (binding?.mode === "integration" && binding.lane === "workspace-integration") return "workspace-integration";
+  if (binding?.mode === "integration") return "integration";
+  return "manual";
+}
+
+function describeBindingMode(binding) {
+  const lane = describeBindingLane(binding);
+  if (lane === "data-source") return { label: "Data source scope", description: "Integration reference selected in the existing widget source flow. Dynamic data resolves through the governed server-side integration path." };
+  if (lane === "workspace-integration") return { label: "Workspace tool scope", description: "Workspace integration reference selected in the existing widget source flow." };
+  if (lane === "integration") return { label: "Integration scope", description: "Integration reference stored on widget.config.binding." };
+  return { label: "Manual local table", description: "Rows and fields live in the existing widget config and travel with workspace export/import." };
+}
+
+export {
+  addTableField,
+  addTableRow,
+  appendRowsToTable,
+  createManualBusinessObject,
+  deleteTableRow,
+  describeBindingLane,
+  describeBindingMode,
+  duplicateTableRow,
+  exportTableAsCsv,
+  importTableFromCsv,
+  listWorkspaceDataModelTables,
+  replaceTableContent,
+  updateTableCell
+};