@wix/zero-config-implementation 1.6.0 → 1.8.0

package/dist/information-extractors/react/extractors/core/index.d.ts

@@ -1,6 +1,6 @@
 export { ExtractorStore } from './store';
 export { runExtractors } from './runner';
-export type { ExtractionResult } from './runner';
+export type { ExtractionResult, RunExtractorsOptions } from './runner';
 export { buildElementTree } from './tree-builder';
 export type { ExtractedElement } from './tree-builder';
 export type { ReactExtractor, RenderContext, CreateElementEvent, RenderCompleteEvent } from './types';

package/dist/information-extractors/react/extractors/core/runner.d.ts

@@ -8,6 +8,10 @@ export interface ExtractionResult {
     store: ExtractorStore;
     elements: ExtractedElement[];
 }
+export interface RunExtractorsOptions {
+    /** Optional HOC to wrap the component before rendering (e.g. a context provider). */
+    wrapper?: (component: ComponentType<unknown>) => ComponentType<unknown>;
+}
 /**
  * Runs extractors through the full lifecycle and returns extraction results.
  *
@@ -16,4 +20,4 @@ export interface ExtractionResult {
  * @param extractors - Array of extractors to run
  * @returns Extraction results including HTML, store, and element tree
  */
-export declare function runExtractors(componentInfo: ComponentInfo, component: ComponentType<unknown>, extractors: ReactExtractor[]): ExtractionResult;
+export declare function runExtractors(componentInfo: ComponentInfo, component: ComponentType<unknown>, extractors: ReactExtractor[], options?: RunExtractorsOptions): ExtractionResult;

package/dist/information-extractors/react/extractors/index.d.ts

@@ -4,7 +4,7 @@
  * Core infrastructure and pluggable extractors for the React information extraction system.
  */
 export { ExtractorStore, runExtractors, buildElementTree, } from './core';
-export type { ExtractionResult, ExtractedElement, ReactExtractor, RenderContext, CreateElementEvent, RenderCompleteEvent, } from './core';
+export type { ExtractionResult, RunExtractorsOptions, ExtractedElement, ReactExtractor, RenderContext, CreateElementEvent, RenderCompleteEvent, } from './core';
 export { createPropTrackerExtractor } from './prop-tracker';
 export type { PropTrackerData, PropTrackerExtractorState } from './prop-tracker';
 export { createCssPropertiesExtractor } from './css-properties';

package/dist/information-extractors/react/index.d.ts

@@ -4,6 +4,6 @@
  * API: runExtractors() with pluggable extractors
  */
 export { ExtractorStore, runExtractors, buildElementTree, createPropTrackerExtractor, createCssPropertiesExtractor, } from './extractors';
-export type { ExtractionResult, ExtractedElement, ReactExtractor, RenderContext, CreateElementEvent, RenderCompleteEvent, PropTrackerData, PropTrackerExtractorState, CssPropertiesData, } from './extractors';
+export type { ExtractionResult, RunExtractorsOptions, ExtractedElement, ReactExtractor, RenderContext, CreateElementEvent, RenderCompleteEvent, PropTrackerData, PropTrackerExtractorState, CssPropertiesData, } from './extractors';
 export type { CoupledComponentInfo, CoupledProp, TrackingStores, DOMBinding, PropReadInfo, PropWriteInfo, PropSpyMeta, } from './types';
 export type { PropSpyContext } from './utils/prop-spy';

package/dist/manifest-pipeline.d.ts

@@ -1,5 +1,5 @@
 import { ComponentInfo } from './information-extractors/ts';
-import { CoupledComponentInfo } from './information-extractors/react';
+import { RunExtractorsOptions, CoupledComponentInfo } from './information-extractors/react';
 import { CSSParserAPI } from './information-extractors/css';
 import { ComponentType } from 'react';
 /** A non-fatal issue encountered during component processing. */
@@ -30,4 +30,4 @@ export interface ProcessComponentResult {
  * encountered during processing. Always returns a component, falling back
  * to minimal info (without DOM coupling) when rendering fails.
  */
-export declare function processComponent(componentInfo: ComponentInfo, loadComponent: (componentName: string) => ComponentType<unknown> | null, cssImportPaths: string[], loaderHasError?: boolean): ProcessComponentResult;
+export declare function processComponent(componentInfo: ComponentInfo, loadComponent: (componentName: string) => ComponentType<unknown> | null, cssImportPaths: string[], loaderHasError?: boolean, options?: RunExtractorsOptions): ProcessComponentResult;

package/dist/module-loader.d.ts

@@ -0,0 +1,20 @@
+import { ResultAsync } from 'neverthrow';
+import { ComponentType } from 'react';
+import { IoError } from './errors';
+type IoErrorInstance = InstanceType<typeof IoError>;
+/**
+ * Attempts to load a module, first via ESM `import()`, then via CJS `require`.
+ *
+ * ESM `import()` is preferred because it participates in the ESM loader hook
+ * pipeline (registered via `module.register()` in the CLI). This is required
+ * for JSX interception to work — the loader hook redirects `react/jsx-runtime`
+ * to the interceptable version. CJS `require()` bypasses ESM hooks even when
+ * loading ESM modules (Node 22+), so it's only used as a fallback.
+ *
+ * @param entryPath - Absolute path to the module entry point.
+ * @returns A `ResultAsync` containing the module exports on success.
+ * @errors {IoError} When both ESM import and CJS require fail.
+ */
+export declare function loadModule(entryPath: string): ResultAsync<Record<string, unknown>, IoErrorInstance>;
+export declare function findComponent(moduleExports: Record<string, unknown>, name: string): ComponentType<unknown> | null;
+export {};

package/dist/schema.d.ts

@@ -77,6 +77,7 @@ export declare const DATA: {
         readonly edgeAnchorLinks: "edgeAnchorLinks";
         readonly loginToWixLink: "loginToWixLink";
     };
+    WIX_TYPE_TO_DATA_TYPE: Record<string, "number" | "function" | "UNKNOWN_DataType" | "text" | "textEnum" | "booleanValue" | "a11y" | "link" | "image" | "video" | "vectorArt" | "audio" | "schema" | "localDate" | "localTime" | "localDateTime" | "webUrl" | "email" | "phone" | "hostname" | "regex" | "guid" | "richText" | "container" | "arrayItems" | "direction" | "menuItems" | "data" | "onClick" | "onChange" | "onKeyPress" | "onKeyUp" | "onSubmit">;
 };
 export declare const MEDIA: {
     VIDEO_CATEGORY: {

package/package.json

@@ -4,7 +4,7 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Core library for extracting component manifests from JS and CSS files",
   "type": "module",
   "main": "dist/index.js",
@@ -50,14 +50,11 @@
     "modern-errors-cli": "^6.0.0",
     "neverthrow": "^8.2.0",
     "parse5": "^7.1.2",
-    "pkg-entry-points": "^1.1.1",
     "react-docgen-typescript": "^2.4.0",
-    "read-package-up": "^11.0.0",
     "tsconfck": "^3.1.6",
     "typedoc": "^0.28.16",
     "typedoc-plugin-markdown": "^4.9.0",
     "vite": "^7.3.1",
-    "vite-node": "^5.3.0",
     "vite-plugin-dts": "^4.5.4",
     "vitest": "^4.0.17"
   },
@@ -77,5 +74,5 @@
       ]
     }
   },
-  "falconPackageHash": "bff28693b4f361afc6884e6bd88e888aaa2338365192170e935df129"
+  "falconPackageHash": "8ca973dc7cc82c6e8d0a333de6717b866e33337ee211bd335f3fa800"
 }

package/src/converters/data-item-builder.ts

@@ -12,7 +12,6 @@
  * resolved type metadata is inconsistent (kind === 'array' but no elementType).
  */
 
-import { camelCase } from 'case-anything'
 import type { Result } from 'neverthrow'
 import { err, ok } from 'neverthrow'
 import { ParseError } from '../errors'
@@ -21,7 +20,7 @@ import type { DataItem } from '../schema'
 import { DATA, MEDIA } from '../schema'
 import { formatDisplayName } from './utils'
 
-const { DATA_TYPE } = DATA
+const { DATA_TYPE, WIX_TYPE_TO_DATA_TYPE } = DATA
 
 type ParseErrorInstance = InstanceType<typeof ParseError>
 
@@ -279,10 +278,10 @@ function handleSemanticType(dataItem: DataItem, resolvedType: ResolvedType): voi
     return
   }
 
-  // Wix public-schemas (Builder) types - map directly to DATA_TYPE via camelCase conversion
+  // Wix public-schemas (Builder) types - map directly to DATA_TYPE via explicit lookup
   if (source === '@wix/public-schemas') {
-    const dataTypeKey = camelCase(semanticValue) as keyof typeof DATA_TYPE
-    if (dataTypeKey in DATA_TYPE) {
+    const dataTypeKey = WIX_TYPE_TO_DATA_TYPE[semanticValue]
+    if (dataTypeKey) {
       dataItem.dataType = DATA_TYPE[dataTypeKey]
       applyDataToBuilderType(dataItem, dataTypeKey)
     } else {

package/src/converters/utils.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest'
+import { formatDisplayName } from './utils'
+
+describe('formatDisplayName', () => {
+  it('maps a11y to Accessibility', () => {
+    expect(formatDisplayName('a11y')).toBe('Accessibility')
+  })
+
+  it('formats kebab-case', () => {
+    expect(formatDisplayName('input-field-weight')).toBe('Input Field Weight')
+  })
+
+  it('formats camelCase', () => {
+    expect(formatDisplayName('camelCaseExample')).toBe('Camel Case Example')
+  })
+})

package/src/converters/utils.ts

@@ -4,6 +4,10 @@
 
 import { capitalCase } from 'case-anything'
 
+const DISPLAY_NAME_OVERRIDES = {
+  a11y: 'Accessibility',
+} as const
+
 /**
  * Formats any string format to Title Case display name
  * Handles: kebab-case, camelCase, PascalCase, snake_case, SCREAMING_SNAKE_CASE, and mixed formats
@@ -15,7 +19,11 @@ import { capitalCase } from 'case-anything'
  *   "snake_case_example" -> "Snake Case Example"
  *   "SCREAMING_SNAKE_CASE" -> "Screaming Snake Case"
  *   "mixed-format_example" -> "Mixed Format Example"
+ *   "a11y" -> "Accessibility"
  */
 export function formatDisplayName(input: string): string {
+  if (input in DISPLAY_NAME_OVERRIDES) {
+    return DISPLAY_NAME_OVERRIDES[input as keyof typeof DISPLAY_NAME_OVERRIDES]
+  }
   return capitalCase(input, { keepSpecialCharacters: false })
 }

package/src/index.ts

@@ -11,8 +11,9 @@ import { compileTsFile } from './ts-compiler'
 import { type NotFoundError, ParseError } from './errors'
 
 // Component loader helpers
-import { findComponent, loadModule } from './component-loader'
+import { findComponent, loadModule } from './module-loader'
 
+import type { RunExtractorsOptions } from './information-extractors/react'
 // Pipeline orchestration
 import { processComponent } from './manifest-pipeline'
 export type {
@@ -36,6 +37,8 @@ export interface ManifestResult {
   errors: ExtractionError[]
 }
 
+export type { RunExtractorsOptions } from './information-extractors/react'
+
 export interface ExtractionError {
   componentName: string
   phase: 'render' | 'coupling' | 'css' | 'loader' | 'conversion'
@@ -59,6 +62,7 @@ export interface ExtractionError {
 export function extractComponentManifest(
   componentPath: string,
   compiledEntryPath: string,
+  options?: RunExtractorsOptions,
 ): ResultAsync<ManifestResult, InstanceType<typeof NotFoundError> | InstanceType<typeof ParseError>> {
   // Step 1: Load the compiled package module (non-fatal)
   return loadModule(compiledEntryPath)
@@ -104,7 +108,7 @@ export function extractComponentManifest(
           // Surface loader error as a non-fatal error
           if (loaderError) {
             errors.push({
-              componentName: compiledEntryPath,
+              componentName: componentInfo.componentName,
               phase: 'loader',
               error: loaderError,
             })
@@ -126,7 +130,7 @@ export function extractComponentManifest(
           }
 
           // Step 5: Process the default-exported component (non-fatal)
-          const processResult = processComponent(componentInfo, loadComponent, cssImportPaths, !!loaderError)
+          const processResult = processComponent(componentInfo, loadComponent, cssImportPaths, !!loaderError, options)
           errors.push(...processResult.warnings)
           const component = toEditorReactComponent(processResult.component)
 
@@ -216,8 +220,8 @@ export {
   withDefectBoundary,
 } from './errors'
 
-/** Component loader */
-export { createComponentLoader } from './component-loader'
+/** Module loader primitives */
+export { loadModule, findComponent } from './module-loader'
 
 // ── Tier 3: Low-Level Renderer ──────────────────────────────────────────────
 

package/src/information-extractors/react/extractors/core/index.ts

@@ -1,6 +1,6 @@
 export { ExtractorStore } from './store'
 export { runExtractors } from './runner'
-export type { ExtractionResult } from './runner'
+export type { ExtractionResult, RunExtractorsOptions } from './runner'
 export { buildElementTree } from './tree-builder'
 export type { ExtractedElement } from './tree-builder'
 export type { ReactExtractor, RenderContext, CreateElementEvent, RenderCompleteEvent } from './types'

package/src/information-extractors/react/extractors/core/runner.ts

@@ -27,6 +27,11 @@ export interface ExtractionResult {
   elements: ExtractedElement[]
 }
 
+export interface RunExtractorsOptions {
+  /** Optional HOC to wrap the component before rendering (e.g. a context provider). */
+  wrapper?: (component: ComponentType<unknown>) => ComponentType<unknown>
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Runner
 // ─────────────────────────────────────────────────────────────────────────────
@@ -43,6 +48,7 @@ export function runExtractors(
   componentInfo: ComponentInfo,
   component: ComponentType<unknown>,
   extractors: ReactExtractor[],
+  options?: RunExtractorsOptions,
 ): ExtractionResult {
   // Reset mock counter for reproducible results
   resetMockCounter()
@@ -74,8 +80,11 @@ export function runExtractors(
     },
   ]
 
+  // Apply optional HOC wrapper before rendering
+  const renderComponent = options?.wrapper ? options.wrapper(context.component) : context.component
+
   // Phase 2: Render with element creation interception
-  const html = renderWithExtractors(context.component, context.props, listeners, store)
+  const html = renderWithExtractors(renderComponent, context.props, listeners, store)
 
   // Phase 3: renderComplete - extractors can post-process
   for (const ext of extractors) {

package/src/information-extractors/react/extractors/index.ts

@@ -12,6 +12,7 @@ export {
 } from './core'
 export type {
   ExtractionResult,
+  RunExtractorsOptions,
   ExtractedElement,
   ReactExtractor,
   RenderContext,

package/src/information-extractors/react/index.ts

@@ -21,6 +21,7 @@ export {
 export type {
   // Core types
   ExtractionResult,
+  RunExtractorsOptions,
   ExtractedElement,
   ReactExtractor,
   RenderContext,

package/src/information-extractors/ts/components.ts

@@ -158,7 +158,19 @@ function findPropsType(
   if (!moduleSymbol) return undefined
 
   const exports = checker.getExportsOfModule(moduleSymbol)
-  const componentSymbol = exports.find((s) => s.getName() === componentName)
+  let componentSymbol = exports.find((s) => s.getName() === componentName)
+
+  // If not found by name, check whether the default export resolves to the component
+  if (!componentSymbol) {
+    const defaultSymbol = exports.find((s) => s.getName() === 'default')
+    if (defaultSymbol && (defaultSymbol.getFlags() & ts.SymbolFlags.Alias) !== 0) {
+      const resolved = checker.getAliasedSymbol(defaultSymbol)
+      if (resolved.getName() === componentName) {
+        componentSymbol = resolved
+      }
+    }
+  }
+
   if (!componentSymbol) return undefined
 
   const componentType = checker.getTypeOfSymbol(componentSymbol)

package/src/information-extractors/ts/utils/semantic-type-resolver.ts

@@ -1,13 +1,12 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
-import { camelCase } from 'case-anything'
 import ts from 'typescript'
 import { DATA } from '../../../schema'
 import type { PropInfo, ResolvedType } from '../types'
 
 const MAX_RESOLVE_DEPTH = 30
 
-const { DATA_TYPE } = DATA
+const { WIX_TYPE_TO_DATA_TYPE } = DATA
 
 /**
  * Cache for package name lookups
@@ -50,8 +49,7 @@ const VALID_REACT_SEMANTIC_TYPES = new Set(['ReactNode', 'ReactElement'])
  * Checks if a Wix type name maps to a valid DATA_TYPE key
  */
 function isValidWixSemanticType(symbolName: string): boolean {
-  const camelCaseKey = camelCase(symbolName)
-  return camelCaseKey in DATA_TYPE
+  return symbolName in WIX_TYPE_TO_DATA_TYPE
 }
 
 /**

package/src/manifest-pipeline.ts

@@ -6,6 +6,7 @@ import type { PropInfo } from './information-extractors/ts/types'
 import {
   type ExtractedElement,
   type PropTrackerData,
+  type RunExtractorsOptions,
   createCssPropertiesExtractor,
   createPropTrackerExtractor,
   runExtractors,
@@ -62,6 +63,7 @@ export function processComponent(
   loadComponent: (componentName: string) => ComponentType<unknown> | null,
   cssImportPaths: string[],
   loaderHasError?: boolean,
+  options?: RunExtractorsOptions,
 ): ProcessComponentResult {
   const warnings: ExtractionWarning[] = []
 
@@ -97,7 +99,7 @@ export function processComponent(
       const { extractor: propTracker, state } = createPropTrackerExtractor()
       const cssExtractor = createCssPropertiesExtractor()
 
-      const result = runExtractors(componentInfo, Component, [propTracker, cssExtractor])
+      const result = runExtractors(componentInfo, Component, [propTracker, cssExtractor], options)
       html = result.html
       extractedElements = result.elements
 

package/src/module-loader.ts

@@ -0,0 +1,76 @@
+import { createRequire } from 'node:module'
+import { pascalCase } from 'case-anything'
+import { ResultAsync, errAsync, okAsync } from 'neverthrow'
+import type { ComponentType } from 'react'
+import { IoError } from './errors'
+
+type IoErrorInstance = InstanceType<typeof IoError>
+
+/**
+ * Attempts to load a module, first via ESM `import()`, then via CJS `require`.
+ *
+ * ESM `import()` is preferred because it participates in the ESM loader hook
+ * pipeline (registered via `module.register()` in the CLI). This is required
+ * for JSX interception to work — the loader hook redirects `react/jsx-runtime`
+ * to the interceptable version. CJS `require()` bypasses ESM hooks even when
+ * loading ESM modules (Node 22+), so it's only used as a fallback.
+ *
+ * @param entryPath - Absolute path to the module entry point.
+ * @returns A `ResultAsync` containing the module exports on success.
+ * @errors {IoError} When both ESM import and CJS require fail.
+ */
+export function loadModule(entryPath: string): ResultAsync<Record<string, unknown>, IoErrorInstance> {
+  return ResultAsync.fromPromise(import(entryPath) as Promise<Record<string, unknown>>, () => null).orElse(() => {
+    try {
+      const require = createRequire(import.meta.url)
+      const exports = require(entryPath)
+      return okAsync(exports as Record<string, unknown>)
+    } catch (requireErr) {
+      const cause = requireErr instanceof Error ? requireErr : new Error(String(requireErr))
+      return errAsync(
+        new IoError(`Failed to load ${entryPath}: ${cause.message}`, {
+          cause,
+          props: { phase: 'load' },
+        }),
+      )
+    }
+  })
+}
+
+function isPascalCase(name: string): boolean {
+  return name.length > 0 && pascalCase(name) === name
+}
+
+function isComponent(value: unknown): value is ComponentType<unknown> {
+  if (typeof value === 'function') return isPascalCase(value.name)
+  // React.memo() and React.forwardRef() return objects, not functions
+  if (typeof value === 'object' && value !== null && '$$typeof' in value) return true
+  return false
+}
+
+export function findComponent(moduleExports: Record<string, unknown>, name: string): ComponentType<unknown> | null {
+  // Direct named export
+  const direct = moduleExports[name]
+  if ((typeof direct === 'function' && isPascalCase(name)) || isComponent(direct)) {
+    return direct as ComponentType<unknown>
+  }
+
+  // Check default export
+  const defaultExport = moduleExports.default
+  if (defaultExport) {
+    // default is the component itself (matches by function name)
+    if (typeof defaultExport === 'function' && defaultExport.name === name) {
+      return defaultExport as ComponentType<unknown>
+    }
+
+    // CJS interop: default is an object with named exports
+    if (typeof defaultExport === 'object' && defaultExport !== null) {
+      const nested = (defaultExport as Record<string, unknown>)[name]
+      if (isComponent(nested)) {
+        return nested as ComponentType<unknown>
+      }
+    }
+  }
+
+  return null
+}

package/src/schema.ts

@@ -116,7 +116,39 @@ const ELEMENT_TYPE = {
   refElement: 'refElement',
 } as const
 
-export const DATA = { DATA_TYPE, A11Y_ATTRIBUTES, LINK_TYPE }
+/**
+ * Maps @wix/public-schemas type names (PascalCase) to their DATA_TYPE keys.
+ * Derived from the exports of @wix/public-schemas.
+ */
+const WIX_TYPE_TO_DATA_TYPE: Record<string, keyof typeof DATA_TYPE> = {
+  Link: 'link',
+  Image: 'image',
+  Video: 'video',
+  VectorArt: 'vectorArt',
+  A11y: 'a11y',
+  Audio: 'audio',
+  MenuItems: 'menuItems',
+  Schema: 'schema',
+  Text: 'text',
+  TextEnum: 'textEnum',
+  NumberType: 'number',
+  BooleanValue: 'booleanValue',
+  LocalDate: 'localDate',
+  LocalTime: 'localTime',
+  LocalDateTime: 'localDateTime',
+  WebUrl: 'webUrl',
+  Email: 'email',
+  Phone: 'phone',
+  Hostname: 'hostname',
+  Regex: 'regex',
+  Guid: 'guid',
+  RichText: 'richText',
+  Container: 'container',
+  ArrayItems: 'arrayItems',
+  Direction: 'direction',
+}
+
+export const DATA = { DATA_TYPE, A11Y_ATTRIBUTES, LINK_TYPE, WIX_TYPE_TO_DATA_TYPE }
 export const MEDIA = { VIDEO_CATEGORY, VECTOR_ART_CATEGORY, IMAGE_CATEGORY }
 export const ELEMENTS = { ELEMENT_TYPE }
 

package/vite.config.ts

@@ -25,6 +25,12 @@ export default defineConfig({
         if (id.startsWith('node:') || builtinModules.includes(id) || ['typescript', 'lightningcss'].includes(id)) {
           return true
         }
+        // Externalize React so the host project's React instance is used at runtime.
+        // Bundling React creates a second instance that causes hook failures when
+        // user components resolve a different React from their own node_modules.
+        if (id === 'react' || id === 'react-dom' || id.startsWith('react/') || id.startsWith('react-dom/')) {
+          return true
+        }
         return false
       },
     },

package/dist/component-loader.d.ts

@@ -1,42 +0,0 @@
-import { ResultAsync } from 'neverthrow';
-import { ComponentType } from 'react';
-import { IoError, NotFoundError } from './errors';
-type NotFoundErrorInstance = InstanceType<typeof NotFoundError>;
-type IoErrorInstance = InstanceType<typeof IoError>;
-export type LoaderError = NotFoundErrorInstance | IoErrorInstance;
-export interface ComponentLoaderResult {
-    loadComponent: (name: string) => ComponentType<unknown> | null;
-    packageName: string;
-    entryPath: string | undefined;
-    exportNames: string[];
-}
-/**
- * Creates a component loader that dynamically loads components from the
- * user's package. Finds the nearest package.json, resolves its entry point,
- * and loads the module.
- *
- * The returned `loadComponent` is synchronous (required by processComponent).
- * ESM modules are loaded via async `import()` during creation, so this
- * function itself is async.
- *
- * @returns A `ResultAsync` containing a `ComponentLoaderResult` on success.
- * @errors {NotFoundError} When no package.json is found or the package has no resolvable entry points.
- * @errors {IoError} When module loading fails (CJS require or ESM import).
- */
-export declare function createComponentLoader(componentPath: string): ResultAsync<ComponentLoaderResult, LoaderError>;
-/**
- * Attempts to load a module, first via ESM `import()`, then via CJS `require`.
- *
- * ESM `import()` is preferred because it participates in the ESM loader hook
- * pipeline (registered via `module.register()` in the CLI). This is required
- * for JSX interception to work — the loader hook redirects `react/jsx-runtime`
- * to the interceptable version. CJS `require()` bypasses ESM hooks even when
- * loading ESM modules (Node 22+), so it's only used as a fallback.
- *
- * @param entryPath - Absolute path to the module entry point.
- * @returns A `ResultAsync` containing the module exports on success.
- * @errors {IoError} When both ESM import and CJS require fail.
- */
-export declare function loadModule(entryPath: string): ResultAsync<Record<string, unknown>, IoErrorInstance>;
-export declare function findComponent(moduleExports: Record<string, unknown>, name: string): ComponentType<unknown> | null;
-export {};