@superblocksteam/library 2.0.59-next.2 → 2.0.59-next.3

package/dist/lib/index.d.ts

@@ -1,11 +1,22 @@
-import { EditorConfig, EvaluateOrValueComputedArgs, Property, TailwindPropertyKey } from "@superblocksteam/library-shared";
+import { Dim, EditorConfig, EvaluateOrValueComputedArgs, Property, TailwindPropertyKey } from "@superblocksteam/library-shared";
+import * as React$2 from "react";
 import React$1, { LegacyRef, ReactNode } from "react";
+import { DataRouter, Location, Params } from "react-router";
 import { OrchestratorViewMode, PlaceholderInfo, Profile } from "@superblocksteam/shared";
-import { AiContextMode, AiGenerationState, AppToEditorMessage, Catalog, CreateChild, CreateChild as CreateChild$1, DeleteMeLibraryApi, EditOperationPayload, EditOperationType, EditorConfig as EditorConfig$1, Entity, EntityOutputProp, InteractionMode, PayloadAction, PropertyInfo, RuntimeErrorData, SbElement, SourceLocation, TransactionInfo, UrlState, WithBindingIdentifier } from "@superblocksteam/library-shared/types";
+import { AiContextMode, AiGenerationState, AppToEditorMessage, Catalog, CatalogWithInternalDetails, ComponentRegistryShareState, CreateChild, CreateChild as CreateChild$1, CreateRequest, DeleteMeLibraryApi, DeleteRequest, EditOperationPayload, EditOperationType, EditOperations, EditorConfig as EditorConfig$1, Entity, EntityOutputProp, InteractionMode, PayloadAction, PropertyInfo, ReparentRequest, RuntimeErrorData, RuntimeSyncComposite, SbApiRunOptions, SbElement, SbSelector, SetPropertiesRequest, SetPropertyRequest, SourceLocation, TransactionInfo, UrlState, ViteMessage, ViteMessageKind, WithBindingIdentifier } from "@superblocksteam/library-shared/types";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
-import { Callback, ControlType, DataType, DataTypeString, HeaderType, PropertiesPanelDefinition as PropertiesPanelDefinition$1, PropertiesPanelDisplay, PropertyForData, PropsCategory, Relation, WidgetPropertyDefinition } from "@superblocksteam/library-shared/props";
+import { Callback, ControlType, DataType, DataTypeString, EntityDefinition, HeaderType, PropertiesPanelDefinition as PropertiesPanelDefinition$1, PropertiesPanelDisplay, PropertyForData, PropsCategory, Relation, WidgetPropertyDefinition } from "@superblocksteam/library-shared/props";
+import { Graph } from "@dagrejs/graphlib";
 import { XYCoord } from "react-dnd";
 
+//#region src/lib/internal-details/scope/types.d.ts
+declare const AppMode: {
+  readonly EDIT: "EDIT";
+  readonly PUBLISHED: "PUBLISHED";
+  readonly PREVIEW: "PREVIEW";
+};
+type AppMode = (typeof AppMode)[keyof typeof AppMode];
+//#endregion
 //#region src/lib/internal-details/superblocks-context.d.ts
 type User = {
   name: string;
@@ -41,6 +52,7 @@ declare function useSuperblocksProfiles(): {
   profiles: Profiles | undefined;
   setProfile: (profileName: string) => void;
 };
+declare function getAppMode(): AppMode | undefined;
 //#endregion
 //#region src/lib/user-facing/sb-provider.d.ts
 declare const SbProvider: ({
@@ -106,6 +118,7 @@ interface StreamEvent {
     execution: string;
   };
 }
+type RouteInfo = Omit<UrlState, "host" | "hostname" | "href" | "port" | "protocol">;
 type RouteChangePayload = Omit<UrlState, "host" | "hostname" | "href" | "pathname" | "port" | "protocol">;
 type AiUpdatesPayload = {
   parentToChild: {
@@ -127,6 +140,7 @@ type AiUpdatesPayload = {
   childToParent: {
     type: "add-component-to-context";
     component: SbElement;
+    label?: string;
   } | {
     type: "toggle-component-in-context";
     component: SbElement;
@@ -151,6 +165,14 @@ type FromParentToChildMessageTypesMap = {
     interactionMode?: InteractionMode;
     /** The value of the authorization header on requests to the dev server. */
     devServerAuthorization: string | undefined;
+    /** Timestamp when the parent connection started (for end-to-end metrics) */
+    connectionStartTime?: number;
+    /** W3C Trace Context headers for linking app websocket span to parent trace */
+    traceContext?: Record<string, string>;
+    /** Connection type: initial or reconnect */
+    connectionType?: "initial" | "reconnect";
+    /** Connection target: local, sabs, or default */
+    connectionTarget?: string;
     aiState?: {
       generationState: AiGenerationState;
       editingComponents: SbElement[];
@@ -345,15 +367,471 @@ type FromChildToParentMessageTypesMap = {
   "logout-integration": {
     callbackId: string;
   };
+  "app-websocket-connected": {
+    success: boolean;
+    durationMs: number;
+    error?: {
+      message: string;
+      type: string;
+      stack?: string;
+    };
+  };
 } & AppToEditorMessage<PropertiesPanelDefinition$1>;
 type FromChildToParentMessageTypes = keyof FromChildToParentMessageTypesMap;
 //#endregion
+//#region src/lib/internal-details/location-store.d.ts
+declare class LocationStore {
+  route?: RouteInfo;
+  rootStore: RootStore;
+  constructor(rootStore: RootStore);
+  updateLocation(location: Location, routes: DataRouter["routes"], params: Readonly<Params<string>>): void;
+  sendLocationToEditor(): void;
+  /**
+   * Recursively searches through route tree (including nested children) to find a matching route
+   */
+  private findMatchingRoute;
+  locationToRouteInfo(location: Location, routes: DataRouter["routes"], params: Readonly<Params<string>>): RouteInfo | undefined;
+}
+//#endregion
+//#region src/lib/internal-details/lib/features/api-store.d.ts
+type ApiResult<T = any> = {
+  data?: T;
+  error?: string;
+};
+declare class ApiManager {
+  readonly rootStore: RootStore;
+  agentUrls: string[];
+  private token;
+  private accessToken;
+  private runningApiControllers;
+  private waitForInitApiPromise;
+  private callContexts;
+  constructor(rootStore: RootStore);
+  setTokens(token: string, accessToken: string): void;
+  isInitialized(): boolean;
+  private awaitInitApiIfNeeded;
+  loadApiManifest({
+    apis
+  }: {
+    apis?: Record<string, {
+      api: DeleteMeLibraryApi;
+      scopeId: string;
+    }>;
+  }): void;
+  rerunApiByCallId(callId: string): Promise<ApiResult>;
+  runApiByPath({
+    path,
+    inputs,
+    callId,
+    callback,
+    isTestRun,
+    injectedCallerId
+  }: {
+    path: string;
+    inputs: SbApiRunOptions;
+    callId?: string;
+    callback?: () => Promise<unknown>;
+    isTestRun?: boolean;
+    injectedCallerId?: string;
+  }): Promise<ApiResult>;
+  private getHMRCallHash;
+  private getCachedHMRExecution;
+  private executeApi;
+  private executeApiInternal;
+  private findError;
+  private extractStatusCode;
+  cancelApi(apiName: string, _scopeId?: string): Promise<void>;
+}
+//#endregion
+//#region src/edit-mode/runtime-graph/types.d.ts
+type ComponentNode = {
+  selectorId: SbSelector;
+  sourceId: SbElement;
+  type: any;
+  isSbComponent: boolean;
+  isHtmlElement: boolean;
+  noSelect?: boolean;
+  props?: Record<string, unknown>;
+  firstRenderedTag: SbSelector | undefined;
+  nearestSelectableAncestor: SbSelector | undefined;
+  displayName: string;
+};
+//#endregion
+//#region src/edit-mode/features/runtime-tracking-store.d.ts
+declare class RuntimeTrackingStore {
+  readonly editStore: EditStore | undefined;
+  constructor(editStore: EditStore | undefined);
+  private graph;
+  private jsxNodes;
+  private sourceNodes;
+  registerComponent(selectorId: SbSelector, params: {
+    sourceId: SbElement;
+    type: any;
+    parentSelectorId?: SbSelector;
+    isSbComponent: boolean;
+    isHtmlElement: boolean;
+    noSelect?: boolean;
+  }): void;
+  getDisplayName(selectorId: SbSelector): string;
+  unregisterComponent(selectorId: SbSelector): void;
+  getFirstAnchorableTag(selectorId: SbSelector): SbSelector | undefined;
+  getNearestSelectableAncestor(selectorId: SbSelector, skipSelf?: boolean): SbSelector | undefined;
+  updatePropsForComponent(selectorId: SbSelector, props: Record<string, unknown>): void;
+  getComponent(selectorId: SbSelector): ComponentNode | undefined;
+  getComponentParent(selectorId: SbSelector): SbSelector;
+  getComponentChildren(selectorId: SbSelector): SbSelector[];
+  getSelectorIdsForSourceId(sourceId: SbElement): Set<SbSelector>;
+  getSourceId(selectorId: SbSelector): SbElement | undefined;
+  getClosestAncestorByType(selectorId: SbSelector, type: string): SbSelector | undefined;
+  hasRenderedNodes(): boolean;
+  get jsxNodeCount(): number;
+}
+//#endregion
+//#region src/edit-mode/features/ai-store.d.ts
+declare class AiManager {
+  private readonly runtimeTrackingStore;
+  private _isTaggingEnabled;
+  private _isEditing;
+  private _editingComponents;
+  private _contextMode;
+  private _targetedComponents;
+  private _targetedSelectors;
+  private _hasHadSuccessfulBuild;
+  private _hasEverHadSuccessfulBuild;
+  constructor(runtimeTrackingStore: RuntimeTrackingStore);
+  getIsTaggingEnabled(): boolean;
+  getIsEditing(): boolean;
+  getShouldShowLoader(): boolean;
+  setIsTaggingEnabled(isTaggingEnabled: boolean): void;
+  getAiContextMode(): AiContextMode;
+  shouldToggleComponentInAiContext(): boolean;
+  getTargetedComponents(): `SB-${string}`[];
+  isEditingComponent(id: SbElement): boolean;
+  isTargetingComponent(id: SbElement): boolean;
+  startEditing(): void;
+  setEditingComponents(components: SbElement[]): void;
+  finishEditing(): void;
+  setAiContextMode(mode: AiContextMode, components?: SbElement[]): void;
+  addTargetedSelector(selectorId: SbSelector): void;
+  toggleTargetedSelector(selectorId: SbSelector): void;
+  isTargetedSelector(selectorId: SbSelector): boolean;
+  /**
+   * Returns true if we are targeting a different selector of the same source id, since in some cases we want to keep
+   * the same source targeted, but just highlight another selector of it
+   */
+  isAlternateSourceIdTarget(sourceId: SbElement, selectorId: SbSelector): boolean;
+  handleRuntimeError(data: RuntimeErrorData): void;
+  clearRuntimeError(id: string): void;
+  markFirstBuildSuccess(): void;
+  private notifyLoaderState;
+  private removeAllSharedSelectors;
+  private removeAllSelectorsForSource;
+}
+//#endregion
+//#region src/edit-mode/features/connection-manager.d.ts
+type ConnectionStatus = "pre-init" | "disconnected" | "connecting" | "connected";
+declare class ConnectionManager {
+  connectionStatus: ConnectionStatus;
+  constructor();
+  initializeSocket(): void;
+  connect(): void;
+  disconnect(): void;
+}
+//#endregion
+//#region src/edit-mode/features/operation-store.d.ts
+type OptimisticOperation<P> = {
+  type: keyof EditOperations;
+  payload: P;
+  id: string;
+  callback?: () => void;
+};
+type ReparentTransaction = OptimisticOperation<ReparentRequest>;
+type SetPropertiesTransaction = OptimisticOperation<SetPropertiesRequest>;
+type SetPropertyTransaction = OptimisticOperation<SetPropertyRequest>;
+type CreateComponentTransaction = OptimisticOperation<CreateRequest>;
+type DeleteComponentsTransaction = OptimisticOperation<DeleteRequest>;
+type PendingTransaction = ReparentTransaction | SetPropertiesTransaction | SetPropertyTransaction | CreateComponentTransaction | DeleteComponentsTransaction;
+declare class OperationManager {
+  private pendingTransactions;
+  private waitingForBatch;
+  private batchOperations;
+  private batchOperationTransactionId;
+  visibleSourceIds: string[];
+  constructor();
+  get allPendingTransactions(): PendingTransaction[];
+  get pendingReparentOperations(): ReparentTransaction[];
+  get pendingDeleteOperations(): DeleteComponentsTransaction[];
+  get pendingSetPropertiesOperations(): SetPropertiesTransaction[];
+  get hasPendingOperations(): boolean;
+  get allNames(): never[];
+  private executeOrAddToBatch;
+  private addPendingTransaction;
+  clearPendingTransactions(transactionIds: string[]): void;
+  batchUpdate(performOperations: () => void): void;
+  createComponent(payload: CreateRequest): void;
+  dropComponent(action: {
+    from: {
+      source: SourceLocation;
+    };
+    to: {
+      source: SourceLocation;
+    };
+    propsToChange?: Record<string, PropertyInfo>;
+  }): void;
+  deleteComponents(sourceIds: SbElement[]): void;
+  acknowledgeEditOperation(operation: EditOperationPayload<EditOperationType>): void;
+  writeRuntimeProperties(sourceId: SbElement, transactionId: string, updates: Record<string, PropertyInfo<unknown>>): void;
+  setWidgetProperties({
+    sourceId,
+    properties,
+    callback
+  }: {
+    sourceId: SbElement;
+    properties: Record<string, PropertyInfo<unknown>>;
+    callback?: () => void;
+  }): void;
+  setWidgetProperty({
+    sourceId,
+    property,
+    value,
+    callback
+  }: {
+    sourceId: SbElement;
+    property: string;
+    value: PropertyInfo<unknown>;
+    callback?: () => void;
+  }): void;
+  ensureFilesSynced(): Promise<void>;
+  generateSourceId(): `SB-${string}`;
+}
+//#endregion
+//#region src/edit-mode/features/properties-panel-manager.d.ts
+declare class PropertiesPanelManager {
+  readonly editStore: EditStore;
+  readonly componentsManager: ComponentRegistry;
+  private propertiesDefinitions;
+  private propertiesPanelTrackerDisposer;
+  private _propertyLookupCache;
+  private removeHotReloadListener;
+  constructor(editStore: EditStore, componentsManager: ComponentRegistry);
+  getPropertiesPanel(selectorId: SbSelector): PropertiesPanelDefinition$1;
+  trackPropertiesPanel(selectorId: SbSelector): void;
+  untrackPropertiesPanel(): void;
+  getPropertiesDefinition(type: string): PropertiesDefinition | undefined;
+  setPropertiesDefinition(widgetType: string, propertiesDefinition: PropertiesDefinition): void;
+  updatePropertiesDefinitionForType(type: string): void;
+  computeAndApplySideEffectsForPropertyUpdate(payload: {
+    sourceId: SbElement;
+    updates: Record<string, PropertyInfo<unknown>>;
+  }): Record<SbElement, Record<string, PropertyInfo<unknown>>>;
+  /**
+   * When a custom component's source code is updated, we want to update the properties definition for that component.
+   * In order to do that, we need to listen to vite's hot reload events. We can't put import.meta.hot calls in the library
+   * because Vite just compiled all of those out in library builds, so we inject a listener from the plugin instead.
+   * https://github.com/vitejs/vite/blob/v6.2/packages/vite/src/node/plugins/define.ts#L37
+   */
+  private attachHotReloadListener;
+}
+//#endregion
+//#region src/edit-mode/features/resizing-store.d.ts
+type ResizeState = {
+  selectorId: SbSelector;
+  sourceId: SbElement;
+  dragStartX: number;
+  dragStartY: number;
+  start: {
+    width: number;
+    height: number;
+  };
+  resizedPosition: string;
+  widthToUpdate: Dim | null;
+  heightToUpdate: Dim | null;
+  isApplyingResize: boolean;
+};
+declare class ResizingManager {
+  private root;
+  private _activeResizes;
+  constructor(root: RootStore);
+  get activeResize(): ResizeState | null | undefined;
+  private isLockedAspectRatio;
+  startResizing(dragStartX: number, dragStartY: number, selectorId: SbSelector, position: string): void;
+  private calculateDimension;
+  private handleResizeDimension;
+  resizeWidget(currentX: number, currentY: number, selectorId: SbSelector, canResizeWidth: boolean, canResizeHeight: boolean): void;
+  pendingResize(sourceId: SbElement): {
+    width: Dim | null;
+    height: Dim | null;
+  } | null;
+  get hasAnyPendingResize(): boolean;
+  get pendingResizes(): ResizeState[];
+  applyResize(selectorId: SbSelector): void;
+}
+//#endregion
+//#region src/edit-mode/features/ui-store.d.ts
+declare class UIStore {
+  readonly root: RootStore;
+  readonly editStore: EditStore;
+  resizing: ResizingManager;
+  private _selectedSourceIds;
+  private _selectedSelectorIds;
+  private _focusedSelectorId;
+  private _rootInstanceData;
+  private newComponentSelectPromise;
+  constructor(root: RootStore, editStore: EditStore);
+  getMostRelevantSelectorIdsForSourceId(sourceId: SbElement): SbSelector[];
+  isSourceSelected(sourceId: SbElement): boolean;
+  getSelectedSourceIds(): SbElement[];
+  getSelectedSelectorIds(): SbSelector[];
+  private get focusedSelectorId();
+  getFocusedSourceId(): SbElement | null;
+  getFocusedSelectorId(): SbSelector | null;
+  setSelectedSourceIds(sourceIds: SbElement[]): void;
+  private subscribeNewSourceIdsToRuntimeSync;
+  setSelectedSelectorIds(selectorIds: SbSelector[]): void;
+  setFocusedIds(selectorId: SbSelector | null): void;
+  selectWidget(selectorId: SbSelector | null, _addToSelection?: boolean): void;
+  /**
+   * This is cursed because component selection actually needs to be done by instance ids, but
+   * instance IDs are only guaranteed to be stable after the component is rendered, while source IDs
+   * are assigned by the source tracker.
+   *
+   * If _any_ other selection comes in before we select something, we will cancel this reaction
+   */
+  selectNewComponentBySourceId(sourceId: SbElement, selectorIdsToIgnore?: Set<`S-${string}`>): Promise<void>;
+}
+//#endregion
+//#region src/edit-mode/runtime-sync/runtime-subscriptions-store.d.ts
+/**
+ * MobX store that manages runtime component subscriptions.
+ * Tracks which components are subscribed and builds fresh composites on-demand.
+ * The subscriptions getter allows startEditorSync reactions to track deep observables
+ * from buildComposite, eliminating the need for manual reaction management.
+ */
+declare class RuntimeSubscriptionsStore {
+  readonly editStore: EditStore;
+  private subscribedSourceIds;
+  constructor(editStore: EditStore);
+  subscribe(sourceId: SbElement): void;
+  unsubscribe(sourceId: SbElement): void;
+  clearAll(): void;
+  get subscriptions(): Record<SbElement, RuntimeSyncComposite | null>;
+  get jsxNodeCount(): number;
+}
+//#endregion
+//#region src/edit-mode/edit-store.d.ts
+declare global {
+  interface Window {
+    _SB_ENABLE_SESSION_RECORDING?: boolean;
+    __SUPERBLOCKS_EDITOR_HOOK__: InstanceType<typeof EditStore>;
+  }
+}
+declare class EditStore {
+  ui: UIStore;
+  operationManager: OperationManager;
+  propertiesPanelManager: PropertiesPanelManager;
+  runtimeTrackingStore: RuntimeTrackingStore;
+  connectionManager: ConnectionManager;
+  ai: AiManager;
+  runtimeSubscriptionsStore: RuntimeSubscriptionsStore;
+  isInitialized: boolean;
+  recordingInitialized: boolean;
+  interactionMode: InteractionMode;
+  lastInteractionMode: InteractionMode;
+  private viteMessageListeners;
+  constructor(rootStore: RootStore);
+  setIsInitialized(isInitialized: boolean): void;
+  setInteractionMode(mode: InteractionMode, notifyEditor?: boolean): void;
+  onViteMessage<T extends ViteMessageKind, Message extends Extract<ViteMessage, {
+    kind: T;
+  }>>(kind: T, callback: (message: Message) => void): () => void;
+  triggerViteMessage<T extends ViteMessageKind, Message extends Extract<ViteMessage, {
+    kind: T;
+  }>>(kind: T, message: Message): void;
+  startRecording(recording: {
+    userId: string;
+    appId: string;
+    sessionRecordingKey: string;
+  }): void;
+}
+//#endregion
+//#region src/lib/internal-details/lib/root-store.d.ts
+declare class RootStore {
+  apis: ApiManager;
+  componentRegistry: ComponentRegistry;
+  editStore?: EditStore;
+  locationStore: LocationStore;
+  currentPageScopeId: string | undefined;
+  applicationId: string | undefined;
+  userId: string | undefined;
+  windowOriginUrl: string | undefined;
+  private editorRegisteredCallbacks;
+  constructor();
+  setEditStore(editStore: EditStore): void;
+  onEditorRegistered(fn: () => void): void;
+}
+//#endregion
 //#region src/lib/internal-details/lib/features/component-registry.d.ts
 type DefaultTagNames = {
   container: string;
   button: string;
   text: string;
 };
+/**
+ * TODO: The component registry could be split into two a thin layer always on, and move some stuff to the EditStore.
+ * Some of the actions (rename, delete) and some of the data (isDroppable) are editor-only.
+ */
+declare class ComponentRegistry implements ComponentRegistryShareState {
+  readonly rootStore: RootStore;
+  private _componentRegistry;
+  private _componentToType;
+  private _defaultContainerType;
+  private _defaultButtonType;
+  private _defaultTextType;
+  constructor(rootStore: RootStore);
+  private getOrCreateMetadata;
+  addComponent(type: string, rawComponent: React$2.ElementType, propertiesDefinition: PropertiesDefinition): void;
+  deleteComponent(type: string): void;
+  renameComponent(oldName: string, newName: string): void;
+  addManagedProps(type: string, props: ManagedPropsList): void;
+  deleteManagedProps(type: string): void;
+  addEditorTemplate(type: string, template: EditorTemplate<any>): void;
+  getEditorTemplates(type: string): EditorTemplate<any>[] | undefined;
+  getEditorConfigFromComponentType(type: any): EditorConfig$1<any> | undefined;
+  addEditorConfig(type: string, config: EditorConfig$1): void;
+  addInternalProps(type: string, props: Array<{
+    path: string;
+    factory: () => any;
+  }>): void;
+  getInternalProps(type: string): Array<{
+    path: string;
+    factory: () => any;
+  }>;
+  getEditorConfig(type: string): EditorConfig$1<any> | undefined;
+  get entityDefinitions(): Record<string, EntityDefinition>;
+  get libraryComponentCatalogs(): CatalogWithInternalDetails[];
+  get libraryComponentEditorConfigs(): Record<string, EditorConfig$1<any>>;
+  get customComponentList(): string[];
+  get containerTypes(): Set<string>;
+  get defaultTagNames(): DefaultTagNames;
+  get managedPropsRegistry(): Map<string, ManagedPropsList>;
+  getManagedProps(type: string): ManagedPropsList;
+  /**
+   * Get the component type string for a raw component reference.
+   * Used for registry-based component identity checking.
+   */
+  getTypeForComponent(component: React$2.ComponentType<any>): string | undefined;
+  /**
+   * Check if a component or element type is registered in the component registry.
+   * Accepts both component references and string element names (e.g., "div").
+   * Used for component identity checking instead of symbol-based approach.
+   */
+  hasComponent(component: React$2.ElementType | string): boolean;
+  /**
+   * Get the property path with the record identifier if it exists. For example,
+   * `columns.columnName.label` becomes `columns.*.label`, for record properties.
+   */
+  getPropertyWithRecordIdentifier(type: string, path: string): string;
+}
 //#endregion
 //#region src/lib/internal-details/sb-wrapper.d.ts
 type InjectedProps = {
@@ -383,9 +861,9 @@ interface EditorTemplate<P extends React$1.ComponentProps<any> = React$1.Compone
    *  A modal that when drag & dropped on the page will add a trigger button.
    *  The modal is closed by default, so the selected component after drop will be the trigger button.
    */
-  create?: (context: CreationContext) => CreateRequest<P> | Array<CreateRequest<P>>;
+  create?: (context: CreationContext) => CreateRequest$1<P> | Array<CreateRequest$1<P>>;
 }
-interface CreateRequest<P extends React$1.ComponentProps<any> = React$1.ComponentProps<any>> {
+interface CreateRequest$1<P extends React$1.ComponentProps<any> = React$1.ComponentProps<any>> {
   type: string;
   properties?: PropertyValues<P>;
   createAt?: "root" | "dropLocation";
@@ -440,16 +918,19 @@ type ManagedProp<T extends DataType = DataType> = PropertyForData<T> & {
   contextual?: boolean;
   computedArgs?: EvaluateOrValueComputedArgs;
 };
+type ManagedPropsList = Array<ManagedProp & {
+  propertiesPanelDisplay?: PropertiesPanelDisplay<any>;
+}>;
 /**
  * Merges shared and variant properties for union types without creating intersections
  * Variant properties override shared properties with the same key
  */
-type MergeUnionVariant<SHARED extends Record<string, Prop<any, any>>, VARIANT extends Record<string, Prop<any, any>>> = Omit<SHARED, keyof VARIANT> & VARIANT;
+type MergeUnionVariant<SHARED$1 extends Record<string, Prop<any, any>>, VARIANT extends Record<string, Prop<any, any>>> = Omit<SHARED$1, keyof VARIANT> & VARIANT;
 /**
  * Converts a union type to an intersection type
  * Used to merge multiple section props into a single props type
  */
-type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends ((x: infer I extends U) => void) ? I : never;
+type UnionToIntersection<U$1> = (U$1 extends any ? (x: U$1) => void : never) extends ((x: infer I extends U$1) => void) ? I : never;
 /**
  * Controls how default values affect property optionality
  * - RequiredIfDefault: Properties with default values become required
@@ -579,15 +1060,15 @@ declare class Prop<Type extends DataType, _HasDefault extends boolean = false, _
    * ```
    */
   static record<T extends CompositeInputs>(props: T): RecordProp<T>;
-  static union<SHARED extends Record<string, Prop<unknown, boolean>>, VARIANTS extends UnionVariant<SHARED>[] = UnionVariant<SHARED>[]>(props: {
-    shared: SHARED;
-    variants: VARIANTS;
-  }): UnionProp<SHARED, VARIANTS, VARIANTS extends readonly any[] ? { [I in keyof VARIANTS]: SHARED & VARIANTS[I] }[number] : never>;
+  static union<SHARED$1 extends Record<string, Prop<unknown, boolean>>, VARIANTS$1 extends UnionVariant<SHARED$1>[] = UnionVariant<SHARED$1>[]>(props: {
+    shared: SHARED$1;
+    variants: VARIANTS$1;
+  }): UnionProp<SHARED$1, VARIANTS$1, VARIANTS$1 extends readonly any[] ? { [I in keyof VARIANTS$1]: SHARED$1 & VARIANTS$1[I] }[number] : never>;
   default(de: SingleInputProp<DataType>): Prop<Type, true>;
   contextual<TContext extends any[] | undefined = any[]>(computedArgs?: EvaluateOrValueComputedArgs): Prop<Type, _HasDefault, TContext>;
   setName(name: string): this;
   propertiesPanel<CT extends ControlType>(schema: Omit<Partial<PropertiesPanelDisplay<Type, CT>>, "isTriggerProperty">): this;
-  setDisplayProperty<K extends keyof PropertiesPanelDisplay<Type>>(property: K, value: PropertiesPanelDisplay<Type>[K]): this;
+  setDisplayProperty<K$1 extends keyof PropertiesPanelDisplay<Type>>(property: K$1, value: PropertiesPanelDisplay<Type>[K$1]): this;
   docs(docs: Exclude<PropertyForData<DataType>["docs"], undefined>): this;
   build(): ManagedProp<Type>;
   toDefinition(props: Record<string, unknown>): WidgetPropertyDefinition<DataType> | undefined;
@@ -645,13 +1126,13 @@ declare class FunctionProp<ARGS extends any[] = any[], RETURN = any> extends Pro
   actionPanel(panel?: ActionPanel): this;
   getActionPanel(): ActionPanel | undefined;
 }
-type UnionVariant<SHARED extends Record<string, Prop<any>>> = { [K in keyof SHARED]: Prop<any> };
-declare class UnionProp<SHARED extends Record<string, Prop<unknown, boolean>>, VARIANTS extends UnionVariant<SHARED>[] = UnionVariant<SHARED>[], _OUTPUT = (VARIANTS extends readonly any[] ? { [I in keyof VARIANTS]: SHARED & VARIANTS[I] }[number] : never)> extends Prop<any> {
+type UnionVariant<SHARED$1 extends Record<string, Prop<any>>> = { [K in keyof SHARED$1]: Prop<any> };
+declare class UnionProp<SHARED$1 extends Record<string, Prop<unknown, boolean>>, VARIANTS$1 extends UnionVariant<SHARED$1>[] = UnionVariant<SHARED$1>[], _OUTPUT = (VARIANTS$1 extends readonly any[] ? { [I in keyof VARIANTS$1]: SHARED$1 & VARIANTS$1[I] }[number] : never)> extends Prop<any> {
   typeString: "union";
-  shared: SHARED;
-  variants: VARIANTS;
-  constructor(shared: SHARED, variants: VARIANTS);
-  getProps(): SHARED & Record<string, Prop<any, false, undefined>>;
+  shared: SHARED$1;
+  variants: VARIANTS$1;
+  constructor(shared: SHARED$1, variants: VARIANTS$1);
+  getProps(): SHARED$1 & Record<string, Prop<any, false, undefined>>;
 }
 //#endregion
 //#region src/lib/user-facing/components/app/props.d.ts
@@ -782,5 +1263,5 @@ declare const tailwindStylesCategory: (props?: {
   className: string;
 }>;
 //#endregion
-export { App, type CreateChild, type CreationContext, type EditorConfig, type EditorTemplate, type FromChildToParentMessageTypes, type FromChildToParentMessageTypesMap, type FromParentToChildMessageTypes, type FromParentToChildMessageTypesMap, PageNotFound, Prop, type PropertiesPanelDefinition, Property, PropsCategory, RouteLoadError, Section, SbProvider as SuperblocksProvider, registerComponent, tailwindStylesCategory, useApiStateful as useApi, useSuperblocksGroups, useSuperblocksProfiles, useSuperblocksUser };
+export { App, type CreateChild, type CreationContext, type EditorConfig, type EditorTemplate, type FromChildToParentMessageTypes, type FromChildToParentMessageTypesMap, type FromParentToChildMessageTypes, type FromParentToChildMessageTypesMap, PageNotFound, Prop, type PropertiesPanelDefinition, Property, PropsCategory, RouteLoadError, Section, SbProvider as SuperblocksProvider, getAppMode, registerComponent, tailwindStylesCategory, useApiStateful as useApi, useSuperblocksGroups, useSuperblocksProfiles, useSuperblocksUser };
 //# sourceMappingURL=index.d.ts.map