@dataverse-kit/form-runtime 0.1.0

package/dist/businessRules-U1_MBgyG.d.ts

@@ -0,0 +1,372 @@
+/**
+ * Business Rules Engine — Type Definitions
+ *
+ * Defines the complete type system for visual business rules:
+ * rule definitions, conditions, actions, variables, data sources,
+ * execution context, workflows, highlights, and canvas layout.
+ *
+ * Design principles:
+ * - FetchXML-style operator names (eq, gt, like) for Dynamics consultant familiarity
+ * - Discriminated unions with `kind` for exhaustive pattern matching on action configs
+ * - Record<string, unknown> for JSON-serializable state (not Map/Set)
+ * - Reuses existing FormDataSource for FetchXML data sources
+ */
+
+/** A complete business rule — stored at entity level, enforced at form level */
+interface BusinessRuleDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    /** Entity logical name (e.g., "stn_order", "account") */
+    entityLogicalName: string;
+    /** Where the rule runs */
+    scope: 'entity' | 'form' | 'global';
+    /** For form-scoped rules */
+    targetFormId?: string;
+    /** When the rule evaluates */
+    trigger: RuleTrigger;
+    /** Execution priority (lower = first) */
+    priority: number;
+    /** Active/inactive toggle */
+    enabled: boolean;
+    /** Rule-specific data sources (beyond form-level shared ones) */
+    dataSources: RuleDataSource[];
+    /** Variables computed from data sources, fields, or expressions */
+    variables: RuleVariable[];
+    /** The IF condition tree */
+    conditionTree: RuleConditionGroup;
+    /** Actions when condition is TRUE */
+    thenActions: RuleAction[];
+    /** Actions when condition is FALSE */
+    elseActions: RuleAction[];
+    /** Visual layout for SVG canvas (Phase 2b) */
+    canvas?: RuleCanvasLayout;
+    /** Metadata */
+    createdAt: string;
+    updatedAt: string;
+    createdBy?: string;
+}
+interface RuleTrigger {
+    type: 'onLoad' | 'onChange' | 'onSave' | 'manual';
+    /** For onChange: which fields trigger re-evaluation */
+    watchFields?: string[];
+    /** For manual: command/button id */
+    commandId?: string;
+}
+/** Event that triggers rule evaluation */
+interface TriggerEvent {
+    type: RuleTrigger['type'];
+    /** For onChange: which field changed */
+    fieldName?: string;
+}
+/** A group of conditions joined by AND/OR */
+interface RuleConditionGroup {
+    id: string;
+    logic: 'and' | 'or';
+    conditions: (RuleCondition | RuleConditionGroup)[];
+}
+/** A single condition that evaluates to true/false */
+interface RuleCondition {
+    id: string;
+    /** Left-hand side source */
+    source: 'field' | 'data-source' | 'calculated' | 'form-state';
+    /** Field logical name (when source = 'field' or 'form-state') */
+    fieldName?: string;
+    /** Comparison operator — matches FetchXML operator names */
+    operator: ConditionOperator;
+    /** Right-hand side literal value */
+    value?: ConditionValue;
+    /** Right-hand side is another field */
+    compareToField?: string;
+    /** Data source reference (when source = 'data-source') */
+    dataSourceId?: string;
+    dataSourceField?: string;
+    /** Expression string (when source = 'calculated') */
+    expression?: string;
+}
+/** Type guard: is this a condition group (has `logic`) or a leaf condition? */
+declare function isConditionGroup(c: RuleCondition | RuleConditionGroup): c is RuleConditionGroup;
+/** Operators match FetchXML names for consultant familiarity */
+type ConditionOperator = 'eq' | 'ne' | 'gt' | 'ge' | 'lt' | 'le' | 'like' | 'not-like' | 'begins-with' | 'ends-with' | 'null' | 'not-null' | 'between' | 'in' | 'not-in' | 'contain-values' | 'not-contain-values' | 'changed' | 'not-changed';
+type ConditionValue = string | number | boolean | null | string[] | [unknown, unknown];
+interface RuleAction {
+    id: string;
+    type: RuleActionType;
+    /** Primary target — always synced to targets[0] */
+    target: ActionTarget;
+    /** Multi-target list (when action applies to multiple fields/sections/tabs) */
+    targets?: ActionTarget[];
+    /** Optional label for the target group (e.g., "Meter Fields") */
+    groupName?: string;
+    config: ActionConfig;
+    /** Execution order within the branch */
+    order: number;
+}
+/** Returns targets array, falling back to [action.target] for legacy data */
+declare function getActionTargets(action: RuleAction): ActionTarget[];
+type RuleActionType = 'setFieldValue' | 'setDefaultValue' | 'setVisibility' | 'setLockState' | 'setRequired' | 'showErrorMessage' | 'showRecommendation' | 'setHighlight' | 'setSectionVisibility' | 'setTabVisibility' | 'setSectionLockState' | 'setFormReadOnly' | 'setFormNotification' | 'preventSave' | 'setButtonVisibility' | 'setButtonEnabled' | 'blockCreate' | 'blockUpdate' | 'blockDelete' | 'callCustomAction' | 'callCustomApi' | 'triggerWorkflow' | 'navigateToForm' | 'openDialog';
+interface ActionTarget {
+    type: 'field' | 'section' | 'tab' | 'form' | 'button' | 'control';
+    /** Control name, section id, tab id, or form id */
+    id: string;
+    displayName?: string;
+}
+type ActionConfig = SetFieldValueConfig | SetDefaultValueConfig | SetVisibilityConfig | SetLockConfig | SetRequiredConfig | ShowMessageConfig | SetHighlightConfig | SetFormReadOnlyConfig | SetFormNotificationConfig | PreventSaveConfig | CrudBlockConfig | CallApiConfig | TriggerWorkflowConfig | NavigateToFormConfig | OpenDialogConfig;
+interface SetFieldValueConfig {
+    kind: 'setFieldValue';
+    source: 'constant' | 'variable' | 'expression' | 'field';
+    value: unknown;
+}
+interface SetDefaultValueConfig {
+    kind: 'setDefaultValue';
+    source: 'constant' | 'variable' | 'expression' | 'field';
+    value: unknown;
+    /** Only apply if field is currently empty */
+    onlyIfEmpty: boolean;
+}
+interface SetVisibilityConfig {
+    kind: 'setVisibility';
+    visible: boolean;
+}
+interface SetLockConfig {
+    kind: 'setLock';
+    locked: boolean;
+}
+interface SetRequiredConfig {
+    kind: 'setRequired';
+    level: 'required' | 'recommended' | 'none';
+}
+interface ShowMessageConfig {
+    kind: 'showMessage';
+    messageType: 'error' | 'warning' | 'info' | 'recommendation';
+    message: string;
+    /** Supports {{variableName}} interpolation */
+    interpolateVariables: boolean;
+}
+interface SetHighlightConfig {
+    kind: 'setHighlight';
+    /** Hex color (e.g., "#63d868") */
+    color: string;
+    /** Higher priority wins when multiple rules match */
+    priority: number;
+}
+interface SetFormReadOnlyConfig {
+    kind: 'setFormReadOnly';
+    readOnly: boolean;
+}
+interface SetFormNotificationConfig {
+    kind: 'setFormNotification';
+    messageType: 'error' | 'warning' | 'info';
+    message: string;
+    interpolateVariables: boolean;
+}
+interface PreventSaveConfig {
+    kind: 'preventSave';
+    message: string;
+}
+interface CrudBlockConfig {
+    kind: 'crudBlock';
+    operation: 'create' | 'update' | 'delete';
+    message?: string;
+}
+interface CallApiConfig {
+    kind: 'callApi';
+    dataSourceId: string;
+    resultVariableId?: string;
+    onSuccessActions?: RuleAction[];
+    onFailureActions?: RuleAction[];
+}
+interface TriggerWorkflowConfig {
+    kind: 'triggerWorkflow';
+    workflowId: string;
+}
+interface NavigateToFormConfig {
+    kind: 'navigateToForm';
+    formId: string;
+    /** Pass field values to the target form */
+    parameterMapping?: Record<string, string>;
+}
+interface OpenDialogConfig {
+    kind: 'openDialog';
+    formId: string;
+    width?: number;
+    height?: number;
+}
+interface RuleVariable {
+    id: string;
+    name: string;
+    displayName: string;
+    type: 'string' | 'number' | 'boolean' | 'datetime' | 'lookup' | 'optionset';
+    source: {
+        kind: 'field';
+        fieldName: string;
+    } | {
+        kind: 'dataSource';
+        dataSourceId: string;
+        outputField: string;
+    } | {
+        kind: 'expression';
+        expression: string;
+    } | {
+        kind: 'constant';
+        value: unknown;
+    } | {
+        kind: 'context';
+        contextPath: string;
+    };
+    defaultValue?: unknown;
+}
+/**
+ * Rule data source — wraps existing FormDataSource with caching,
+ * or defines a Custom Action / API source.
+ */
+interface RuleDataSource {
+    id: string;
+    name: string;
+    displayName: string;
+    type: 'fetchXml' | 'aggregateFetchXml' | 'customAction' | 'customApi';
+    /**
+     * For fetchXml/aggregateFetchXml: reference an existing FormDataSource by id.
+     * Avoids duplicating FetchXML definitions.
+     */
+    formDataSourceId?: string;
+    /**
+     * Inline FetchXML when not referencing a shared FormDataSource.
+     * Supports {{fieldName}} placeholders.
+     */
+    fetchXml?: string;
+    /** Custom Action / API configuration (Phase 3) */
+    apiConfig?: {
+        actionName: string;
+        inputParameters: ApiParameter[];
+        outputParameters: ApiParameter[];
+    };
+    /** Caching strategy */
+    cache: {
+        enabled: boolean;
+        ttlSeconds: number;
+        invalidateOn?: string[];
+    };
+}
+interface ApiParameter {
+    name: string;
+    type: string;
+    source: 'field' | 'variable' | 'constant';
+    value: string;
+}
+/** Full runtime context — plain objects for JSON-serializable portions */
+interface RuleExecutionContext {
+    /** Current form field values */
+    formData: Record<string, unknown>;
+    /** Original values at load time (for dirty detection) */
+    originalData: Record<string, unknown>;
+    /** Fields changed since load (runtime only, not serialized) */
+    dirtyFields: Set<string>;
+    /** Resolved data source results */
+    dataSourceResults: Record<string, unknown>;
+    /** Resolved variable values */
+    variableValues: Record<string, unknown>;
+    /** Form-level state */
+    formState: {
+        isNew: boolean;
+        isDirty: boolean;
+        isValid: boolean;
+        isSaving: boolean;
+        formId: string;
+        entityLogicalName: string;
+        recordId?: string;
+        lastSaved?: string;
+    };
+    /** Custom Action results (Phase 3) */
+    customActionResults: Record<string, unknown>;
+}
+interface RuleExecutionResult {
+    ruleId: string;
+    ruleName: string;
+    conditionMet: boolean;
+    actionsExecuted: ActionResult[];
+    error?: string;
+    durationMs: number;
+}
+interface ActionResult {
+    actionId: string;
+    actionType: RuleActionType;
+    targetId: string;
+    success: boolean;
+    error?: string;
+}
+interface FieldState {
+    visible: boolean;
+    locked: boolean;
+    required: 'required' | 'recommended' | 'none';
+    errorMessage?: string;
+    warningMessage?: string;
+    recommendationMessage?: string;
+    highlightColor?: string;
+}
+interface SectionState {
+    visible: boolean;
+    locked: boolean;
+}
+interface TabState {
+    visible: boolean;
+}
+interface FormNotification {
+    id: string;
+    type: 'error' | 'warning' | 'info';
+    message: string;
+    ruleId: string;
+}
+interface WorkflowDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    trigger: 'on-save' | 'on-field-change' | 'on-load' | 'manual';
+    triggerField?: string;
+    steps: WorkflowStep[];
+}
+interface WorkflowStep {
+    id: string;
+    type: 'validate' | 'save' | 'call-action' | 'refresh' | 'evaluate-rules' | 'set-field';
+    actionName?: string;
+    fieldName?: string;
+    fieldValue?: unknown;
+    onError: 'stop' | 'continue' | 'rollback';
+}
+interface WorkflowResult {
+    workflowId: string;
+    success: boolean;
+    steps: WorkflowStepResult[];
+}
+interface WorkflowStepResult {
+    stepId: string;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+}
+interface RuleCanvasLayout {
+    nodes: CanvasNode[];
+    connections: CanvasConnection[];
+    zoom: number;
+    panX: number;
+    panY: number;
+}
+interface CanvasNode {
+    id: string;
+    type: 'condition' | 'action' | 'branch';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface CanvasConnection {
+    fromNodeId: string;
+    toNodeId: string;
+    type: 'then' | 'else' | 'sequence';
+}
+/** Creates a minimal empty rule definition */
+declare function createDefaultBusinessRule(entityLogicalName: string, name?: string): BusinessRuleDefinition;
+/** Creates a default field state (visible, unlocked, not required) */
+declare function createDefaultFieldState(): FieldState;
+
+export { type ActionConfig as A, type BusinessRuleDefinition as B, type CallApiConfig as C, type ShowMessageConfig as D, type TriggerEvent as E, type FieldState as F, type TriggerWorkflowConfig as G, type WorkflowResult as H, type WorkflowStep as I, type WorkflowStepResult as J, createDefaultBusinessRule as K, createDefaultFieldState as L, getActionTargets as M, type NavigateToFormConfig as N, type OpenDialogConfig as O, type PreventSaveConfig as P, isConditionGroup as Q, type RuleAction as R, type SectionState as S, type TabState as T, type WorkflowDefinition as W, type ActionResult as a, type ActionTarget as b, type ApiParameter as c, type CanvasConnection as d, type CanvasNode as e, type ConditionOperator as f, type ConditionValue as g, type CrudBlockConfig as h, type FormNotification as i, type RuleActionType as j, type RuleCanvasLayout as k, type RuleCondition as l, type RuleConditionGroup as m, type RuleDataSource as n, type RuleExecutionContext as o, type RuleExecutionResult as p, type RuleTrigger as q, type RuleVariable as r, type SetDefaultValueConfig as s, type SetFieldValueConfig as t, type SetFormNotificationConfig as u, type SetFormReadOnlyConfig as v, type SetHighlightConfig as w, type SetLockConfig as x, type SetRequiredConfig as y, type SetVisibilityConfig as z };

package/dist/context.cjs

@@ -0,0 +1,151 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/context/index.ts
+var context_exports = {};
+__export(context_exports, {
+  CalloutsProvider: () => CalloutsProvider,
+  FormRuntimeProvider: () => FormRuntimeProvider,
+  RuleStatesProvider: () => RuleStatesProvider,
+  TabContentSlotsProvider: () => TabContentSlotsProvider,
+  useCallout: () => useCallout,
+  useFieldState: () => useFieldState,
+  useFormRuntimeContext: () => useFormRuntimeContext,
+  useOptionalFormRuntimeContext: () => useOptionalFormRuntimeContext,
+  useRuleStates: () => useRuleStates,
+  useSectionState: () => useSectionState,
+  useTabContentSlots: () => useTabContentSlots,
+  useTabState: () => useTabState
+});
+module.exports = __toCommonJS(context_exports);
+
+// src/context/FormRuntimeContext.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var FormRuntimeContext = (0, import_react.createContext)(null);
+FormRuntimeContext.displayName = "FormRuntimeContext";
+var FormRuntimeProvider = ({
+  capabilities,
+  children
+}) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FormRuntimeContext.Provider, { value: capabilities, children });
+function useFormRuntimeContext() {
+  const value = (0, import_react.useContext)(FormRuntimeContext);
+  if (value === null) {
+    throw new Error(
+      "[@dataverse-kit/form-runtime] useFormRuntimeContext was called outside of a <FormRuntimeProvider>. Wrap your <FormRuntime> mount with a provider that supplies FormRuntimeCapabilities (the editor app uses EditorFormRuntimeProvider; generated host code uses ServiceFactory-backed capabilities). See packages/form-runtime/src/context/FormRuntimeContext.tsx."
+    );
+  }
+  return value;
+}
+function useOptionalFormRuntimeContext() {
+  return (0, import_react.useContext)(FormRuntimeContext);
+}
+
+// src/context/CalloutsContext.tsx
+var import_react2 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var EMPTY = { byId: /* @__PURE__ */ new Map() };
+var CalloutsContext = (0, import_react2.createContext)(EMPTY);
+CalloutsContext.displayName = "CalloutsContext";
+var CalloutsProvider = ({ callouts, children }) => {
+  const value = (0, import_react2.useMemo)(() => {
+    if (!callouts || callouts.length === 0) return EMPTY;
+    return { byId: new Map(callouts.map((c) => [c.id, c])) };
+  }, [callouts]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(CalloutsContext.Provider, { value, children });
+};
+function useCallout(id) {
+  const ctx = (0, import_react2.useContext)(CalloutsContext);
+  if (!id) return void 0;
+  return ctx.byId.get(id);
+}
+
+// src/context/RuleStatesContext.tsx
+var import_react3 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var EMPTY2 = {
+  fieldStates: {},
+  sectionStates: {},
+  tabStates: {}
+};
+var RuleStatesContext = (0, import_react3.createContext)(EMPTY2);
+RuleStatesContext.displayName = "RuleStatesContext";
+var RuleStatesProvider = ({
+  fieldStates,
+  sectionStates,
+  tabStates,
+  children
+}) => {
+  const value = (0, import_react3.useMemo)(
+    () => ({
+      fieldStates: fieldStates ?? {},
+      sectionStates: sectionStates ?? {},
+      tabStates: tabStates ?? {}
+    }),
+    [fieldStates, sectionStates, tabStates]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(RuleStatesContext.Provider, { value, children });
+};
+function useRuleStates() {
+  return (0, import_react3.useContext)(RuleStatesContext);
+}
+function useFieldState(controlName) {
+  const ctx = (0, import_react3.useContext)(RuleStatesContext);
+  if (!controlName) return void 0;
+  return ctx.fieldStates[controlName];
+}
+function useSectionState(sectionId) {
+  return (0, import_react3.useContext)(RuleStatesContext).sectionStates[sectionId];
+}
+function useTabState(tabId) {
+  return (0, import_react3.useContext)(RuleStatesContext).tabStates[tabId];
+}
+
+// src/context/TabContentSlotsContext.tsx
+var import_react4 = require("react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var EMPTY3 = {};
+var TabContentSlotsContext = (0, import_react4.createContext)(EMPTY3);
+TabContentSlotsContext.displayName = "TabContentSlotsContext";
+var TabContentSlotsProvider = ({
+  slots,
+  children
+}) => {
+  const value = (0, import_react4.useMemo)(() => slots ?? EMPTY3, [slots]);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(TabContentSlotsContext.Provider, { value, children });
+};
+function useTabContentSlots() {
+  return (0, import_react4.useContext)(TabContentSlotsContext);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CalloutsProvider,
+  FormRuntimeProvider,
+  RuleStatesProvider,
+  TabContentSlotsProvider,
+  useCallout,
+  useFieldState,
+  useFormRuntimeContext,
+  useOptionalFormRuntimeContext,
+  useRuleStates,
+  useSectionState,
+  useTabContentSlots,
+  useTabState
+});
+//# sourceMappingURL=context.cjs.map

package/dist/context.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/context/index.ts","../src/context/FormRuntimeContext.tsx","../src/context/CalloutsContext.tsx","../src/context/RuleStatesContext.tsx","../src/context/TabContentSlotsContext.tsx"],"sourcesContent":["// Public surface for `@dataverse-kit/form-runtime/context`.\n\nexport {\n  FormRuntimeProvider,\n  useFormRuntimeContext,\n  useOptionalFormRuntimeContext,\n  type FormRuntimeProviderProps,\n} from './FormRuntimeContext';\n\nexport {\n  CalloutsProvider,\n  useCallout,\n  type CalloutsProviderProps,\n} from './CalloutsContext';\n\nexport {\n  RuleStatesProvider,\n  useRuleStates,\n  useFieldState,\n  useSectionState,\n  useTabState,\n  type RuleStatesProviderProps,\n  type RuleStatesContextValue,\n} from './RuleStatesContext';\n\nexport {\n  TabContentSlotsProvider,\n  useTabContentSlots,\n  type TabContentSlots,\n  type TabContentSlotsProviderProps,\n} from './TabContentSlotsContext';\n\nexport type {\n  FormRuntimeCapabilities,\n  FormRuntimeConnection,\n  FormRuntimePreviewContext,\n  LiveDataResult,\n  WebResourceData,\n  LookupResult,\n  LookupSearchOptions,\n  TimelineItem,\n} from '../types/runtime-capabilities';\n","import React, { createContext, useContext } from 'react';\nimport type { FormRuntimeCapabilities } from '../types/runtime-capabilities';\n\n/**\n * Context that exposes editor- or host-supplied async capabilities to\n * the runtime's controls.\n *\n * Two implementations exist (Phase 1 Task 6.5 onwards):\n * - `EditorFormRuntimeProvider` in `apps/form-builder/src/contexts/` —\n *   wires capabilities to the form-builder's Zustand stores (designer,\n *   dataverse, previewRecord, gridCustomizer).\n * - Generated host code's provider (Phase 3) — wires capabilities to\n *   `IApiService` from `@dataverse-kit/api-service`.\n *\n * Per `feedback_v1_migrations`, the runtime DOES NOT define a default\n * mock or no-op provider. Controls that depend on capabilities throw if\n * the consumer hasn't wrapped them in a provider — the error names the\n * provider that's expected, so the failure points at the integration\n * gap rather than masking it with silent no-ops.\n */\nconst FormRuntimeContext = createContext<FormRuntimeCapabilities | null>(null);\n\nFormRuntimeContext.displayName = 'FormRuntimeContext';\n\nexport interface FormRuntimeProviderProps {\n  capabilities: FormRuntimeCapabilities;\n  children: React.ReactNode;\n}\n\n/**\n * Provider wrapper. Caller supplies a `FormRuntimeCapabilities` value;\n * descendants read it via `useFormRuntimeContext()`. Wrap the runtime's\n * mount point (`<FormRuntime>`) with this; failing to do so causes\n * capability-consuming controls to throw on first render.\n */\nexport const FormRuntimeProvider: React.FC<FormRuntimeProviderProps> = ({\n  capabilities,\n  children,\n}) => <FormRuntimeContext.Provider value={capabilities}>{children}</FormRuntimeContext.Provider>;\n\n/**\n * Hook for runtime-internal callers that REQUIRE capabilities. Throws\n * with a directed error message if no provider is present so the\n * integration gap is visible at the call site (rather than a vague\n * \"Cannot read properties of null\" that points at the consumer).\n */\nexport function useFormRuntimeContext(): FormRuntimeCapabilities {\n  const value = useContext(FormRuntimeContext);\n  if (value === null) {\n    throw new Error(\n      '[@dataverse-kit/form-runtime] useFormRuntimeContext was called outside of a ' +\n        '<FormRuntimeProvider>. Wrap your <FormRuntime> mount with a provider that ' +\n        'supplies FormRuntimeCapabilities (the editor app uses ' +\n        'EditorFormRuntimeProvider; generated host code uses ServiceFactory-backed ' +\n        'capabilities). See packages/form-runtime/src/context/FormRuntimeContext.tsx.',\n    );\n  }\n  return value;\n}\n\n/**\n * Same as `useFormRuntimeContext()` but returns `null` when no provider\n * is present. Use for OPTIONAL capability access — controls that have a\n * sensible offline rendering (e.g. timeline, which renders a placeholder\n * when not connected) prefer this over the throwing variant.\n */\nexport function useOptionalFormRuntimeContext(): FormRuntimeCapabilities | null {\n  return useContext(FormRuntimeContext);\n}\n","/**\n * CalloutsContext — exposes `form.callouts` to descendants so\n * SectionShell's CellShell can look up the CalloutDefinition that a\n * control's `calloutId` references without prop-drilling the array\n * through every shell layer.\n *\n * The runtime emits a provider once, at the FormRuntime mount point;\n * shells use {@link useCallout} to resolve an id to its definition (or\n * undefined when no provider is mounted, when the array is empty, or\n * when the id doesn't match — all of which should render the host\n * control without callout chrome).\n */\n\nimport React, { createContext, useContext, useMemo } from 'react';\nimport type { CalloutDefinition } from '../types';\n\ninterface CalloutsContextValue {\n  /** Map from callout id -> definition for O(1) lookup. */\n  byId: Map<string, CalloutDefinition>;\n}\n\nconst EMPTY: CalloutsContextValue = { byId: new Map() };\n\nconst CalloutsContext = createContext<CalloutsContextValue>(EMPTY);\nCalloutsContext.displayName = 'CalloutsContext';\n\nexport interface CalloutsProviderProps {\n  callouts?: CalloutDefinition[];\n  children: React.ReactNode;\n}\n\nexport const CalloutsProvider: React.FC<CalloutsProviderProps> = ({ callouts, children }) => {\n  const value = useMemo<CalloutsContextValue>(() => {\n    if (!callouts || callouts.length === 0) return EMPTY;\n    return { byId: new Map(callouts.map((c) => [c.id, c])) };\n  }, [callouts]);\n  return <CalloutsContext.Provider value={value}>{children}</CalloutsContext.Provider>;\n};\n\n/**\n * Look up a callout by id. Returns undefined when no provider is\n * mounted, when the id is undefined, or when no callout with that id\n * exists — all should render the host control without chrome.\n */\nexport function useCallout(id: string | undefined): CalloutDefinition | undefined {\n  const ctx = useContext(CalloutsContext);\n  if (!id) return undefined;\n  return ctx.byId.get(id);\n}\n","/**\n * RuleStatesContext — exposes business-rule evaluation outputs\n * (fieldStates / sectionStates / tabStates) to the runtime's shells so\n * they can gate visibility and override control props (readOnly,\n * required) at render time.\n *\n * The runtime does NOT own the rule engine — that's editor/host state.\n * It only consumes pre-computed state maps. The form-builder's\n * `useRuleExecutionStore` feeds these in via FormRuntime's `ruleStates`\n * prop; generated apps pass equivalent maps from their host integration.\n *\n * Missing entries are treated as \"no rule constraint\" — the underlying\n * control's own props (hidden / readOnly / required) take effect. This\n * matches the legacy SectionPreview's fallthrough behavior.\n */\n\nimport React, { createContext, useContext, useMemo } from 'react';\nimport type { FieldState, SectionState, TabState } from '../types/businessRules';\n\nexport interface RuleStatesContextValue {\n  fieldStates: Record<string, FieldState>;\n  sectionStates: Record<string, SectionState>;\n  tabStates: Record<string, TabState>;\n}\n\nconst EMPTY: RuleStatesContextValue = {\n  fieldStates: {},\n  sectionStates: {},\n  tabStates: {},\n};\n\nconst RuleStatesContext = createContext<RuleStatesContextValue>(EMPTY);\nRuleStatesContext.displayName = 'RuleStatesContext';\n\nexport interface RuleStatesProviderProps {\n  fieldStates?: Record<string, FieldState>;\n  sectionStates?: Record<string, SectionState>;\n  tabStates?: Record<string, TabState>;\n  children: React.ReactNode;\n}\n\nexport const RuleStatesProvider: React.FC<RuleStatesProviderProps> = ({\n  fieldStates,\n  sectionStates,\n  tabStates,\n  children,\n}) => {\n  const value = useMemo<RuleStatesContextValue>(\n    () => ({\n      fieldStates: fieldStates ?? {},\n      sectionStates: sectionStates ?? {},\n      tabStates: tabStates ?? {},\n    }),\n    [fieldStates, sectionStates, tabStates],\n  );\n  return <RuleStatesContext.Provider value={value}>{children}</RuleStatesContext.Provider>;\n};\n\n/**\n * Returns the full rule-state maps. Use this when you need to walk\n * multiple field/section ids in a single render pass (e.g. RowShell\n * checking \"is every cell in this row hidden\") — avoids violating\n * the rules of hooks by calling useFieldState in a loop.\n */\nexport function useRuleStates(): RuleStatesContextValue {\n  return useContext(RuleStatesContext);\n}\n\n/** Returns the field's rule state, or undefined if no rule has set one. */\nexport function useFieldState(controlName: string | undefined): FieldState | undefined {\n  const ctx = useContext(RuleStatesContext);\n  if (!controlName) return undefined;\n  return ctx.fieldStates[controlName];\n}\n\n/** Returns the section's rule state, or undefined if no rule has set one. */\nexport function useSectionState(sectionId: string): SectionState | undefined {\n  return useContext(RuleStatesContext).sectionStates[sectionId];\n}\n\n/** Returns the tab's rule state, or undefined if no rule has set one. */\nexport function useTabState(tabId: string): TabState | undefined {\n  return useContext(RuleStatesContext).tabStates[tabId];\n}\n","/**\n * TabContentSlotsContext — pluggable render slots for non-main tabs\n * (related-records, audit-history). The runtime ships a placeholder\n * for these tab types because they depend on host-specific concerns\n * (dataverse queries, related-record metadata) that don't belong in\n * the runtime itself.\n *\n * Hosts that want full fidelity (form-builder preview, generated\n * apps) provide render functions for these slots via\n * `TabContentSlotsProvider`. TabsShell consumes them via\n * `useTabContentSlots()`; missing slots fall through to the\n * placeholder.\n *\n * Phase 3 m6 — replaces the legacy preview's direct imports of\n * RelatedTabPreview / AuditTabPreview without making the runtime\n * depend on either component.\n */\n\nimport React, { createContext, useContext, useMemo } from 'react';\nimport type { RelatedFormTab, AuditFormTab } from '../types';\n\nexport interface TabContentSlots {\n  /** Render override for related-records tabs. */\n  renderRelatedTab?: (tab: RelatedFormTab) => React.ReactNode;\n  /** Render override for audit-history tabs. */\n  renderAuditTab?: (tab: AuditFormTab) => React.ReactNode;\n}\n\nconst EMPTY: TabContentSlots = {};\n\nconst TabContentSlotsContext = createContext<TabContentSlots>(EMPTY);\nTabContentSlotsContext.displayName = 'TabContentSlotsContext';\n\nexport interface TabContentSlotsProviderProps {\n  slots?: TabContentSlots;\n  children: React.ReactNode;\n}\n\nexport const TabContentSlotsProvider: React.FC<TabContentSlotsProviderProps> = ({\n  slots,\n  children,\n}) => {\n  const value = useMemo<TabContentSlots>(() => slots ?? EMPTY, [slots]);\n  return <TabContentSlotsContext.Provider value={value}>{children}</TabContentSlotsContext.Provider>;\n};\n\nexport function useTabContentSlots(): TabContentSlots {\n  return useContext(TabContentSlotsContext);\n}\n"],"mappings":"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","names":["import_react","import_jsx_runtime","import_react","import_jsx_runtime","EMPTY","import_react","import_jsx_runtime","EMPTY"]}

package/dist/context.d.cts

@@ -0,0 +1,132 @@
+import React from 'react';
+import { F as FormRuntimeCapabilities } from './runtime-capabilities-BdGDdu0d.cjs';
+export { a as FormRuntimeConnection, b as FormRuntimePreviewContext, L as LiveDataResult, c as LookupResult, d as LookupSearchOptions, T as TimelineItem, W as WebResourceData } from './runtime-capabilities-BdGDdu0d.cjs';
+import { h as CalloutDefinition, ai as RelatedFormTab, A as AuditFormTab } from './control-DFOg_pc_.cjs';
+import { F as FieldState, S as SectionState, T as TabState } from './businessRules-U1_MBgyG.cjs';
+import './theme-BfeZIxmZ.cjs';
+
+interface FormRuntimeProviderProps {
+    capabilities: FormRuntimeCapabilities;
+    children: React.ReactNode;
+}
+/**
+ * Provider wrapper. Caller supplies a `FormRuntimeCapabilities` value;
+ * descendants read it via `useFormRuntimeContext()`. Wrap the runtime's
+ * mount point (`<FormRuntime>`) with this; failing to do so causes
+ * capability-consuming controls to throw on first render.
+ */
+declare const FormRuntimeProvider: React.FC<FormRuntimeProviderProps>;
+/**
+ * Hook for runtime-internal callers that REQUIRE capabilities. Throws
+ * with a directed error message if no provider is present so the
+ * integration gap is visible at the call site (rather than a vague
+ * "Cannot read properties of null" that points at the consumer).
+ */
+declare function useFormRuntimeContext(): FormRuntimeCapabilities;
+/**
+ * Same as `useFormRuntimeContext()` but returns `null` when no provider
+ * is present. Use for OPTIONAL capability access — controls that have a
+ * sensible offline rendering (e.g. timeline, which renders a placeholder
+ * when not connected) prefer this over the throwing variant.
+ */
+declare function useOptionalFormRuntimeContext(): FormRuntimeCapabilities | null;
+
+/**
+ * CalloutsContext — exposes `form.callouts` to descendants so
+ * SectionShell's CellShell can look up the CalloutDefinition that a
+ * control's `calloutId` references without prop-drilling the array
+ * through every shell layer.
+ *
+ * The runtime emits a provider once, at the FormRuntime mount point;
+ * shells use {@link useCallout} to resolve an id to its definition (or
+ * undefined when no provider is mounted, when the array is empty, or
+ * when the id doesn't match — all of which should render the host
+ * control without callout chrome).
+ */
+
+interface CalloutsProviderProps {
+    callouts?: CalloutDefinition[];
+    children: React.ReactNode;
+}
+declare const CalloutsProvider: React.FC<CalloutsProviderProps>;
+/**
+ * Look up a callout by id. Returns undefined when no provider is
+ * mounted, when the id is undefined, or when no callout with that id
+ * exists — all should render the host control without chrome.
+ */
+declare function useCallout(id: string | undefined): CalloutDefinition | undefined;
+
+/**
+ * RuleStatesContext — exposes business-rule evaluation outputs
+ * (fieldStates / sectionStates / tabStates) to the runtime's shells so
+ * they can gate visibility and override control props (readOnly,
+ * required) at render time.
+ *
+ * The runtime does NOT own the rule engine — that's editor/host state.
+ * It only consumes pre-computed state maps. The form-builder's
+ * `useRuleExecutionStore` feeds these in via FormRuntime's `ruleStates`
+ * prop; generated apps pass equivalent maps from their host integration.
+ *
+ * Missing entries are treated as "no rule constraint" — the underlying
+ * control's own props (hidden / readOnly / required) take effect. This
+ * matches the legacy SectionPreview's fallthrough behavior.
+ */
+
+interface RuleStatesContextValue {
+    fieldStates: Record<string, FieldState>;
+    sectionStates: Record<string, SectionState>;
+    tabStates: Record<string, TabState>;
+}
+interface RuleStatesProviderProps {
+    fieldStates?: Record<string, FieldState>;
+    sectionStates?: Record<string, SectionState>;
+    tabStates?: Record<string, TabState>;
+    children: React.ReactNode;
+}
+declare const RuleStatesProvider: React.FC<RuleStatesProviderProps>;
+/**
+ * Returns the full rule-state maps. Use this when you need to walk
+ * multiple field/section ids in a single render pass (e.g. RowShell
+ * checking "is every cell in this row hidden") — avoids violating
+ * the rules of hooks by calling useFieldState in a loop.
+ */
+declare function useRuleStates(): RuleStatesContextValue;
+/** Returns the field's rule state, or undefined if no rule has set one. */
+declare function useFieldState(controlName: string | undefined): FieldState | undefined;
+/** Returns the section's rule state, or undefined if no rule has set one. */
+declare function useSectionState(sectionId: string): SectionState | undefined;
+/** Returns the tab's rule state, or undefined if no rule has set one. */
+declare function useTabState(tabId: string): TabState | undefined;
+
+/**
+ * TabContentSlotsContext — pluggable render slots for non-main tabs
+ * (related-records, audit-history). The runtime ships a placeholder
+ * for these tab types because they depend on host-specific concerns
+ * (dataverse queries, related-record metadata) that don't belong in
+ * the runtime itself.
+ *
+ * Hosts that want full fidelity (form-builder preview, generated
+ * apps) provide render functions for these slots via
+ * `TabContentSlotsProvider`. TabsShell consumes them via
+ * `useTabContentSlots()`; missing slots fall through to the
+ * placeholder.
+ *
+ * Phase 3 m6 — replaces the legacy preview's direct imports of
+ * RelatedTabPreview / AuditTabPreview without making the runtime
+ * depend on either component.
+ */
+
+interface TabContentSlots {
+    /** Render override for related-records tabs. */
+    renderRelatedTab?: (tab: RelatedFormTab) => React.ReactNode;
+    /** Render override for audit-history tabs. */
+    renderAuditTab?: (tab: AuditFormTab) => React.ReactNode;
+}
+interface TabContentSlotsProviderProps {
+    slots?: TabContentSlots;
+    children: React.ReactNode;
+}
+declare const TabContentSlotsProvider: React.FC<TabContentSlotsProviderProps>;
+declare function useTabContentSlots(): TabContentSlots;
+
+export { CalloutsProvider, type CalloutsProviderProps, FormRuntimeCapabilities, FormRuntimeProvider, type FormRuntimeProviderProps, type RuleStatesContextValue, RuleStatesProvider, type RuleStatesProviderProps, type TabContentSlots, TabContentSlotsProvider, type TabContentSlotsProviderProps, useCallout, useFieldState, useFormRuntimeContext, useOptionalFormRuntimeContext, useRuleStates, useSectionState, useTabContentSlots, useTabState };