@arkcit/engine-react 0.3.0

package/dist/index.js

@@ -0,0 +1,1371 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/materialization/materializeCoverContent.tsx
+import React from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+var materializeCoverContent = ({
+  descriptor,
+  renderSafeNode
+}) => {
+  const resolvedActionChildren = descriptor.actionNodes.map((child) => /* @__PURE__ */ jsx("span", { className: "inline-flex align-middle", children: renderSafeNode(child) }, child.id));
+  const resolvedContentChildren = descriptor.contentNodes.map((child) => /* @__PURE__ */ jsx(React.Fragment, { children: renderSafeNode(child) }, child.id));
+  return {
+    actions: resolvedActionChildren.length > 0 ? resolvedActionChildren.length === 1 ? resolvedActionChildren[0] : /* @__PURE__ */ jsx(Fragment, { children: resolvedActionChildren }) : void 0,
+    children: resolvedContentChildren.length > 0 ? resolvedContentChildren.length === 1 ? resolvedContentChildren[0] : /* @__PURE__ */ jsx(Fragment, { children: resolvedContentChildren }) : null
+  };
+};
+
+// src/composition/applyContentComposition.tsx
+var applyContentComposition = ({
+  node,
+  componentProps,
+  isStudioRendererContext,
+  internalStudioNodeTypes,
+  schemaNodes,
+  onInlineTextEdit,
+  captureFieldFocus,
+  renderSafeNode,
+  normalizeRenderableChild: normalizeRenderableChild2,
+  findNodeById,
+  runtime,
+  plans: providedPlans,
+  dependencies
+}) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const plans = providedPlans != null ? providedPlans : dependencies.resolveContentCompositionPlan({
+    node,
+    isStudioRendererContext,
+    internalStudioNodeTypes
+  });
+  if (plans.some((plan) => plan.kind === "button-toggle" && plan.disableOnClick)) {
+    delete componentProps.onClick;
+  }
+  if (plans.some((plan) => plan.kind === "form-field")) {
+    const rawProps = (_a = node.props) != null ? _a : {};
+    const existingField = componentProps.field && typeof componentProps.field === "object" && !Array.isArray(componentProps.field) ? componentProps.field : {};
+    const fieldName = String((_c = (_b = existingField.name) != null ? _b : rawProps.name) != null ? _c : "").trim();
+    const fieldType = String((_e = (_d = existingField.type) != null ? _d : rawProps.type) != null ? _e : "text");
+    const fallbackLabel = fieldName || "Field";
+    const fieldLabel = String((_g = (_f = existingField.label) != null ? _f : rawProps.label) != null ? _g : fallbackLabel);
+    componentProps.field = __spreadProps(__spreadValues(__spreadValues({}, rawProps), existingField), {
+      name: fieldName || "field",
+      type: fieldType,
+      label: fieldLabel
+    });
+    if (componentProps.value === void 0) {
+      componentProps.value = (_i = (_h = rawProps.value) != null ? _h : rawProps.defaultValue) != null ? _i : "";
+    }
+    if (!componentProps.dict || typeof componentProps.dict !== "object" || Array.isArray(componentProps.dict)) {
+      componentProps.dict = {
+        submit: "Submit",
+        reset: "Reset",
+        loading: "Loading...",
+        success: "Saved",
+        search: "Search...",
+        noResultToShow: "No result"
+      };
+    }
+    if (!componentProps.onChange) {
+      componentProps.onChange = (event) => {
+        var _a2;
+        captureFieldFocus(event.target);
+        const target = event.target;
+        const nextValue = target.type === "checkbox" ? Boolean(target.checked) : target.value;
+        const findParentFormId = (nodes, targetId, lineage = []) => {
+          var _a3, _b2;
+          for (const candidate of nodes) {
+            const nextLineage = [...lineage, candidate];
+            if (candidate.id === targetId) {
+              for (let index = nextLineage.length - 2; index >= 0; index -= 1) {
+                if (((_a3 = nextLineage[index]) == null ? void 0 : _a3.type) === "Form") {
+                  return nextLineage[index].id;
+                }
+              }
+              return null;
+            }
+            if ((_b2 = candidate.children) == null ? void 0 : _b2.length) {
+              const found = findParentFormId(candidate.children, targetId, nextLineage);
+              if (found) return found;
+            }
+          }
+          return null;
+        };
+        const parentFormId = findParentFormId(schemaNodes, node.id);
+        if (parentFormId && onInlineTextEdit && fieldName) {
+          const parentForm = findNodeById(parentFormId, schemaNodes);
+          const parentProps = (_a2 = parentForm == null ? void 0 : parentForm.props) != null ? _a2 : {};
+          const currentValues = parentProps.values && typeof parentProps.values === "object" && !Array.isArray(parentProps.values) ? parentProps.values : {};
+          onInlineTextEdit(parentFormId, "values", __spreadProps(__spreadValues({}, currentValues), {
+            [fieldName]: nextValue
+          }));
+          return;
+        }
+        onInlineTextEdit == null ? void 0 : onInlineTextEdit(node.id, "value", nextValue);
+      };
+    }
+  }
+  const studioFormPlan = plans.find((plan) => plan.kind === "studio-form");
+  if ((studioFormPlan == null ? void 0 : studioFormPlan.kind) === "studio-form") {
+    return dependencies.renderStudioForm({
+      node,
+      componentProps,
+      visibleChildren: studioFormPlan.visibleChildren,
+      runtime,
+      onInlineTextEdit,
+      captureFieldFocus,
+      renderSafeNode
+    });
+  }
+  if (isStudioRendererContext && node.type === "Form" && onInlineTextEdit) {
+    const existingStudioConfig = componentProps.studio && typeof componentProps.studio === "object" && !Array.isArray(componentProps.studio) ? componentProps.studio : {};
+    componentProps.studio = __spreadProps(__spreadValues({}, existingStudioConfig), {
+      onSubmitLabelDoubleClick: () => {
+        var _a2, _b2;
+        return onInlineTextEdit(
+          node.id,
+          "dict.submit",
+          String(
+            (_b2 = (_a2 = componentProps.dict) == null ? void 0 : _a2.submit) != null ? _b2 : "Submit"
+          )
+        );
+      },
+      onResetLabelDoubleClick: () => {
+        var _a2, _b2;
+        return onInlineTextEdit(
+          node.id,
+          "dict.reset",
+          String(
+            (_b2 = (_a2 = componentProps.dict) == null ? void 0 : _a2.reset) != null ? _b2 : "Reset"
+          )
+        );
+      }
+    });
+  }
+  const coverPlan = plans.find((plan) => plan.kind === "cover-content");
+  if ((coverPlan == null ? void 0 : coverPlan.kind) === "cover-content") {
+    const content = materializeCoverContent({
+      descriptor: coverPlan.descriptor,
+      renderSafeNode
+    });
+    if (content.actions !== void 0) {
+      componentProps.actions = content.actions;
+    }
+    if (content.children !== null) {
+      componentProps.children = content.children;
+    } else if (componentProps.children === void 0) {
+      componentProps.children = null;
+    }
+  }
+  const scrollRevealPlan = plans.find((plan) => plan.kind === "scroll-reveal");
+  if ((scrollRevealPlan == null ? void 0 : scrollRevealPlan.kind) === "scroll-reveal") {
+    componentProps.children = dependencies.buildScrollRevealChildren({
+      rawChildren: scrollRevealPlan.rawChildren,
+      renderSafeNode,
+      normalizeRenderableChild: normalizeRenderableChild2,
+      fallbackChildren: componentProps.children
+    });
+  }
+  return null;
+};
+
+// src/materialization/materializeNavigationContent.tsx
+import React2 from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var materializeAccordionItems = ({
+  items,
+  renderSafeNode
+}) => items.map((item) => {
+  var _a;
+  return {
+    id: item.id,
+    title: item.title,
+    disabled: item.disabled,
+    content: item.contentKind === "nodes" ? /* @__PURE__ */ jsx2("div", { className: "space-y-2", children: item.contentNodes.map((nested) => /* @__PURE__ */ jsx2(React2.Fragment, { children: renderSafeNode(nested) }, nested.id)) }) : (_a = item.contentText) != null ? _a : ""
+  };
+});
+var materializeExpandablePanelContent = ({
+  descriptor,
+  renderSafeNode
+}) => {
+  if (descriptor.kind === "empty") {
+    return void 0;
+  }
+  return /* @__PURE__ */ jsx2("div", { className: "space-y-2", children: descriptor.nodes.map((child) => /* @__PURE__ */ jsx2(React2.Fragment, { children: renderSafeNode(child) }, child.id)) });
+};
+
+// src/materialization/materializeTabsContent.tsx
+import React3 from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var materializeTabsContent = ({
+  tabs,
+  renderSafeNode,
+  normalizeRenderableChild: normalizeRenderableChild2
+}) => tabs.map((tab) => ({
+  id: tab.id,
+  title: tab.title,
+  label: tab.label,
+  content: tab.contentKind === "nodes" ? tab.contentNodes.length === 1 ? renderSafeNode(tab.contentNodes[0]) : tab.contentNodes.map((child) => /* @__PURE__ */ jsx3(React3.Fragment, { children: renderSafeNode(child) }, child.id)) : normalizeRenderableChild2(tab.fallbackContent)
+}));
+
+// src/composition/applyNavigationComposition.tsx
+var applyNavigationComposition = ({
+  node,
+  componentProps,
+  isStudioRendererContext,
+  selectedNodeId,
+  wizardActiveStepByNodeId,
+  accordionOpenIdsByNodeId,
+  expandablePanelOpenByNodeId,
+  runtime,
+  setWizardActiveStepByNodeId,
+  setAccordionOpenIdsByNodeId,
+  setExpandablePanelOpenByNodeId,
+  onNodeClick,
+  onInlineTextEdit,
+  renderSafeNode,
+  normalizeRenderableChild: normalizeRenderableChild2,
+  captureFieldFocus,
+  setInlineEditing,
+  internalStudioNodeTypes,
+  plans: providedPlans,
+  dependencies
+}) => {
+  const plans = providedPlans != null ? providedPlans : dependencies.resolveNavigationCompositionPlan({
+    node,
+    componentProps,
+    internalStudioNodeTypes,
+    runtime
+  });
+  if (plans.some((plan) => plan.kind === "form-wizard")) {
+    const openInlineEditorForNodeProp = (targetNodeId, propName, rawValue) => {
+      setInlineEditing(dependencies.createInlineEditingState(targetNodeId, propName, rawValue));
+    };
+    dependencies.configureStudioFormWizard({
+      node,
+      componentProps,
+      isStudioRendererContext,
+      selectedNodeId,
+      wizardActiveStepByNodeId,
+      runtime,
+      setWizardActiveStepByNodeId,
+      onNodeClick,
+      onInlineTextEdit,
+      renderSafeNode,
+      captureFieldFocus,
+      openInlineEditorForNodeProp,
+      internalStudioNodeTypes
+    });
+  }
+  const accordionPlan = plans.find((plan) => plan.kind === "accordion");
+  if ((accordionPlan == null ? void 0 : accordionPlan.kind) === "accordion") {
+    const accordionChildren = accordionPlan.accordionChildren;
+    if (accordionChildren.length > 0) {
+      if (isStudioRendererContext) {
+        dependencies.configureStudioAccordion({
+          node,
+          componentProps,
+          accordionChildren,
+          selectedNodeId,
+          accordionOpenIdsByNodeId,
+          setAccordionOpenIdsByNodeId,
+          renderSafeNode
+        });
+      } else {
+        componentProps.items = materializeAccordionItems({
+          items: accordionPlan.itemDescriptors,
+          renderSafeNode
+        });
+      }
+    }
+  }
+  const expandablePanelPlan = plans.find((plan) => plan.kind === "expandable-panel");
+  if ((expandablePanelPlan == null ? void 0 : expandablePanelPlan.kind) === "expandable-panel") {
+    const panelChildren = expandablePanelPlan.panelChildren;
+    if (isStudioRendererContext) {
+      dependencies.configureStudioExpandablePanel({
+        node,
+        componentProps,
+        panelChildren,
+        expandablePanelOpenByNodeId,
+        setExpandablePanelOpenByNodeId,
+        renderSafeNode
+      });
+    } else if (panelChildren.length > 0) {
+      componentProps.children = materializeExpandablePanelContent({
+        descriptor: expandablePanelPlan.contentDescriptor,
+        renderSafeNode
+      });
+    }
+  }
+  const tabsPlan = plans.find((plan) => plan.kind === "tabs");
+  if ((tabsPlan == null ? void 0 : tabsPlan.kind) === "tabs") {
+    Object.assign(componentProps, tabsPlan.normalizedComponentProps);
+    if (isStudioRendererContext) {
+      const tabItems = Array.isArray(componentProps.tabs) ? componentProps.tabs : [];
+      dependencies.configureStudioTabs({
+        componentProps,
+        tabItems,
+        rawChildren: tabsPlan.rawChildren,
+        runtime,
+        renderSafeNode,
+        normalizeRenderableChild: normalizeRenderableChild2
+      });
+    } else {
+      componentProps.tabs = materializeTabsContent({
+        tabs: tabsPlan.tabDescriptors,
+        renderSafeNode,
+        normalizeRenderableChild: normalizeRenderableChild2
+      });
+      delete componentProps.children;
+    }
+  }
+};
+
+// src/directives/applyRenderDirectives.ts
+var applyRenderDirectives = ({
+  node,
+  componentProps,
+  renderBindingProps,
+  runtime,
+  plans: providedPlans,
+  dependencies
+}) => {
+  const directives = providedPlans != null ? providedPlans : dependencies.resolveRenderDirectivePlan({
+    node,
+    renderBindingProps
+  });
+  for (const directive of directives) {
+    if (directive.kind === "rows-columns-binding") {
+      dependencies.applyRowsAndColumnsBinding({
+        componentProps,
+        runtime,
+        rowsBindingKey: directive.rowsBindingKey,
+        columnsBindingKey: directive.columnsBindingKey
+      });
+    }
+    if (directive.kind === "filter-rows-by-query") {
+      dependencies.filterRowsByRuntimeQuery({
+        nodeId: directive.nodeId,
+        componentProps,
+        runtime
+      });
+    }
+    if (directive.kind === "cover-media") {
+      componentProps.media = dependencies.buildCoverMedia({
+        mediaSource: directive.mediaSource,
+        mediaSrc: directive.mediaSrc,
+        mediaAlt: directive.mediaAlt
+      });
+    }
+    if (directive.kind === "object-binding") {
+      dependencies.applyObjectBinding({
+        componentProps,
+        runtime,
+        bindingKey: directive.bindingKey
+      });
+    }
+    if (directive.kind === "decode-translation-binding") {
+      dependencies.applyDecodeTranslationBinding({
+        componentProps,
+        runtime,
+        tagContentTranslationKey: directive.tagContentTranslationKey,
+        tagContentTranslationValue: directive.tagContentTranslationValue,
+        hrefTranslationKey: directive.hrefTranslationKey,
+        hrefTranslationValue: directive.hrefTranslationValue
+      });
+    }
+  }
+};
+
+// src/engine/EngineWarningFallback.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var EngineWarningFallback = ({ message }) => /* @__PURE__ */ jsx4(
+  "div",
+  {
+    role: "alert",
+    className: "rounded-md border border-amber-300 bg-amber-50 px-3 py-2 text-sm text-amber-900",
+    children: message
+  }
+);
+var EngineWarningFallback_default = EngineWarningFallback;
+
+// src/engine/NodeErrorBoundary.tsx
+import React4 from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var NodeErrorBoundary = class extends React4.Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidUpdate(prevProps) {
+    if (this.state.hasError && prevProps.resetToken !== this.props.resetToken) {
+      this.setState({ hasError: false });
+    }
+  }
+  render() {
+    if (!this.state.hasError) return this.props.children;
+    return /* @__PURE__ */ jsx5(
+      EngineWarningFallback_default,
+      {
+        message: `Renderer fallback: node "${this.props.nodeType}" (${this.props.nodeId}) failed.`
+      }
+    );
+  }
+};
+
+// src/engine/ReactWebEngineRoot.tsx
+import React7, { useRef, useState as useState2 } from "react";
+
+// src/rendering/resolveResolvedReactNode.ts
+import {
+  resolveResolvedNode
+} from "@arkcit/engine-render-layer";
+
+// src/rendering/prepareRenderableChildren.tsx
+import React6 from "react";
+import {
+  resolveChildContentDescriptor,
+  resolveChildDescriptors
+} from "@arkcit/engine-render-layer";
+
+// src/rendering/gridItemWrapperProps.ts
+var getGridItemWrapperProps = (colSpan) => ({
+  className: "w-full min-w-0",
+  style: {
+    gridColumn: `span ${colSpan} / span ${colSpan}`
+  }
+});
+
+// src/materialization/materializeChildContent.tsx
+import React5 from "react";
+import { Fragment as Fragment2, jsx as jsx6 } from "react/jsx-runtime";
+var materializeChildContent = ({
+  descriptor,
+  renderSafeNode
+}) => {
+  if (descriptor.kind === "empty") {
+    return null;
+  }
+  const renderDescriptor = (childDescriptor) => {
+    if (childDescriptor.kind === "grid-item") {
+      return /* @__PURE__ */ jsx6("div", __spreadProps(__spreadValues({}, getGridItemWrapperProps(childDescriptor.colSpan)), { children: renderSafeNode(childDescriptor.child) }), childDescriptor.child.id);
+    }
+    return /* @__PURE__ */ jsx6(React5.Fragment, { children: renderSafeNode(childDescriptor.child) }, childDescriptor.child.id);
+  };
+  if (descriptor.kind === "single") {
+    return renderDescriptor(descriptor.child);
+  }
+  return /* @__PURE__ */ jsx6(Fragment2, { children: descriptor.children.map(renderDescriptor) });
+};
+
+// src/rendering/prepareRenderableChildren.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+var prepareRenderableChildren = ({
+  node,
+  internalStudioNodeTypes,
+  renderSafeNode,
+  childDescriptors,
+  childContentDescriptor
+}) => {
+  const resolvedDescriptors = childDescriptors != null ? childDescriptors : resolveChildDescriptors({
+    node,
+    internalStudioNodeTypes
+  });
+  const children = resolvedDescriptors.map((descriptor) => {
+    if (descriptor.kind === "grid-item") {
+      return /* @__PURE__ */ jsx7("div", __spreadProps(__spreadValues({}, getGridItemWrapperProps(descriptor.colSpan)), { children: renderSafeNode(descriptor.child) }), descriptor.child.id);
+    }
+    return /* @__PURE__ */ jsx7(React6.Fragment, { children: renderSafeNode(descriptor.child) }, descriptor.child.id);
+  });
+  const resolvedChildContentDescriptor = childContentDescriptor != null ? childContentDescriptor : resolveChildContentDescriptor({
+    childDescriptors: resolvedDescriptors
+  });
+  const resolvedChildContent = materializeChildContent({
+    descriptor: resolvedChildContentDescriptor,
+    renderSafeNode
+  });
+  return {
+    children,
+    resolvedChildContent,
+    childDescriptors: resolvedDescriptors,
+    childContentDescriptor: resolvedChildContentDescriptor
+  };
+};
+
+// src/rendering/resolveResolvedReactNode.ts
+var resolveResolvedReactNode = ({
+  node,
+  runtime,
+  registry,
+  internalStudioNodeTypes,
+  renderSafeNode,
+  isStudioRendererContext,
+  studioSizing
+}) => {
+  const registryEntry = registry[node.type];
+  if (!registryEntry) {
+    return null;
+  }
+  const resolvedNode = resolveResolvedNode({
+    node,
+    runtime,
+    internalStudioNodeTypes,
+    isStudioRendererContext,
+    studioSizing
+  });
+  const { children, resolvedChildContent } = prepareRenderableChildren({
+    node,
+    internalStudioNodeTypes,
+    renderSafeNode,
+    childDescriptors: resolvedNode.childDescriptors,
+    childContentDescriptor: resolvedNode.childContentDescriptor
+  });
+  return __spreadProps(__spreadValues({}, resolvedNode), {
+    registryEntry,
+    children,
+    resolvedChildContent
+  });
+};
+
+// src/rendering/renderReactNode.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+var renderReactNode = ({
+  node,
+  runtime,
+  registry,
+  schemaNodes,
+  renderSafeNode,
+  internalStudioNodeTypes,
+  overlaysByNodeId,
+  onInlineTextEdit,
+  isStudioRendererContext,
+  dropdownOpenByNodeId,
+  setDropdownOpenByNodeId,
+  captureFieldFocus,
+  selectedNodeId,
+  wizardActiveStepByNodeId,
+  accordionOpenIdsByNodeId,
+  expandablePanelOpenByNodeId,
+  setWizardActiveStepByNodeId,
+  setAccordionOpenIdsByNodeId,
+  setExpandablePanelOpenByNodeId,
+  onNodeClick,
+  setInlineEditing,
+  studioSizing,
+  dependencies
+}) => {
+  try {
+    const resolvedNode = resolveResolvedReactNode({
+      node,
+      runtime,
+      registry,
+      internalStudioNodeTypes,
+      renderSafeNode,
+      isStudioRendererContext,
+      studioSizing
+    });
+    if (!resolvedNode) {
+      return /* @__PURE__ */ jsx8(
+        EngineWarningFallback_default,
+        {
+          message: `Unknown component type "${node.type}" for node "${node.id}".`
+        }
+      );
+    }
+    const {
+      registryEntry,
+      componentProps,
+      renderBindingProps,
+      children,
+      resolvedChildContent,
+      contentPlans,
+      navigationPlans,
+      renderDirectivePlans,
+      finalRenderPlans
+    } = resolvedNode;
+    dependencies.applyStudioOverlayComponentProps({
+      node,
+      componentProps,
+      runtime,
+      overlaysByNodeId,
+      renderBindingProps,
+      resolvedChildContent,
+      onInlineTextEdit,
+      isStudioRendererContext,
+      dropdownOpenByNodeId,
+      setDropdownOpenByNodeId
+    });
+    const contentNode = dependencies.applyContentComposition({
+      node,
+      componentProps,
+      isStudioRendererContext,
+      internalStudioNodeTypes,
+      schemaNodes,
+      onInlineTextEdit,
+      captureFieldFocus,
+      renderSafeNode,
+      normalizeRenderableChild: dependencies.normalizeRenderableChild,
+      findNodeById: dependencies.findNodeById,
+      runtime,
+      plans: contentPlans
+    });
+    if (contentNode) {
+      return contentNode;
+    }
+    dependencies.applyRenderDirectives({
+      node,
+      componentProps,
+      renderBindingProps,
+      runtime,
+      plans: renderDirectivePlans
+    });
+    dependencies.applyNavigationComposition({
+      node,
+      componentProps,
+      isStudioRendererContext,
+      selectedNodeId: selectedNodeId != null ? selectedNodeId : null,
+      wizardActiveStepByNodeId,
+      accordionOpenIdsByNodeId,
+      expandablePanelOpenByNodeId,
+      runtime,
+      setWizardActiveStepByNodeId,
+      setAccordionOpenIdsByNodeId,
+      setExpandablePanelOpenByNodeId,
+      onNodeClick,
+      onInlineTextEdit,
+      renderSafeNode,
+      normalizeRenderableChild: dependencies.normalizeRenderableChild,
+      captureFieldFocus,
+      setInlineEditing,
+      internalStudioNodeTypes,
+      plans: navigationPlans
+    });
+    return dependencies.finalizeRenderedNode({
+      node,
+      children,
+      componentProps,
+      registryComponent: registryEntry.Component,
+      runtime,
+      isStudioRendererContext,
+      studioSizing,
+      plans: finalRenderPlans
+    });
+  } catch (e) {
+    return /* @__PURE__ */ jsx8(
+      EngineWarningFallback_default,
+      {
+        message: `Renderer fallback: node "${node.type}" (${node.id}) could not be resolved.`
+      }
+    );
+  }
+};
+
+// src/hooks/useUIEngineState.ts
+import { useState } from "react";
+var useUIEngineState = () => {
+  const [inlineEditing, setInlineEditing] = useState(null);
+  const [wizardActiveStepByNodeId, setWizardActiveStepByNodeId] = useState({});
+  const [expandablePanelOpenByNodeId, setExpandablePanelOpenByNodeId] = useState({});
+  const [accordionOpenIdsByNodeId, setAccordionOpenIdsByNodeId] = useState({});
+  const [dropdownOpenByNodeId, setDropdownOpenByNodeId] = useState(
+    {}
+  );
+  return {
+    inlineEditing,
+    setInlineEditing,
+    wizardActiveStepByNodeId,
+    setWizardActiveStepByNodeId,
+    expandablePanelOpenByNodeId,
+    setExpandablePanelOpenByNodeId,
+    accordionOpenIdsByNodeId,
+    setAccordionOpenIdsByNodeId,
+    dropdownOpenByNodeId,
+    setDropdownOpenByNodeId
+  };
+};
+
+// src/engine/ReactWebEngineRoot.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var INTERNAL_STUDIO_NODE_TYPES = /* @__PURE__ */ new Set();
+var STUDIO_CANVAS_OVERLAY_ROOT_ID = "studio-canvas-overlay-root";
+var STUDIO_MIN_WIDTH_PCT = 5;
+var STUDIO_MIN_HEIGHT_PCT = 5;
+var STUDIO_MIN_HEIGHT_PX = 20;
+var NOOP_RUNTIME = {
+  get: () => void 0,
+  dispatch: () => void 0
+};
+var EMPTY_UI_REGISTRY = {};
+var isFormInteractiveTarget = (target) => {
+  if (!target) return false;
+  const interactive = target.closest(
+    "button,input,textarea,select,option,label,[role='button'],[role='link']"
+  );
+  if (!interactive) return false;
+  return true;
+};
+var FallbackInlineTextEditor = ({
+  editing,
+  onChange,
+  onCancel,
+  onCommit
+}) => editing.multiline ? /* @__PURE__ */ jsx9(
+  "textarea",
+  {
+    style: editing.editorStyle,
+    value: editing.value,
+    autoFocus: true,
+    "aria-label": "Inline text editor",
+    onChange: (event) => onChange(event.target.value),
+    onBlur: onCommit,
+    onKeyDown: (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        onCancel();
+        return;
+      }
+      if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+        event.preventDefault();
+        onCommit();
+      }
+    }
+  }
+) : /* @__PURE__ */ jsx9(
+  "input",
+  {
+    style: editing.editorStyle,
+    value: editing.value,
+    autoFocus: true,
+    "aria-label": "Inline text editor",
+    onChange: (event) => onChange(event.target.value),
+    onBlur: onCommit,
+    onKeyDown: (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        onCancel();
+        return;
+      }
+      if (event.key === "Enter") {
+        event.preventDefault();
+        onCommit();
+      }
+    }
+  }
+);
+var ReactWebEngineRoot = ({
+  schema,
+  registry = EMPTY_UI_REGISTRY,
+  store,
+  onNodeClick,
+  onInlineTextEdit,
+  onNodeResize,
+  onNodeResizeStart,
+  onNodeResizeEnd,
+  onNodeDragStart,
+  onNodeDragOverTarget,
+  onNodeDropTarget,
+  selectedNodeId = null,
+  nodeWrapper,
+  dependencies
+}) => {
+  var _a;
+  const runtime = store != null ? store : NOOP_RUNTIME;
+  const NodeWrapper = nodeWrapper != null ? nodeWrapper : dependencies.StudioNodeWrapper;
+  const InlineTextEditor = (_a = dependencies.InlineTextEditor) != null ? _a : FallbackInlineTextEditor;
+  const isStudioRendererContext = Boolean(
+    onNodeClick || onInlineTextEdit || onNodeResize || onNodeDragStart || onNodeDragOverTarget || onNodeDropTarget || selectedNodeId
+  );
+  const [, setVersion] = useState2(0);
+  const {
+    inlineEditing,
+    setInlineEditing,
+    wizardActiveStepByNodeId,
+    setWizardActiveStepByNodeId,
+    expandablePanelOpenByNodeId,
+    setExpandablePanelOpenByNodeId,
+    accordionOpenIdsByNodeId,
+    setAccordionOpenIdsByNodeId,
+    dropdownOpenByNodeId,
+    setDropdownOpenByNodeId
+  } = useUIEngineState();
+  const resizeStateRef = useRef(null);
+  const pinchStateRef = useRef(null);
+  const pendingFieldFocusRef = useRef(null);
+  const { ancestorTypeMembership, overlaysByNodeId, captureFieldFocus } = dependencies.useUIEngineEffects({
+    schema,
+    runtime,
+    onNodeResize,
+    onNodeResizeEnd,
+    resizeStateRef,
+    pendingFieldFocusRef,
+    setVersion,
+    minWidthPct: STUDIO_MIN_WIDTH_PCT,
+    minHeightPct: STUDIO_MIN_HEIGHT_PCT,
+    minHeightPx: STUDIO_MIN_HEIGHT_PX
+  });
+  const renderNode = (node, studioSizing) => renderReactNode({
+    node,
+    runtime,
+    registry,
+    schemaNodes: schema.nodes,
+    renderSafeNode: renderSafeEngineNode,
+    internalStudioNodeTypes: INTERNAL_STUDIO_NODE_TYPES,
+    overlaysByNodeId,
+    onInlineTextEdit,
+    isStudioRendererContext,
+    dropdownOpenByNodeId,
+    setDropdownOpenByNodeId,
+    captureFieldFocus,
+    selectedNodeId,
+    wizardActiveStepByNodeId,
+    accordionOpenIdsByNodeId,
+    expandablePanelOpenByNodeId,
+    setWizardActiveStepByNodeId,
+    setAccordionOpenIdsByNodeId,
+    setExpandablePanelOpenByNodeId,
+    onNodeClick,
+    setInlineEditing,
+    studioSizing,
+    dependencies: dependencies.renderReactNodeDependencies
+  });
+  const renderSafeEngineNode = (node) => dependencies.renderSafeNode({
+    node,
+    registry,
+    runtime,
+    schemaNodes: schema.nodes,
+    renderNode,
+    isStudioRendererContext,
+    overlaysByNodeId,
+    selectedNodeId,
+    onNodeClick,
+    onInlineTextEdit,
+    onNodeResize,
+    onNodeResizeStart,
+    onNodeResizeEnd,
+    inlineEditing,
+    setInlineEditing,
+    ancestorTypeMembership,
+    resizeStateRef,
+    pinchStateRef,
+    minWidthPct: STUDIO_MIN_WIDTH_PCT,
+    minHeightPct: STUDIO_MIN_HEIGHT_PCT,
+    minHeightPx: STUDIO_MIN_HEIGHT_PX,
+    overlayRootId: STUDIO_CANVAS_OVERLAY_ROOT_ID,
+    NodeWrapper,
+    InlineTextEditorComponent: InlineTextEditor,
+    isFormInteractiveTarget
+  });
+  return /* @__PURE__ */ jsx9("div", { className: "flex h-full min-w-0 w-full flex-wrap content-start items-start gap-3", children: schema.nodes.map((node) => /* @__PURE__ */ jsx9(React7.Fragment, { children: renderSafeEngineNode(node) }, node.id)) });
+};
+
+// src/hooks/useUIEngineEffects.ts
+import { useEffect, useLayoutEffect, useMemo } from "react";
+var useUIEngineEffects = ({
+  schema,
+  runtime,
+  onNodeResize,
+  onNodeResizeEnd,
+  resizeStateRef,
+  pendingFieldFocusRef,
+  setVersion,
+  minWidthPct,
+  minHeightPct,
+  minHeightPx,
+  dependencies
+}) => {
+  const ancestorTypeMembership = useMemo(
+    () => dependencies.buildAncestorTypeMembership(schema.nodes, ["Form", "FormWizard", "StepForm"]),
+    [dependencies, schema.nodes]
+  );
+  const overlaysByNodeId = dependencies.readOverlayState(runtime);
+  const captureFieldFocus = (target) => {
+    pendingFieldFocusRef.current = dependencies.capturePendingFieldFocus(target);
+  };
+  useLayoutEffect(() => {
+    const pending = pendingFieldFocusRef.current;
+    if (!pending) return;
+    pendingFieldFocusRef.current = null;
+    dependencies.restorePendingFieldFocus(pending);
+  }, [dependencies, schema, pendingFieldFocusRef]);
+  useEffect(() => {
+    if (!runtime.subscribe) return;
+    return runtime.subscribe(() => {
+      setVersion((previous) => previous + 1);
+    });
+  }, [runtime, setVersion]);
+  useEffect(() => {
+    if (!onNodeResize) return;
+    const handleMouseMove = (event) => {
+      const state = resizeStateRef.current;
+      if (!state) return;
+      const nextSize = dependencies.computeMouseResizeSize({
+        state,
+        clientX: event.clientX,
+        clientY: event.clientY,
+        minWidthPct,
+        minHeightPct,
+        minHeightPx
+      });
+      resizeStateRef.current = __spreadProps(__spreadValues({}, state), {
+        lastSize: nextSize
+      });
+      onNodeResize(state.nodeId, __spreadValues({
+        widthPct: nextSize.widthPct,
+        heightPct: nextSize.heightPct
+      }, nextSize.heightPx !== void 0 ? { heightPx: nextSize.heightPx } : {}));
+    };
+    const handleMouseUp = () => {
+      const state = resizeStateRef.current;
+      if (state == null ? void 0 : state.lastSize) {
+        onNodeResizeEnd == null ? void 0 : onNodeResizeEnd(state.nodeId, __spreadValues({
+          widthPct: state.lastSize.widthPct,
+          heightPct: state.lastSize.heightPct
+        }, state.lastSize.heightPx !== void 0 ? { heightPx: state.lastSize.heightPx } : {}));
+      }
+      resizeStateRef.current = null;
+    };
+    window.addEventListener("mousemove", handleMouseMove);
+    window.addEventListener("mouseup", handleMouseUp);
+    return () => {
+      window.removeEventListener("mousemove", handleMouseMove);
+      window.removeEventListener("mouseup", handleMouseUp);
+    };
+  }, [
+    dependencies,
+    minHeightPct,
+    minHeightPx,
+    minWidthPct,
+    onNodeResize,
+    onNodeResizeEnd,
+    resizeStateRef
+  ]);
+  return {
+    ancestorTypeMembership,
+    overlaysByNodeId,
+    captureFieldFocus
+  };
+};
+
+// src/materialization/contentStudio.tsx
+import React8 from "react";
+import { Fragment as Fragment3, jsx as jsx10 } from "react/jsx-runtime";
+var buildCoverMedia = ({
+  mediaSource,
+  mediaSrc,
+  mediaAlt
+}) => {
+  if (mediaSource === "none") return void 0;
+  if (mediaSource === "image" && mediaSrc) {
+    return /* @__PURE__ */ jsx10(
+      "img",
+      {
+        src: mediaSrc,
+        alt: mediaAlt || "Cover media",
+        className: "h-56 w-full rounded-xl object-cover"
+      }
+    );
+  }
+  if (mediaSource === "video" && mediaSrc) {
+    return /* @__PURE__ */ jsx10(
+      "video",
+      {
+        src: mediaSrc,
+        className: "h-56 w-full rounded-xl object-cover",
+        controls: true,
+        preload: "metadata"
+      }
+    );
+  }
+  return void 0;
+};
+var buildCoverContent = ({
+  rawChildren,
+  renderSafeNode
+}) => {
+  const actionChildren = rawChildren.filter((child) => child.type === "Button" || child.type === "Link");
+  const contentChildren = rawChildren.filter((child) => child.type !== "Button" && child.type !== "Link");
+  const resolvedActionChildren = actionChildren.map((child) => /* @__PURE__ */ jsx10("span", { className: "inline-flex align-middle", children: renderSafeNode(child) }, child.id));
+  const resolvedContentChildren = contentChildren.map((child) => /* @__PURE__ */ jsx10(React8.Fragment, { children: renderSafeNode(child) }, child.id));
+  return {
+    actions: resolvedActionChildren.length > 0 ? resolvedActionChildren.length === 1 ? resolvedActionChildren[0] : /* @__PURE__ */ jsx10(Fragment3, { children: resolvedActionChildren }) : void 0,
+    children: resolvedContentChildren.length > 0 ? resolvedContentChildren.length === 1 ? resolvedContentChildren[0] : /* @__PURE__ */ jsx10(Fragment3, { children: resolvedContentChildren }) : null
+  };
+};
+var buildScrollRevealChildren = ({
+  rawChildren,
+  renderSafeNode,
+  normalizeRenderableChild: normalizeRenderableChild2,
+  fallbackChildren
+}) => {
+  if (rawChildren.length > 0) {
+    return rawChildren.length === 1 ? /* @__PURE__ */ jsx10(React8.Fragment, { children: renderSafeNode(rawChildren[0]) }, rawChildren[0].id) : /* @__PURE__ */ jsx10(Fragment3, { children: rawChildren.map((child) => /* @__PURE__ */ jsx10(React8.Fragment, { children: renderSafeNode(child) }, child.id)) });
+  }
+  return normalizeRenderableChild2(fallbackChildren);
+};
+
+// src/materialization/materializeBoundTable.tsx
+import React9 from "react";
+
+// src/rendering/resolveBoundTableData.ts
+var resolveBoundTableData = ({
+  nodeId,
+  componentProps,
+  runtime
+}) => {
+  var _a, _b, _c, _d;
+  const rows = Array.isArray(componentProps.rows) ? componentProps.rows : [];
+  const columns = Array.isArray(componentProps.columns) ? componentProps.columns : [];
+  const paginationCandidate = componentProps.pagination;
+  const pagination = paginationCandidate && typeof paginationCandidate === "object" ? paginationCandidate : null;
+  const pageRaw = Number((_a = pagination == null ? void 0 : pagination.page) != null ? _a : 1);
+  const pageSizeRaw = Number(((_b = pagination == null ? void 0 : pagination.pageSize) != null ? _b : rows.length) || 1);
+  const page = Number.isFinite(pageRaw) && pageRaw > 0 ? pageRaw : 1;
+  const pageSize = Number.isFinite(pageSizeRaw) && pageSizeRaw > 0 ? pageSizeRaw : rows.length || 1;
+  const tableQueriesRaw = runtime.get("table.queriesByNodeId");
+  const tableQueries = tableQueriesRaw && typeof tableQueriesRaw === "object" ? tableQueriesRaw : {};
+  const query = String((_d = (_c = tableQueries[nodeId]) != null ? _c : tableQueries.__all__) != null ? _d : "").trim().toLowerCase();
+  const filteredRows = query.length === 0 ? rows : rows.filter(
+    (row) => columns.some((column) => {
+      var _a2;
+      const key = String((_a2 = column.key) != null ? _a2 : "").trim();
+      if (!key) return false;
+      const value = row[key];
+      return String(value != null ? value : "").toLowerCase().includes(query);
+    })
+  );
+  const startIndex = (page - 1) * pageSize;
+  const pagedRows = pagination ? filteredRows.slice(startIndex, startIndex + pageSize) : filteredRows;
+  return {
+    columns,
+    rows,
+    filteredRows,
+    pagedRows,
+    pagination,
+    page,
+    pageSize,
+    query
+  };
+};
+
+// src/materialization/materializeBoundTable.tsx
+var RENDER_INTERNAL_PROP_NAMES = /* @__PURE__ */ new Set([
+  "bindingEnabled",
+  "valueBindingKey",
+  "optionsBindingKey",
+  "useBindingData",
+  "entitiesBindingKey",
+  "videoBindingKey",
+  "mapBindingKey",
+  "productBindingKey",
+  "useTranslationKeys",
+  "tagContentTranslationKey",
+  "tagContentTranslationValue",
+  "hrefTranslationKey",
+  "hrefTranslationValue",
+  "mediaSource",
+  "mediaSrc",
+  "mediaAlt",
+  "rowsBindingKey",
+  "columnsBindingKey"
+]);
+var omitInternalProps = (props) => {
+  const next = __spreadValues({}, props);
+  delete next.__studio;
+  for (const propName of RENDER_INTERNAL_PROP_NAMES) {
+    delete next[propName];
+  }
+  return next;
+};
+var materializeBoundTable = ({
+  nodeId,
+  componentProps,
+  runtime,
+  TableComponent
+}) => {
+  const { columns, pagedRows } = resolveBoundTableData({
+    nodeId,
+    componentProps,
+    runtime
+  });
+  delete componentProps.rows;
+  delete componentProps.columns;
+  delete componentProps.pagination;
+  delete componentProps.rowsBindingKey;
+  delete componentProps.columnsBindingKey;
+  delete componentProps.useBindingData;
+  if (columns.length === 0) return null;
+  delete componentProps.children;
+  const headerNode = React9.createElement(
+    TableComponent.Header,
+    null,
+    React9.createElement(
+      TableComponent.Row,
+      null,
+      ...columns.map(
+        (column, columnIndex) => {
+          var _a, _b, _c;
+          return React9.createElement(
+            TableComponent.Head,
+            { key: `table-head-${String((_a = column.key) != null ? _a : columnIndex)}` },
+            String((_c = (_b = column.header) != null ? _b : column.key) != null ? _c : `Column ${columnIndex + 1}`)
+          );
+        }
+      )
+    )
+  );
+  const bodyNode = React9.createElement(
+    TableComponent.Body,
+    null,
+    ...pagedRows.map(
+      (row, rowIndex) => {
+        var _a;
+        return React9.createElement(
+          TableComponent.Row,
+          { key: `table-row-${String((_a = row.id) != null ? _a : rowIndex)}` },
+          ...columns.map((column, columnIndex) => {
+            var _a2, _b;
+            const key = String((_a2 = column.key) != null ? _a2 : "").trim();
+            const value = key ? row[key] : "";
+            return React9.createElement(
+              TableComponent.Cell,
+              { key: `table-cell-${String((_b = row.id) != null ? _b : rowIndex)}-${key || columnIndex}` },
+              value == null ? "" : String(value)
+            );
+          })
+        );
+      }
+    )
+  );
+  return React9.createElement(
+    TableComponent,
+    omitInternalProps(componentProps),
+    headerNode,
+    bodyNode
+  );
+};
+
+// src/materialization/navigationStudio.tsx
+import React10 from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var buildAccordionItems = (accordionChildren, renderSafeNode) => accordionChildren.map((child, index) => {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const childProps = (_a = child.props) != null ? _a : {};
+  return {
+    id: String((_c = (_b = childProps.id) != null ? _b : child.id) != null ? _c : `item-${index + 1}`),
+    title: String((_d = childProps.title) != null ? _d : `Section ${index + 1}`),
+    content: ((_e = child.children) != null ? _e : []).length > 0 ? /* @__PURE__ */ jsx11("div", { className: "space-y-2", children: ((_f = child.children) != null ? _f : []).map((nested) => /* @__PURE__ */ jsx11(React10.Fragment, { children: renderSafeNode(nested) }, nested.id)) }) : String((_g = childProps.content) != null ? _g : ""),
+    disabled: Boolean(childProps.disabled)
+  };
+});
+var buildExpandablePanelChildren = (panelChildren, renderSafeNode) => {
+  if (panelChildren.length === 0) return void 0;
+  return /* @__PURE__ */ jsx11("div", { className: "space-y-2", children: panelChildren.map((child) => /* @__PURE__ */ jsx11(React10.Fragment, { children: renderSafeNode(child) }, child.id)) });
+};
+
+// src/rendering/finalizeRenderedNode.tsx
+import React11 from "react";
+
+// src/rendering/previewLinkBehavior.ts
+var configurePreviewLinkBehavior = (componentProps) => {
+  const existingOnClick = componentProps.onClick;
+  componentProps.onClick = (event) => {
+    event.preventDefault();
+    if (typeof existingOnClick === "function") {
+      existingOnClick(event);
+    }
+  };
+};
+
+// src/rendering/finalizeRenderedNode.tsx
+var finalizeRenderedNode = ({
+  node,
+  children,
+  componentProps,
+  registryComponent,
+  runtime,
+  isStudioRendererContext,
+  studioSizing,
+  plans: providedPlans,
+  dependencies
+}) => {
+  const plans = providedPlans != null ? providedPlans : dependencies.resolveFinalRenderPlan({
+    node,
+    componentProps,
+    isStudioRendererContext,
+    studioSizing
+  });
+  for (const plan of plans) {
+    if (plan.kind === "style-sizing") {
+      componentProps.style = plan.style;
+    }
+    if (plan.kind === "configure-studio-link") {
+      configurePreviewLinkBehavior(componentProps);
+    }
+    if (plan.kind === "cleanup-studio-props") {
+      delete componentProps.__studioColSpan;
+      delete componentProps.__studioWrapperClassName;
+      delete componentProps.__studioWidthPct;
+      delete componentProps.__studioHeightPct;
+      delete componentProps.__studioHeightPx;
+      delete componentProps.__studioCardSection;
+      delete componentProps.layout;
+    }
+  }
+  if (plans.some((plan) => plan.kind === "table-fallback")) {
+    const tableNode = materializeBoundTable({
+      nodeId: node.id,
+      componentProps,
+      runtime,
+      TableComponent: registryComponent
+    });
+    if (tableNode) {
+      return tableNode;
+    }
+  }
+  const finalComponentProps = dependencies.omitStudioProps(componentProps);
+  if (children && children.length > 0) {
+    if (node.type === "Cover" || node.type === "Tabs" || node.type === "Accordion") {
+      return React11.createElement(registryComponent, finalComponentProps);
+    }
+    return React11.createElement(registryComponent, finalComponentProps, children);
+  }
+  return React11.createElement(registryComponent, finalComponentProps);
+};
+
+// src/rendering/nodeResetToken.ts
+import { isValidElement } from "react";
+var buildNodeResetToken = (node) => {
+  var _a, _b, _c, _d, _e, _f;
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(
+      {
+        type: node.type,
+        props: (_a = node.props) != null ? _a : null,
+        events: (_b = node.events) != null ? _b : null,
+        children: (_d = (_c = node.children) == null ? void 0 : _c.map((child) => child.id)) != null ? _d : []
+      },
+      (_key, value) => {
+        if (typeof value === "function") return "[function]";
+        if (isValidElement(value)) return "[react-element]";
+        if (value && typeof value === "object") {
+          if (seen.has(value)) return "[circular]";
+          seen.add(value);
+        }
+        return value;
+      }
+    );
+  } catch (e) {
+    return `${node.type}:${node.id}:${Object.keys((_e = node.props) != null ? _e : {}).join(",")}:${((_f = node.children) != null ? _f : []).map((child) => child.id).join(",")}`;
+  }
+};
+
+// src/rendering/renderChildren.tsx
+import React12, { isValidElement as isValidElement2 } from "react";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var toBoolean = (value) => {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return value.toLowerCase() === "true";
+  return false;
+};
+var normalizeRenderableChild = (value) => {
+  if (value == null || typeof value === "boolean") return null;
+  if (typeof value === "string" || typeof value === "number") return value;
+  if (isValidElement2(value)) return value;
+  if (Array.isArray(value)) {
+    return value.map((item, index) => /* @__PURE__ */ jsx12(React12.Fragment, { children: normalizeRenderableChild(item) }, `normalized-child-${index}`));
+  }
+  if (value && typeof value === "object") {
+    const candidate = value;
+    if ("props" in candidate && candidate.props && typeof candidate.props === "object") {
+      const nestedChildren = candidate.props.children;
+      return normalizeRenderableChild(nestedChildren);
+    }
+  }
+  return null;
+};
+
+// src/rendering/resolveReactNodePlan.ts
+import { resolveNodeBase } from "@arkcit/engine-render-layer";
+var resolveReactNodePlan = ({
+  node,
+  runtime,
+  registry,
+  internalStudioNodeTypes,
+  renderSafeNode
+}) => {
+  const registryEntry = registry[node.type];
+  if (!registryEntry) {
+    return null;
+  }
+  const resolvedNodeBase = resolveNodeBase({
+    node,
+    runtime,
+    internalStudioNodeTypes
+  });
+  const { children, resolvedChildContent } = prepareRenderableChildren({
+    node,
+    internalStudioNodeTypes,
+    renderSafeNode,
+    childDescriptors: resolvedNodeBase.childDescriptors,
+    childContentDescriptor: resolvedNodeBase.childContentDescriptor
+  });
+  return __spreadProps(__spreadValues({}, resolvedNodeBase), {
+    registryEntry,
+    children,
+    resolvedChildContent
+  });
+};
+export {
+  EngineWarningFallback_default as EngineWarningFallback,
+  NodeErrorBoundary,
+  ReactWebEngineRoot,
+  applyContentComposition,
+  applyNavigationComposition,
+  applyRenderDirectives,
+  buildAccordionItems,
+  buildCoverContent,
+  buildCoverMedia,
+  buildExpandablePanelChildren,
+  buildNodeResetToken,
+  buildScrollRevealChildren,
+  configurePreviewLinkBehavior,
+  finalizeRenderedNode,
+  getGridItemWrapperProps,
+  materializeAccordionItems,
+  materializeBoundTable,
+  materializeChildContent,
+  materializeCoverContent,
+  materializeExpandablePanelContent,
+  materializeTabsContent,
+  normalizeRenderableChild,
+  prepareRenderableChildren,
+  renderReactNode,
+  resolveBoundTableData,
+  resolveReactNodePlan,
+  resolveResolvedReactNode,
+  toBoolean,
+  useUIEngineEffects,
+  useUIEngineState
+};