@asymmetric-effort/specifyjs 0.2.97 → 0.2.100

package/dist/types/core/src/core/lazy.d.ts

@@ -0,0 +1,19 @@
+import { SPEC_LAZY_TYPE, type Props, type ComponentType } from '../shared/types';
+type LazyStatus = 'pending' | 'resolved' | 'rejected';
+export interface LazyComponent<P extends Props = Props> {
+    $$typeof: typeof SPEC_LAZY_TYPE;
+    _payload: {
+        _status: LazyStatus;
+        _result: ComponentType<P> | unknown;
+    };
+    _init: () => ComponentType<P>;
+    displayName?: string;
+}
+/**
+ * Lazily loads a component. Must be used with Suspense.
+ * Equivalent to React.lazy.
+ */
+export declare function lazy<P extends Props>(factory: () => Promise<{
+    default: ComponentType<P>;
+}>): LazyComponent<P>;
+export {};

package/dist/types/core/src/core/memo.d.ts

@@ -0,0 +1,12 @@
+import { SPEC_MEMO_TYPE, type Props, type ComponentType } from '../shared/types';
+export interface MemoComponent<P extends Props = Props> {
+    $$typeof: typeof SPEC_MEMO_TYPE;
+    type: ComponentType<P>;
+    compare: ((prevProps: P, nextProps: P) => boolean) | null;
+    displayName?: string;
+}
+/**
+ * Memoizes a component, skipping re-render if props are shallowly equal.
+ * Equivalent to React.memo.
+ */
+export declare function memo<P extends Props>(component: ComponentType<P>, compare?: (prevProps: P, nextProps: P) => boolean): MemoComponent<P>;

package/dist/types/core/src/core/reconciler.d.ts

@@ -0,0 +1,11 @@
+import { type Fiber, type SpecNode } from '../shared/types';
+/**
+ * The reconciler is responsible for diffing old and new virtual trees,
+ * producing a set of fiber effects (placement, update, deletion) that
+ * the renderer can apply to the host environment (DOM).
+ */
+/**
+ * Reconciles the children of a fiber, producing a linked list of child fibers.
+ * This implements React's reconciliation algorithm including keyed diffing.
+ */
+export declare function reconcileChildren(returnFiber: Fiber, currentFirstChild: Fiber | null, newChildren: SpecNode, lanes: number): Fiber | null;

package/dist/types/core/src/core/scheduler-host-config.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Host scheduling configuration for concurrent rendering.
+ *
+ * Abstracts the platform-specific scheduling primitives behind a swappable
+ * interface. In browsers, uses MessageChannel for macrotask scheduling with
+ * a 5ms frame budget. In tests, can be replaced with a controllable mock.
+ */
+export interface SchedulerCallback {
+    (): SchedulerCallback | null;
+}
+export interface CallbackNode {
+    callback: SchedulerCallback | null;
+    cancelled: boolean;
+}
+export declare function getCurrentTime(): number;
+export declare function shouldYieldToHost(): boolean;
+export declare function resetDeadline(): void;
+/**
+ * Schedule a callback to run asynchronously. Returns a handle for cancellation.
+ * If the callback returns another function, that function is scheduled as a
+ * continuation (the work was interrupted and needs to resume).
+ */
+export declare function scheduleCallback(callback: SchedulerCallback): CallbackNode;
+/**
+ * Cancel a previously scheduled callback.
+ */
+export declare function cancelCallback(node: CallbackNode): void;
+/**
+ * Synchronously flush all pending scheduled work.
+ * Only use in tests — in production, work is scheduled asynchronously.
+ */
+export declare function flushAllWork(): void;
+/**
+ * Check if there is pending scheduled work.
+ */
+export declare function hasPendingWork(): boolean;

package/dist/types/core/src/core/scheduler.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Minimal scheduler for batching updates and scheduling work.
+ * This is the internal engine that drives re-renders.
+ */
+type Task = () => void;
+/**
+ * Schedule a task. If inside a batch, it's deferred.
+ * Otherwise it runs synchronously (or via microtask).
+ */
+export declare function scheduleUpdate(task: Task): void;
+/**
+ * Run a callback inside a batch — all updates are deferred
+ * until the batch completes.
+ */
+export declare function batchUpdates<T>(fn: () => T): T;
+/**
+ * Flush all pending tasks synchronously.
+ */
+export declare function flushPendingTasks(): void;
+/**
+ * Schedule work via microtask for async batching.
+ */
+export declare function scheduleMicrotask(fn: () => void): void;
+/**
+ * Check if we're currently batching.
+ */
+export declare function isBatching(): boolean;
+export {};

package/dist/types/core/src/core/transitions.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Get the lane that should be assigned to a new state update.
+ * Respects the current context: flushSync → SyncLane,
+ * startTransition → TransitionLane, else DefaultLane.
+ */
+export declare function requestUpdateLane(): number;
+/**
+ * Enter flushSync context. State updates within will use SyncLane.
+ */
+export declare function enterFlushSyncContext(): void;
+/**
+ * Exit flushSync context.
+ */
+export declare function exitFlushSyncContext(): void;
+/**
+ * Marks a state update as a transition (non-urgent).
+ * Equivalent to React.startTransition.
+ *
+ * State updates called within the callback receive TransitionLane priority
+ * instead of DefaultLane, allowing them to be interrupted by higher-priority
+ * updates (user input, flushSync, etc.).
+ */
+export declare function startTransition(callback: () => void): void;
+/**
+ * Check if we're currently inside a transition.
+ */
+export declare function isInTransition(): boolean;
+/**
+ * Queue a callback to run at the end of the current transition batch.
+ */
+export declare function queueTransitionCallback(callback: () => void): void;

package/dist/types/core/src/devtools/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * DevTools integration hooks.
+ * Allows browser extensions to inspect the SpecifyJS component tree.
+ */
+import type { Fiber } from '../shared/types';
+/**
+ * Connect to DevTools if available (e.g., via browser extension).
+ */
+export declare function connectDevTools(): void;
+/**
+ * Notify DevTools of a commit.
+ */
+export declare function notifyDevToolsOfCommit(root: unknown): void;
+/**
+ * Notify DevTools of an unmount.
+ */
+export declare function notifyDevToolsOfUnmount(fiber: Fiber): void;
+/**
+ * Check if DevTools is connected.
+ */
+export declare function isDevToolsConnected(): boolean;

package/dist/types/core/src/dom/create-portal.d.ts

@@ -0,0 +1,6 @@
+import { type SpecElement, type SpecNode, type Key } from '../shared/types';
+/**
+ * Creates a portal to render children into a different DOM subtree.
+ * Equivalent to ReactDOM.createPortal.
+ */
+export declare function createPortal(children: SpecNode, container: Element, key?: Key): SpecElement;

package/dist/types/core/src/dom/create-root.d.ts

@@ -0,0 +1,23 @@
+import type { SpecNode } from '../shared/types';
+export interface Root {
+    render(children: SpecNode): void;
+    unmount(): void;
+}
+export interface RootOptions {
+    onRecoverableError?: (error: unknown) => void;
+    identifierPrefix?: string;
+}
+/**
+ * Creates a concurrent root for rendering.
+ * Equivalent to ReactDOM.createRoot.
+ */
+export declare function createRoot(container: Element | DocumentFragment, _options?: RootOptions): Root;
+/**
+ * Creates a root for hydrating server-rendered content.
+ * Equivalent to ReactDOM.hydrateRoot.
+ *
+ * Unlike createRoot, this preserves the existing DOM in the container and
+ * attempts to reuse DOM nodes during the initial render. Event listeners
+ * and component state are attached to the existing DOM structure.
+ */
+export declare function hydrateRoot(container: Element | Document, initialChildren: SpecNode, _options?: RootOptions): Root;

package/dist/types/core/src/dom/flush-sync.d.ts

@@ -0,0 +1 @@
+export declare function flushSync<T>(fn: () => T): T;

package/dist/types/core/src/dom/index.d.ts

@@ -0,0 +1,4 @@
+export { createRoot, hydrateRoot } from './create-root';
+export { createPortal } from './create-portal';
+export { flushSync } from './flush-sync';
+export { render, hydrate, unmountComponentAtNode } from './legacy';

package/dist/types/core/src/dom/legacy.d.ts

@@ -0,0 +1,16 @@
+import type { SpecNode } from '../shared/types';
+/**
+ * Legacy render API.
+ * Equivalent to ReactDOM.render (pre-React 18).
+ */
+export declare function render(element: SpecNode, container: Element, callback?: () => void): void;
+/**
+ * Legacy hydrate API.
+ * Equivalent to ReactDOM.hydrate (pre-React 18).
+ */
+export declare function hydrate(element: SpecNode, container: Element, callback?: () => void): void;
+/**
+ * Legacy unmount API.
+ * Equivalent to ReactDOM.unmountComponentAtNode.
+ */
+export declare function unmountComponentAtNode(container: Element): boolean;

package/dist/types/core/src/dom/synthetic-event.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Synthetic event system with cross-browser normalization.
+ * Events are delegated to the root container for efficiency.
+ */
+export declare class SyntheticEvent {
+    readonly nativeEvent: Event;
+    readonly type: string;
+    readonly target: EventTarget | null;
+    readonly currentTarget: EventTarget | null;
+    readonly timeStamp: number;
+    readonly bubbles: boolean;
+    readonly cancelable: boolean;
+    readonly defaultPrevented: boolean;
+    readonly eventPhase: number;
+    readonly isTrusted: boolean;
+    private _isPropagationStopped;
+    private _isDefaultPrevented;
+    constructor(nativeEvent: Event);
+    preventDefault(): void;
+    stopPropagation(): void;
+    stopImmediatePropagation(): void;
+    isDefaultPrevented(): boolean;
+    isPropagationStopped(): boolean;
+    persist(): void;
+}
+export declare class SyntheticMouseEvent extends SyntheticEvent {
+    readonly clientX: number;
+    readonly clientY: number;
+    readonly pageX: number;
+    readonly pageY: number;
+    readonly screenX: number;
+    readonly screenY: number;
+    readonly button: number;
+    readonly buttons: number;
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly metaKey: boolean;
+    readonly shiftKey: boolean;
+    readonly movementX: number;
+    readonly movementY: number;
+    readonly relatedTarget: EventTarget | null;
+    constructor(nativeEvent: MouseEvent);
+    getModifierState(key: string): boolean;
+}
+export declare class SyntheticKeyboardEvent extends SyntheticEvent {
+    readonly key: string;
+    readonly code: string;
+    readonly location: number;
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly metaKey: boolean;
+    readonly shiftKey: boolean;
+    readonly repeat: boolean;
+    constructor(nativeEvent: KeyboardEvent);
+    getModifierState(key: string): boolean;
+}
+export declare class SyntheticFocusEvent extends SyntheticEvent {
+    readonly relatedTarget: EventTarget | null;
+    constructor(nativeEvent: FocusEvent);
+}
+export declare class SyntheticInputEvent extends SyntheticEvent {
+    readonly data: string | null;
+    readonly inputType: string;
+    constructor(nativeEvent: InputEvent);
+}
+export declare class SyntheticTouchEvent extends SyntheticEvent {
+    readonly touches: TouchList;
+    readonly targetTouches: TouchList;
+    readonly changedTouches: TouchList;
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly metaKey: boolean;
+    readonly shiftKey: boolean;
+    constructor(nativeEvent: TouchEvent);
+}
+export declare class SyntheticWheelEvent extends SyntheticEvent {
+    readonly deltaX: number;
+    readonly deltaY: number;
+    readonly deltaZ: number;
+    readonly deltaMode: number;
+    constructor(nativeEvent: WheelEvent);
+}
+/**
+ * Create the appropriate synthetic event wrapper for a native event.
+ */
+export declare function createSyntheticEvent(nativeEvent: Event): SyntheticEvent;
+/**
+ * Map of React-style event names to DOM event names.
+ */
+export declare const EVENT_NAME_MAP: Record<string, string>;

package/dist/types/core/src/dom/work-loop.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The work loop drives the rendering pipeline:
+ * 1. Begin work: traverse fibers, render components, reconcile children
+ * 2. Complete work: build DOM nodes bottom-up
+ * 3. Commit: apply mutations to the real DOM, run effects
+ */
+import { type Fiber, type Props, type SpecNode } from '../shared/types';
+export interface FiberRoot {
+    containerNode: Element | DocumentFragment;
+    current: Fiber;
+    pendingChildren: SpecNode;
+    callbackScheduled: boolean;
+    pendingLanes: number;
+    suspendedLanes: number;
+    expirationTimes: number[];
+    callbackNode: unknown;
+    callbackPriority: number;
+    isHydrating: boolean;
+}
+declare const fiberRoots: Map<Element | DocumentFragment, FiberRoot>;
+export declare function createFiberRoot(container: Element | DocumentFragment): FiberRoot;
+export declare function scheduleRender(root: FiberRoot, children: SpecNode): void;
+export declare function performSyncWork(root: FiberRoot, children: SpecNode): void;
+/**
+ * Mark a root as having pending work at the given lane.
+ */
+export declare function markRootUpdated(root: FiberRoot, lane: number): void;
+/**
+ * Ensure that work is scheduled for a root. This is the central coordinator
+ * that decides whether to use sync or concurrent rendering based on lanes.
+ */
+export declare function ensureRootIsScheduled(root: FiberRoot): void;
+export declare function updateDOMProperties(dom: HTMLElement, prevProps: Props | Record<string, unknown>, nextProps: Props): void;
+export { fiberRoots };

package/dist/types/core/src/features/feature-flags.d.ts

@@ -0,0 +1,38 @@
+import type { SpecNode } from '../shared/types';
+export type FeatureFlags = Record<string, boolean>;
+export interface FeatureFlagContextValue {
+    /** Current flag states */
+    flags: FeatureFlags;
+    /** Check if a flag is enabled */
+    isEnabled: (flag: string) => boolean;
+    /** Set a flag's state at runtime */
+    setFlag: (flag: string, enabled: boolean) => void;
+    /** Whether flags are still loading from remote */
+    loading: boolean;
+}
+export interface FeatureFlagProviderProps {
+    /** URL to fetch feature flags JSON from (optional) */
+    url?: string;
+    /** Initial/default flag values */
+    defaults?: FeatureFlags;
+    /** Children */
+    children?: SpecNode;
+}
+export declare function FeatureFlagProvider(props: FeatureFlagProviderProps): SpecNode;
+export interface FeatureGateProps {
+    /** Flag name to check */
+    flag: string;
+    /** Content to render when flag is enabled */
+    children?: SpecNode;
+    /** Content to render when flag is disabled (optional) */
+    fallback?: SpecNode;
+}
+/**
+ * Conditionally renders children based on a feature flag.
+ * Renders nothing (or fallback) when the flag is disabled.
+ */
+export declare function FeatureGate(props: FeatureGateProps): SpecNode;
+/**
+ * Hook to access feature flag state and controls.
+ */
+export declare function useFeatureFlags(): FeatureFlagContextValue;

package/dist/types/core/src/features/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Feature Flags — Conditionally render components based on feature state.
+ *
+ * Features can be loaded from a static JSON file, configured programmatically,
+ * or toggled at runtime. The FeatureFlagProvider wraps the app and provides
+ * flag state via context. FeatureGate conditionally renders children based
+ * on whether a flag is enabled.
+ *
+ * Usage:
+ * ```typescript
+ * // Wrap app with provider
+ * createElement(FeatureFlagProvider, { url: '/features.json' },
+ *   createElement(App, null),
+ * );
+ *
+ * // Gate a feature
+ * createElement(FeatureGate, { flag: 'dark-mode' },
+ *   createElement(DarkModeToggle, null),
+ * );
+ *
+ * // Use hook for custom logic
+ * const { isEnabled, flags, setFlag } = useFeatureFlags();
+ * if (isEnabled('beta-charts')) { ... }
+ * ```
+ */
+export { FeatureFlagProvider, FeatureGate, useFeatureFlags } from './feature-flags';
+export type { FeatureFlags, FeatureFlagProviderProps } from './feature-flags';

package/dist/types/core/src/hooks/dispatcher.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The concrete hook implementations that get wired up as the dispatcher
+ * when a function component is being rendered.
+ */
+import type { SpecContext, Fiber } from '../shared/types';
+export declare function setRerenderCallback(cb: ((fiber: Fiber) => void) | null): void;
+export declare function useStateImpl<T>(initialState: T | (() => T)): [T, (action: T | ((prev: T) => T)) => void];
+export declare function useReducerImpl<S, A>(reducer: (state: S, action: A) => S, initialArg: S, init?: (arg: S) => S): [S, (action: A) => void];
+export declare function useEffectDispatch(create: () => void | (() => void), deps?: readonly unknown[]): void;
+export declare function useLayoutEffectDispatch(create: () => void | (() => void), deps?: readonly unknown[]): void;
+export declare function useInsertionEffectDispatch(create: () => void | (() => void), deps?: readonly unknown[]): void;
+export declare function useContextImpl<T>(context: SpecContext<T>): T;
+export declare function useCallbackImpl<T extends (...args: any[]) => any>(callback: T, deps: readonly unknown[]): T;
+export declare function useMemoImpl<T>(factory: () => T, deps: readonly unknown[]): T;
+export declare function useRefImpl<T>(initialValue?: T): {
+    current: T | undefined;
+};
+export declare function useImperativeHandleImpl<T>(ref: {
+    current: T | null;
+} | ((instance: T | null) => void) | null, createHandle: () => T, deps?: readonly unknown[]): void;
+export declare function useDebugValueImpl<T>(_value: T, _format?: (value: T) => unknown): void;
+export declare function resetIdCounter(): void;
+export declare function useIdImpl(): string;
+export declare function useDeferredValueImpl<T>(value: T): T;
+export declare function useTransitionImpl(): [boolean, (callback: () => void) => void];
+export declare function useSyncExternalStoreImpl<T>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => T, _getServerSnapshot?: () => T): T;

package/dist/types/core/src/hooks/hook-state.d.ts

@@ -0,0 +1,46 @@
+import type { Fiber } from '../shared/types';
+/**
+ * Internal hook state management.
+ * Each fiber maintains a linked list of hook states.
+ */
+export interface Hook {
+    memoizedState: unknown;
+    queue: HookUpdate[] | null;
+    next: Hook | null;
+}
+export interface HookUpdate {
+    action: unknown;
+}
+export interface EffectHook {
+    tag: EffectHookTag;
+    create: () => void | (() => void);
+    destroy: (() => void) | null | undefined;
+    deps: readonly unknown[] | undefined;
+    next: EffectHook | null;
+}
+export declare const enum EffectHookTag {
+    NoEffect = 0,
+    HasEffect = 1,
+    Layout = 2,
+    Passive = 4,
+    Insertion = 8
+}
+export declare function setCurrentFiber(fiber: Fiber | null): void;
+export declare function getCurrentFiber(): Fiber | null;
+export declare function getCurrentHookIndex(): number;
+export declare function getHookIndex(): number;
+/**
+ * Allocate the next hook slot for the currently rendering fiber.
+ * On mount: creates a new hook.
+ * On update: advances to the next existing hook.
+ */
+export declare function allocateHook(): Hook;
+/**
+ * Push an effect onto the current fiber's effect list.
+ */
+export declare function pushEffect(tag: EffectHookTag, create: () => void | (() => void), destroy: (() => void) | null | undefined, deps: readonly unknown[] | undefined): EffectHook;
+export declare function getEffectList(): EffectHook | null;
+/**
+ * Compare dependency arrays.
+ */
+export declare function areDepsEqual(prevDeps: readonly unknown[] | undefined, nextDeps: readonly unknown[] | undefined): boolean;

package/dist/types/core/src/hooks/index.d.ts

@@ -0,0 +1,47 @@
+import type { SpecContext } from '../shared/types';
+type Dispatcher = {
+    useState: typeof useState;
+    useEffect: typeof useEffect;
+    useContext: typeof useContext;
+    useReducer: typeof useReducer;
+    useCallback: typeof useCallback;
+    useMemo: typeof useMemo;
+    useRef: typeof useRef;
+    useImperativeHandle: typeof useImperativeHandle;
+    useLayoutEffect: typeof useLayoutEffect;
+    useDebugValue: typeof useDebugValue;
+    useId: typeof useId;
+    useDeferredValue: typeof useDeferredValue;
+    useTransition: typeof useTransition;
+    useSyncExternalStore: typeof useSyncExternalStore;
+    useInsertionEffect: typeof useInsertionEffect;
+};
+export declare function __setDispatcher(dispatcher: Dispatcher | null): void;
+export declare function __getDispatcher(): Dispatcher | null;
+export declare function useState<T>(initialState: T | (() => T)): [T, (action: T | ((prev: T) => T)) => void];
+export declare function useEffect(create: () => void | (() => void), deps?: readonly unknown[]): void;
+export declare function useContext<T>(context: SpecContext<T>): T;
+export declare function useReducer<S, A>(reducer: (state: S, action: A) => S, initialArg: S, init?: (arg: S) => S): [S, (action: A) => void];
+export declare function useCallback<T extends (...args: any[]) => any>(callback: T, deps: readonly unknown[]): T;
+export declare function useMemo<T>(factory: () => T, deps: readonly unknown[]): T;
+export declare function useRef<T>(initialValue: T): {
+    current: T;
+};
+export declare function useRef<T>(initialValue: T | null): {
+    current: T | null;
+};
+export declare function useRef<T>(): {
+    current: T | undefined;
+};
+export declare function useImperativeHandle<T>(ref: {
+    current: T | null;
+} | ((instance: T | null) => void) | null, createHandle: () => T, deps?: readonly unknown[]): void;
+export declare function useLayoutEffect(create: () => void | (() => void), deps?: readonly unknown[]): void;
+export declare function useDebugValue<T>(value: T, format?: (value: T) => unknown): void;
+export declare function useId(): string;
+export declare function useDeferredValue<T>(value: T): T;
+export declare function useTransition(): [boolean, (callback: () => void) => void];
+export declare function useSyncExternalStore<T>(subscribe: (onStoreChange: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T): T;
+export declare function useInsertionEffect(create: () => void | (() => void), deps?: readonly unknown[]): void;
+export { useHead } from './use-head';
+export type { HeadMeta, HeadHttpEquiv } from './use-head';

package/dist/types/core/src/hooks/install-dispatcher.d.ts

@@ -0,0 +1,2 @@
+export declare function installDispatcher(): void;
+export declare function uninstallDispatcher(): void;

package/dist/types/core/src/hooks/use-head.d.ts

@@ -0,0 +1,54 @@
+export interface HeadHttpEquiv {
+    /** Content-Security-Policy */
+    csp?: string;
+    /** Referrer-Policy */
+    referrer?: string;
+    /** X-Content-Type-Options */
+    contentType?: string;
+    /** X-Frame-Options (via Content-Security-Policy frame-ancestors) */
+    frameOptions?: string;
+    /** Cache-Control */
+    cacheControl?: string;
+    /** Arbitrary http-equiv tags */
+    [key: string]: string | undefined;
+}
+export interface HeadMeta {
+    /** Document title */
+    title?: string;
+    /** Meta description */
+    description?: string;
+    /** Meta keywords (comma-separated) */
+    keywords?: string;
+    /** Meta author */
+    author?: string;
+    /** Canonical URL */
+    canonical?: string;
+    /** Open Graph tags */
+    og?: Record<string, string>;
+    /** Twitter card tags */
+    twitter?: Record<string, string>;
+    /** HTTP-equiv meta tags (security headers, caching, etc.) */
+    httpEquiv?: HeadHttpEquiv;
+    /** Arbitrary meta tags: [{ name, content }] or [{ property, content }] */
+    meta?: Array<{
+        name?: string;
+        property?: string;
+        content: string;
+    }>;
+}
+/**
+ * Sets document head meta tags. Tags are applied when the component
+ * mounts and removed when it unmounts, preventing stale meta from
+ * persisting across route changes.
+ *
+ * ```typescript
+ * useHead({
+ *   title: 'My Page',
+ *   description: 'Page description for SEO',
+ *   keywords: 'specifyjs, framework, spa',
+ *   author: 'Your Name',
+ *   og: { title: 'My Page', image: '/og-image.png' },
+ * });
+ * ```
+ */
+export declare function useHead(head: HeadMeta): void;

package/dist/types/core/src/index.d.ts

@@ -0,0 +1,23 @@
+export { createElement, createElement as h, createFactory } from './core/create-element';
+export { Fragment } from './core/fragment';
+export { createContext } from './context/create-context';
+export { createRef } from './core/create-ref';
+export { forwardRef } from './core/forward-ref';
+export { memo } from './core/memo';
+export { lazy } from './core/lazy';
+export { isValidElement } from './core/is-valid-element';
+export { cloneElement } from './core/clone-element';
+export { Children } from './core/children';
+export { Component, PureComponent } from './components/component';
+export { ErrorBoundary } from './components/error-boundary';
+export { useState, useEffect, useContext, useReducer, useCallback, useMemo, useRef, useImperativeHandle, useLayoutEffect, useDebugValue, useId, useDeferredValue, useTransition, useSyncExternalStore, useInsertionEffect, useHead, } from './hooks/index';
+export { Suspense } from './components/suspense';
+export { StrictMode } from './components/strict-mode';
+export { Profiler } from './components/profiler';
+export { Router, Route, Link, useRouter, useParams, useNavigate, matchPath } from './router/index';
+export { startTransition } from './core/transitions';
+export { act } from './shared/act';
+export { secureFetch, assertSecureUrl } from './shared/secure-fetch';
+export { resolveComponentId, getComponentTypeTable, setComponentIdsEnabled, } from './shared/component-registry';
+export { FeatureFlagProvider, FeatureGate, useFeatureFlags } from './features/index';
+export type { SpecElement, SpecNode, SpecChild, Props, Key, Ref, RefObject, RefCallback, FunctionComponent, ClassComponentConstructor, ClassComponentInstance, SpecContext, ErrorInfo, Fiber, } from './shared/types';

package/dist/types/core/src/jsx-dev-runtime.d.ts

@@ -0,0 +1 @@
+export { jsx as jsxDEV, Fragment } from './jsx-runtime';

package/dist/types/core/src/jsx-runtime.d.ts

@@ -0,0 +1,7 @@
+import { Fragment } from './core/fragment';
+import type { Props, Key, ComponentType, SpecElement } from './shared/types';
+export { Fragment };
+export declare function jsx<P extends Props>(type: ComponentType<P>, config: P & {
+    key?: Key;
+}, maybeKey?: Key): SpecElement<P>;
+export { jsx as jsxs };

package/dist/types/core/src/router/index.d.ts

@@ -0,0 +1,12 @@
+export { Router } from './router-component';
+export { Route } from './route-component';
+export { Link } from './link-component';
+export { useRouter } from './use-router';
+export { useParams } from './use-params';
+export { useNavigate } from './use-navigate';
+export { matchPath } from './match-path';
+export type { MatchResult, MatchOptions } from './match-path';
+export type { RouterContextValue } from './router-context';
+export type { RouterProps } from './router-component';
+export type { RouteProps } from './route-component';
+export type { LinkProps } from './link-component';