@asymmetric-effort/specifyjs 0.2.97 → 0.2.100

package/dist/types/core/src/client/protobuf.d.ts

@@ -0,0 +1,39 @@
+export type FieldType = 'int32' | 'uint32' | 'string' | 'bool' | 'bytes' | 'float64' | 'enum';
+export interface FieldDescriptor {
+    tag: number;
+    type: FieldType;
+    repeated?: boolean;
+}
+export type FieldMap = Record<string, FieldDescriptor>;
+export interface MessageType<T> {
+    name: string;
+    fields: FieldMap;
+    encode(obj: T): Uint8Array;
+    decode(bytes: Uint8Array): T;
+}
+export interface GrpcWebClientConfig {
+    baseURL: string;
+    headers?: Record<string, string>;
+}
+export interface GrpcWebClient {
+    unary<Req, Res>(service: string, method: string, reqType: MessageType<Req>, resType: MessageType<Res>, request: Req): Promise<Res>;
+}
+export interface UseProtoResult<T> {
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+/** Encode an unsigned 32-bit integer as a varint into an array of bytes. */
+export declare function encodeVarint(value: number): number[];
+/** Decode a varint from a Uint8Array starting at `offset`. Returns [value, newOffset]. */
+export declare function decodeVarint(bytes: Uint8Array, offset: number): [number, number];
+export declare function defineMessage<T>(name: string, fields: FieldMap): MessageType<T>;
+/** Encode a message into a gRPC-Web frame: [flags:1][length:4][data:N] */
+export declare function encodeGrpcWebFrame(data: Uint8Array, flags?: number): Uint8Array;
+/** Decode the first gRPC-Web frame from bytes. Returns [flags, data, bytesConsumed]. */
+export declare function decodeGrpcWebFrame(bytes: Uint8Array): [number, Uint8Array, number];
+export declare function createGrpcWebClient(config: GrpcWebClientConfig): GrpcWebClient;
+export declare function useProto<Req, Res>(client: GrpcWebClient, service: string, method: string, reqType: MessageType<Req>, resType: MessageType<Res>, request: Req, opts?: {
+    enabled?: boolean;
+}): UseProtoResult<Res>;

package/dist/types/core/src/client/rest.d.ts

@@ -0,0 +1,60 @@
+export interface RestClientConfig {
+    baseURL: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    interceptors?: {
+        request?: RequestInterceptor[];
+        response?: ResponseInterceptor[];
+        error?: ErrorInterceptor[];
+    };
+}
+export interface RequestConfig {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: unknown;
+    signal?: AbortSignal;
+    timeout?: number;
+}
+export interface RestResponse<T> {
+    data: T;
+    status: number;
+    headers: Record<string, string>;
+    ok: boolean;
+}
+export type RequestInterceptor = (config: RequestConfig) => RequestConfig | Promise<RequestConfig>;
+export type ResponseInterceptor = (response: RestResponse<unknown>) => RestResponse<unknown>;
+export type ErrorInterceptor = (error: RestError) => RestError | Promise<RestError>;
+export interface RequestOptions {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    timeout?: number;
+}
+export interface RestClient {
+    get<T>(path: string, opts?: RequestOptions): Promise<RestResponse<T>>;
+    post<T>(path: string, body?: unknown, opts?: RequestOptions): Promise<RestResponse<T>>;
+    put<T>(path: string, body?: unknown, opts?: RequestOptions): Promise<RestResponse<T>>;
+    patch<T>(path: string, body?: unknown, opts?: RequestOptions): Promise<RestResponse<T>>;
+    delete<T>(path: string, opts?: RequestOptions): Promise<RestResponse<T>>;
+}
+export declare class RestError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly data: unknown;
+    readonly config: RequestConfig;
+    constructor(message: string, status: number, statusText: string, data: unknown, config: RequestConfig);
+}
+export declare function createRestClient(config: RestClientConfig): RestClient;
+export interface UseRestOptions {
+    method?: string;
+    body?: unknown;
+    deps?: readonly unknown[];
+    enabled?: boolean;
+}
+export interface UseRestResult<T> {
+    data: T | null;
+    loading: boolean;
+    error: RestError | null;
+    refetch: () => void;
+}
+export declare function useRest<T>(client: RestClient, path: string, opts?: UseRestOptions): UseRestResult<T>;

package/dist/types/core/src/components/component.d.ts

@@ -0,0 +1,38 @@
+import type { Props, SpecNode, ErrorInfo } from '../shared/types';
+/**
+ * Base class for class components.
+ * Equivalent to React.Component.
+ */
+export declare class Component<P extends Props = Props, S = unknown> {
+    static contextType?: unknown;
+    static getDerivedStateFromProps?(_props: Props, _state: unknown): Partial<unknown> | null;
+    static getDerivedStateFromError?(_error: unknown): Partial<unknown> | null;
+    props: P;
+    state: S;
+    context: unknown;
+    _fiber: unknown;
+    _pendingState: Array<Partial<S> | ((prevState: S, props: P) => Partial<S> | null)>;
+    _forceUpdate: boolean;
+    constructor(props: P);
+    setState(updater: Partial<S> | ((prevState: S, props: P) => Partial<S> | null), callback?: () => void): void;
+    forceUpdate(callback?: () => void): void;
+    render(): SpecNode;
+    componentDidMount?(): void;
+    componentDidUpdate?(_prevProps: P, _prevState: S, _snapshot?: unknown): void;
+    componentWillUnmount?(): void;
+    shouldComponentUpdate?(_nextProps: P, _nextState: S): boolean;
+    getSnapshotBeforeUpdate?(_prevProps: P, _prevState: S): unknown;
+    componentDidCatch?(_error: unknown, _info: ErrorInfo): void;
+    _enqueueUpdate(_callback?: () => void): void;
+}
+/**
+ * PureComponent implements shouldComponentUpdate with shallow prop/state comparison.
+ * Equivalent to React.PureComponent.
+ */
+export declare class PureComponent<P extends Props = Props, S = unknown> extends Component<P, S> {
+    shouldComponentUpdate(nextProps: P, nextState: S): boolean;
+}
+/**
+ * Shallow comparison of two objects.
+ */
+export declare function shallowEqual(a: unknown, b: unknown): boolean;

package/dist/types/core/src/components/error-boundary.d.ts

@@ -0,0 +1,22 @@
+import type { Props, SpecNode, ErrorInfo } from '../shared/types';
+import { Component } from './component';
+export interface ErrorBoundaryProps extends Props {
+    fallback?: SpecNode;
+    onError?: (error: unknown, info: ErrorInfo) => void;
+    children?: SpecNode;
+}
+export interface ErrorBoundaryState {
+    hasError: boolean;
+    error: unknown;
+}
+/**
+ * A built-in error boundary component.
+ * Users can also create their own by implementing componentDidCatch
+ * and getDerivedStateFromError on a class component.
+ */
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    static getDerivedStateFromError(error: unknown): Partial<ErrorBoundaryState>;
+    constructor(props: ErrorBoundaryProps);
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): SpecNode;
+}

package/dist/types/core/src/components/profiler.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Profiler measures rendering performance of its subtree.
+ * Equivalent to React.Profiler.
+ */
+export declare const Profiler: symbol;

package/dist/types/core/src/components/strict-mode.d.ts

@@ -0,0 +1,5 @@
+/**
+ * StrictMode enables additional development checks.
+ * Equivalent to React.StrictMode.
+ */
+export declare const StrictMode: symbol;

package/dist/types/core/src/components/suspense.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Suspense component for handling async loading states.
+ * Equivalent to React.Suspense.
+ */
+export declare const Suspense: symbol;

package/dist/types/core/src/components-barrel.d.ts

@@ -0,0 +1,100 @@
+/**
+ * SpecifyJS Component Library — all 62 components re-exported.
+ * Import via: import { Toggle, DataGrid, Modal } from "specifyjs/components"
+ */
+export * from '../../components/data/analog-clock/src/index';
+export * from '../../components/data/avatar/src/index';
+export * from '../../components/data/badge/src/index';
+export * from '../../components/data/data-grid/src/index';
+export * from '../../components/data/digital-clock/src/index';
+export * from '../../components/data/list-view/src/index';
+export * from '../../components/data/tag/src/index';
+export * from '../../components/data/virtual-scroll/src/index';
+export * from '../../components/feedback/alert/src/index';
+export * from '../../components/feedback/empty-state/src/index';
+export * from '../../components/feedback/progress-bar/src/index';
+export * from '../../components/feedback/skeleton/src/index';
+export * from '../../components/feedback/spinner/src/index';
+export * from '../../components/form/checkbox/src/index';
+export * from '../../components/form/color-picker/src/index';
+export * from '../../components/form/color-wheel/src/index';
+export * from '../../components/form/datepicker/src/index';
+export * from '../../components/form/file-upload/src/index';
+export * from '../../components/form/multiline/src/index';
+export * from '../../components/form/number-spinner/src/index';
+export * from '../../components/form/radio/src/index';
+export * from '../../components/form/select/src/index';
+export * from '../../components/form/slider/src/index';
+export * from '../../components/form/texteditor/src/index';
+export * from '../../components/form/textfield/src/index';
+export * from '../../components/form/timepicker/src/index';
+export * from '../../components/form/toggle/src/index';
+export * from '../../components/form/wrapper/src/index';
+export * from '../../components/layout/card/src/index';
+export * from '../../components/layout/flex-container/src/index';
+export * from '../../components/layout/grid/src/index';
+export * from '../../components/layout/panel/src/index';
+export * from '../../components/layout/scroll-container/src/index';
+export * from '../../components/layout/splitter/src/index';
+export * from '../../components/layout/tabs/src/index';
+export * from '../../components/media/carousel/src/index';
+export * from '../../components/media/image/src/index';
+export * from '../../components/media/video-player/src/index';
+export * from '../../components/nav/accordion/src/index';
+export * from '../../components/nav/breadcrumb/src/index';
+export * from '../../components/nav/dropdown/src/index';
+export * from '../../components/nav/menubar/src/index';
+export * from '../../components/nav/pagination/src/index';
+export * from '../../components/nav/sidebar/src/index';
+export * from '../../components/nav/stepper/src/index';
+export * from '../../components/nav/toolbar/src/index';
+export * from '../../components/nav/treenav/src/index';
+export * from '../../components/nav/wrapper/src/index';
+export * from '../../components/overlay/context-menu/src/index';
+export * from '../../components/overlay/drawer/src/index';
+export * from '../../components/overlay/modal/src/index';
+export * from '../../components/overlay/popover/src/index';
+export * from '../../components/overlay/toast/src/index';
+export * from '../../components/overlay/tooltip/src/index';
+export * from '../../components/viz/2D-bar-graph/src/index';
+export * from '../../components/viz/2D-cartesian-raw/src/index';
+export * from '../../components/viz/2D-complex-graph/src/index';
+export * from '../../components/viz/2D-line-graph/src/index';
+export * from '../../components/viz/2D-pie-graph/src/index';
+export * from '../../components/viz/2D-polar-graph/src/index';
+export * from '../../components/viz/graph/src/index';
+export * from '../../components/viz/wrapper/src/index';
+export * from '../../components/analytics/google-analytics/src/index';
+export * from '../../components/layout/footer/src/index';
+export * from '../../components/page/unity-desktop/src/index';
+export * from '../../components/page/word-processor/src/index';
+export * from '../../components/page/ide/src/index';
+export * from '../../components/page/trading-dashboard/src/index';
+export * from '../../components/form/button/src/index';
+export * from '../../components/viz/3d-layers/src/index';
+export * from '../../components/viz/big-number/src/index';
+export * from '../../components/viz/bloch-sphere/src/index';
+export * from '../../components/viz/box-plot/src/index';
+export * from '../../components/viz/bubble-chart/src/index';
+export * from '../../components/viz/calendar-heat-map/src/index';
+export * from '../../components/viz/chord/src/index';
+export * from '../../components/viz/decomposition-tree/src/index';
+export * from '../../components/viz/force-graph/src/index';
+export * from '../../components/viz/funnel/src/index';
+export * from '../../components/viz/gantt-chart/src/index';
+export * from '../../components/viz/gauge/src/index';
+export * from '../../components/viz/us-state-map/src/index';
+export * from '../../components/viz/heat-map/src/index';
+export * from '../../components/viz/histogram/src/index';
+export * from '../../components/viz/lollipop/src/index';
+export * from '../../components/viz/matrix/src/index';
+export * from '../../components/viz/partition/src/index';
+export * from '../../components/viz/pivot-table/src/index';
+export * from '../../components/viz/radar-chart/src/index';
+export * from '../../components/viz/sankey/src/index';
+export * from '../../components/viz/sunburst/src/index';
+export * from '../../components/viz/tree-map/src/index';
+export * from '../../components/viz/vector-field/src/index';
+export * from '../../components/viz/waterfall/src/index';
+export * from '../../components/viz/word-cloud/src/index';
+export * from '../../components/viz/2D-discrete-cartesian/src/index';

package/dist/types/core/src/compute/context.d.ts

@@ -0,0 +1,19 @@
+import type { ComputeContext } from './types';
+/**
+ * Force a specific backend for all subsequent {@link createComputeContext}
+ * calls.
+ *
+ * Passing a new value clears the cached backend so the next
+ * {@link createComputeContext} call will create a fresh instance.
+ *
+ * @param name - Backend to use ('webgpu', 'webgl', or 'cpu').
+ */
+export declare function setComputeBackend(name: 'webgpu' | 'webgl' | 'cpu'): void;
+/**
+ * Create (or return the cached) {@link ComputeContext}.
+ *
+ * Auto-detection order: WebGPU -> WebGL -> CPU.
+ * The first backend that reports {@link ComputeBackend.isAvailable | isAvailable()}
+ * is initialised and cached for the lifetime of the page.
+ */
+export declare function createComputeContext(): Promise<ComputeContext>;

package/dist/types/core/src/compute/cpu-backend.d.ts

@@ -0,0 +1,14 @@
+import type { BackendInfo, ComputeBackend, KernelName, KernelParams, KernelResult } from './types';
+/** Pure TypeScript CPU backend — the universal fallback. */
+export declare class CpuBackend implements ComputeBackend {
+    /** @inheritdoc */
+    readonly info: BackendInfo;
+    /** CPU backend is always available. */
+    isAvailable(): boolean;
+    /** No initialisation required for the CPU backend. */
+    init(): Promise<void>;
+    /** Execute the named kernel synchronously on the CPU. */
+    execute(kernel: KernelName, params: KernelParams): Promise<KernelResult>;
+    /** No resources to release on the CPU backend. */
+    dispose(): void;
+}

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

@@ -0,0 +1,2 @@
+export { createComputeContext, setComputeBackend } from './context';
+export type { KernelName, ComputeBuffer, KernelParams, KernelResult, BackendInfo, ComputeBackend, ComputeContext, } from './types';

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

@@ -0,0 +1,56 @@
+/** Named compute kernel identifier. */
+export type KernelName = 'matrix-multiply' | 'verlet-constraints' | 'n-body' | 'particle-system';
+/** Buffer of numeric data for GPU transfer. */
+export interface ComputeBuffer {
+    /** Identifier for this buffer within a kernel invocation. */
+    name: string;
+    /** Typed array holding the numeric payload. */
+    data: Float64Array | Float32Array;
+    /** 'read' = input only, 'write' = output only, 'readwrite' = both. */
+    usage: 'read' | 'write' | 'readwrite';
+}
+/** Parameters for a kernel execution. */
+export interface KernelParams {
+    /** Data buffers consumed and/or produced by the kernel. */
+    buffers: ComputeBuffer[];
+    /** Scalar uniform values keyed by name. */
+    uniforms?: Record<string, number>;
+    /** Optional workgroup size hint (GPU backends). */
+    workgroupSize?: number;
+}
+/** Result of a kernel execution. */
+export interface KernelResult {
+    /** Output buffers keyed by buffer name. */
+    buffers: Map<string, Float64Array | Float32Array>;
+}
+/** Backend capabilities descriptor. */
+export interface BackendInfo {
+    /** Backend identifier. */
+    name: 'webgpu' | 'webgl' | 'cpu';
+    /** Whether this backend uses a hardware GPU. */
+    isGPU: boolean;
+    /** Maximum buffer size in bytes. */
+    maxBufferSize: number;
+}
+/** Compute backend interface — implemented by each backend. */
+export interface ComputeBackend {
+    /** Descriptor for this backend's capabilities. */
+    readonly info: BackendInfo;
+    /** Returns true when this backend can be used in the current environment. */
+    isAvailable(): boolean;
+    /** Perform any async initialisation (e.g. request GPU device). */
+    init(): Promise<void>;
+    /** Execute the named kernel with the given parameters. */
+    execute(kernel: KernelName, params: KernelParams): Promise<KernelResult>;
+    /** Release GPU resources held by this backend. */
+    dispose(): void;
+}
+/** Public compute context — the developer-facing API. */
+export interface ComputeContext {
+    /** Execute a named compute kernel. */
+    execute(kernel: KernelName, params: KernelParams): Promise<KernelResult>;
+    /** Return information about the active backend. */
+    getBackendInfo(): BackendInfo;
+    /** Release all resources. */
+    dispose(): void;
+}

package/dist/types/core/src/compute/webgl-backend.d.ts

@@ -0,0 +1,32 @@
+import type { BackendInfo, ComputeBackend, KernelName, KernelParams, KernelResult } from './types';
+/**
+ * WebGL compute backend.
+ *
+ * Currently delegates all computation to the CPU backend. The texture-based
+ * compute pipeline described above will be implemented in a future release
+ * once the kernel registry stabilises.
+ */
+export declare class WebGlBackend implements ComputeBackend {
+    /** @inheritdoc */
+    readonly info: BackendInfo;
+    /** CPU fallback used for all kernel execution at this stage. */
+    private readonly _cpu;
+    /**
+     * Returns true when a WebGL rendering context can be created.
+     *
+     * Checks for WebGL2 first (required for float texture support without
+     * extensions), then falls back to WebGL1.
+     */
+    isAvailable(): boolean;
+    /** No async initialisation needed while delegating to CPU. */
+    init(): Promise<void>;
+    /**
+     * Execute the kernel.
+     *
+     * Delegates to the CPU backend until the texture-based compute pipeline
+     * is implemented.
+     */
+    execute(kernel: KernelName, params: KernelParams): Promise<KernelResult>;
+    /** Release any GL resources (none held at this stage). */
+    dispose(): void;
+}

package/dist/types/core/src/compute/webgpu-backend.d.ts

@@ -0,0 +1,49 @@
+import type { BackendInfo, ComputeBackend, KernelName, KernelParams, KernelResult } from './types';
+/**
+ * WebGPU compute backend.
+ *
+ * When a real GPU device is available the backend compiles WGSL shaders and
+ * dispatches compute workgroups. If the device cannot be obtained the backend
+ * reports itself as unavailable during {@link init}.
+ *
+ * Shader execution paths are marked with `v8 ignore` because they require a
+ * live GPU device which is not present in jsdom/unit-test environments.
+ */
+export declare class WebGpuBackend implements ComputeBackend {
+    /** @inheritdoc */
+    readonly info: BackendInfo;
+    /** GPU device handle — populated by {@link init}. */
+    private _device;
+    /** CPU fallback used when GPU dispatch is not yet possible. */
+    private readonly _cpuFallback;
+    /** Reference to the WGSL shader source for matrix-multiply. */
+    private readonly _matrixMultiplyWgsl;
+    /**
+     * Returns true when the WebGPU API is exposed by the runtime.
+     * This does not guarantee that a usable adapter exists — call {@link init}
+     * to confirm device availability.
+     */
+    isAvailable(): boolean;
+    /**
+     * Request a GPU adapter and device. If neither can be obtained the backend
+     * silently degrades; subsequent {@link execute} calls will throw.
+     */
+    init(): Promise<void>;
+    /**
+     * Execute the named kernel on the GPU.
+     *
+     * If no device is available an error is thrown — callers should check
+     * {@link isAvailable} or use the auto-detection in
+     * {@link createComputeContext}.
+     */
+    execute(kernel: KernelName, params: KernelParams): Promise<KernelResult>;
+    /**
+     * Internal dispatch — compiles the appropriate WGSL shader and runs the
+     * compute pipeline for the given kernel.
+     */
+    private _dispatchKernel;
+    /** Return the WGSL source for a kernel, or null if not yet implemented. */
+    private _getShaderSource;
+    /** Release the GPU device and associated resources. */
+    dispose(): void;
+}

package/dist/types/core/src/context/create-context.d.ts

@@ -0,0 +1,14 @@
+import { SPEC_PROVIDER_TYPE, SPEC_CONSUMER_TYPE, type SpecContext } from '../shared/types';
+export interface ContextProvider<T> {
+    $$typeof: typeof SPEC_PROVIDER_TYPE;
+    _context: SpecContext<T>;
+}
+export interface ContextConsumer<T> {
+    $$typeof: typeof SPEC_CONSUMER_TYPE;
+    _context: SpecContext<T>;
+}
+/**
+ * Creates a context object with Provider and Consumer.
+ * Equivalent to React.createContext.
+ */
+export declare function createContext<T>(defaultValue: T): SpecContext<T>;

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

@@ -0,0 +1,14 @@
+import type { SpecNode, SpecChild, SpecElement } from '../shared/types';
+declare function mapChildren(children: SpecNode, fn: (child: SpecChild, index: number) => SpecChild): SpecChild[];
+declare function forEachChildren(children: SpecNode, fn: (child: SpecChild, index: number) => void): void;
+declare function countChildren(children: SpecNode): number;
+declare function onlyChild(children: SpecNode): SpecElement;
+declare function toArray(children: SpecNode): SpecChild[];
+export declare const Children: {
+    map: typeof mapChildren;
+    forEach: typeof forEachChildren;
+    count: typeof countChildren;
+    only: typeof onlyChild;
+    toArray: typeof toArray;
+};
+export {};

package/dist/types/core/src/core/clone-element.d.ts

@@ -0,0 +1,9 @@
+import { type SpecElement, type Props, type Key, type Ref } from '../shared/types';
+/**
+ * Clones a SpecifyJS element with new props merged in.
+ * Equivalent to React.cloneElement.
+ */
+export declare function cloneElement<P extends Props>(element: SpecElement<P>, config?: Partial<P> & {
+    key?: Key;
+    ref?: Ref;
+}, ...children: unknown[]): SpecElement<P>;

package/dist/types/core/src/core/create-element.d.ts

@@ -0,0 +1,19 @@
+import { type SpecElement, type ComponentType, type Props, type Key, type Ref } from '../shared/types';
+/**
+ * Creates a SpecifyJS element (virtual DOM node).
+ * Equivalent to React.createElement.
+ */
+export declare function createElement<P extends Props>(type: ComponentType<P>, config: (Omit<P, 'children'> & {
+    key?: Key;
+    ref?: Ref;
+}) | null, ...children: unknown[]): SpecElement<P>;
+/**
+ * Creates a factory function for producing elements of a given type.
+ * Legacy API — equivalent to React.createFactory.
+ *
+ * @deprecated Use createElement directly or JSX instead.
+ */
+export declare function createFactory<P extends Props>(type: ComponentType<P>): (config?: (Omit<P, 'children'> & {
+    key?: Key;
+    ref?: Ref;
+}) | null, ...children: unknown[]) => SpecElement<P>;

package/dist/types/core/src/core/create-ref.d.ts

@@ -0,0 +1,6 @@
+import type { RefObject } from '../shared/types';
+/**
+ * Creates a ref object with a mutable .current property.
+ * Equivalent to React.createRef.
+ */
+export declare function createRef<T = unknown>(): RefObject<T>;

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

@@ -0,0 +1,29 @@
+import { type Fiber, type Props, type ComponentType, type Key, type Ref, type SpecElement, type SpecNode, FiberTag } from '../shared/types';
+/**
+ * Determines the fiber tag for a given element type.
+ */
+export declare function getFiberTag(type: ComponentType): FiberTag;
+/**
+ * Creates a new fiber from a SpecifyJS element.
+ */
+export declare function createFiberFromElement(element: SpecElement, lanes?: number): Fiber;
+/**
+ * Creates a fiber for a text node.
+ */
+export declare function createFiberFromText(content: string | number, lanes?: number): Fiber;
+/**
+ * Creates the root fiber for a container.
+ */
+export declare function createHostRootFiber(): Fiber;
+/**
+ * Core fiber constructor.
+ */
+export declare function createFiber(tag: FiberTag, type: ComponentType | null, key: Key, ref: Ref, pendingProps: Props, lanes: number): Fiber;
+/**
+ * Creates a working-in-progress clone of an existing fiber.
+ */
+export declare function createWorkInProgress(current: Fiber, pendingProps: Props): Fiber;
+/**
+ * Converts SpecNode children into fiber-compatible form.
+ */
+export declare function coerceToFiberChildren(children: SpecNode): Array<SpecElement | string | number>;

package/dist/types/core/src/core/forward-ref.d.ts

@@ -0,0 +1,15 @@
+import { SPEC_FORWARD_REF_TYPE, type Props, type Ref, type SpecNode } from '../shared/types';
+export interface ForwardRefRenderFunction<T, P extends Props = Props> {
+    (props: P, ref: Ref<T>): SpecNode;
+    displayName?: string;
+}
+export interface ForwardRefComponent<T, P extends Props = Props> {
+    $$typeof: typeof SPEC_FORWARD_REF_TYPE;
+    render: ForwardRefRenderFunction<T, P>;
+    displayName?: string;
+}
+/**
+ * Forwards a ref through a component to a child.
+ * Equivalent to React.forwardRef.
+ */
+export declare function forwardRef<T, P extends Props = Props>(render: ForwardRefRenderFunction<T, P>): ForwardRefComponent<T, P>;

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

@@ -0,0 +1,5 @@
+/**
+ * Fragment allows grouping children without adding extra DOM nodes.
+ * Usage: <Fragment>...</Fragment> or <>...</>
+ */
+export declare const Fragment: symbol;

package/dist/types/core/src/core/is-valid-element.d.ts

@@ -0,0 +1,6 @@
+import { type SpecElement } from '../shared/types';
+/**
+ * Checks if a value is a valid SpecifyJS element.
+ * Equivalent to React.isValidElement.
+ */
+export declare function isValidElement(object: unknown): object is SpecElement;

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

@@ -0,0 +1,46 @@
+/**
+ * Lane-based priority system for concurrent rendering.
+ *
+ * Lanes are bitmask values representing priority levels. Lower bits = higher
+ * priority. Multiple lanes can be active simultaneously. The scheduler uses
+ * lanes to determine which work to process first and whether to interrupt
+ * lower-priority work for higher-priority updates.
+ */
+export declare const NoLane = 0;
+export declare const NoLanes = 0;
+/** Synchronous, blocking — used by flushSync */
+export declare const SyncLane = 1;
+/** Continuous user input — drag, scroll, hover */
+export declare const InputContinuousLane = 2;
+/** Default priority — normal state updates */
+export declare const DefaultLane = 4;
+/** First transition lane — startTransition */
+export declare const TransitionLane1 = 8;
+/** Second transition lane — concurrent transitions */
+export declare const TransitionLane2 = 16;
+/** Retry lane — Suspense retries */
+export declare const RetryLane = 32;
+/** Idle priority — offscreen/low-priority work */
+export declare const IdleLane = 64;
+/** Offscreen rendering (future) */
+export declare const OffscreenLane = 128;
+/** All non-idle lanes */
+export declare const NonIdleLanes: number;
+/** Combine two lane sets. */
+export declare function mergeLanes(a: number, b: number): number;
+/** Check if `subset` is entirely contained within `set`. */
+export declare function isSubsetOfLanes(set: number, subset: number): boolean;
+/** Check if `a` and `b` share any lanes. */
+export declare function includesSomeLane(a: number, b: number): boolean;
+/** Remove `subset` lanes from `set`. */
+export declare function removeLanes(set: number, subset: number): number;
+/**
+ * Isolate the highest-priority (lowest-bit) lane from a lane set.
+ * Uses the two's complement trick: `lanes & -lanes` isolates the rightmost set bit.
+ */
+export declare function getHighestPriorityLane(lanes: number): number;
+/** Check if a lane set is empty. */
+export declare function isEmpty(lanes: number): boolean;
+/** Timeout in ms before a pending lane is promoted to SyncLane. -1 = never. */
+export declare function laneExpirationMs(lane: number): number;
+export declare function claimNextTransitionLane(): number;