@synnaxlabs/pluto 0.12.0

package/dist/vis/pid/Symbols.d.ts

@@ -0,0 +1,205 @@
+import { type ReactElement } from "react";
+import { type xy, location, type UnknownRecord } from "@synnaxlabs/x";
+import { Align } from '../../align';
+import { type Color } from '../../color';
+import { Control } from '../../telem/control';
+import { Button as CoreButton } from '../../vis/button';
+import { type LabelExtensionProps } from '../../vis/pid/Labeled';
+import { Primitives } from '../../vis/pid/primitives';
+import { Toggle } from '../../vis/toggle';
+import { Value as CoreValue } from '../../vis/value';
+export interface ControlStateProps extends Omit<Align.SpaceProps, "direction"> {
+    showChip?: boolean;
+    showIndicator?: boolean;
+    chip?: Control.ChipProps;
+    indicator?: Control.IndicatorProps;
+    orientation?: location.Outer;
+}
+export declare const ControlState: ({ showChip, showIndicator, indicator, orientation, chip, children, ...props }: ControlStateProps) => ReactElement;
+export type SymbolProps<P extends object = UnknownRecord> = P & {
+    symbolKey: string;
+    position: xy.XY;
+    selected: boolean;
+    onChange: (value: P) => void;
+};
+export interface ThreeWayValveProps extends Primitives.ThreeWayValveProps, Omit<Toggle.UseProps, "aetherKey"> {
+    label?: LabelExtensionProps;
+    control?: ControlStateProps;
+}
+export declare const ThreeWayValve: import("react").FC<ThreeWayValveProps & {
+    symbolKey: string;
+    position: xy.XY;
+    selected: boolean;
+    onChange: (value: ThreeWayValveProps) => void;
+} & {
+    aetherKey?: string | undefined;
+}>;
+export declare const ThreeWayValvePreview: (props: ThreeWayValveProps) => ReactElement;
+export interface ValveProps extends Primitives.ValveProps, Omit<Toggle.UseProps, "aetherKey"> {
+    label?: LabelExtensionProps;
+    control?: ControlStateProps;
+}
+export declare const Valve: import("react").FC<ValveProps & {
+    symbolKey: string;
+    position: xy.XY;
+    selected: boolean;
+    onChange: (value: ValveProps) => void;
+} & {
+    aetherKey?: string | undefined;
+}>;
+export declare const ValvePreview: (props: ValveProps) => ReactElement;
+export interface SolenoidValveProps extends Primitives.SolenoidValveProps, Omit<Toggle.UseProps, "aetherKey"> {
+    label?: LabelExtensionProps;
+    control?: ControlStateProps;
+}
+export declare const SolenoidValve: import("react").FC<SolenoidValveProps & {
+    symbolKey: string;
+    position: xy.XY;
+    selected: boolean;
+    onChange: (value: SolenoidValveProps) => void;
+} & {
+    aetherKey?: string | undefined;
+}>;
+export declare const SolenoidValvePreview: (props: SolenoidValveProps) => ReactElement;
+export interface FourWayValveProps extends Primitives.FourWayValveProps, Omit<Toggle.UseProps, "aetherKey"> {
+    label?: LabelExtensionProps;
+    control?: ControlStateProps;
+}
+export declare const FourWayValve: import("react").FC<FourWayValveProps & {
+    symbolKey: string;
+    position: xy.XY;
+    selected: boolean;
+    onChange: (value: FourWayValveProps) => void;
+} & {
+    aetherKey?: string | undefined;
+}>;
+export declare const FourWayValvePreview: (props: FourWayValveProps) => ReactElement;
+export interface AngledValveProps extends Primitives.AngledValveProps, Omit<Toggle.UseProps, "aetherKey"> {
+    label?: LabelExtensionProps;
+    control?: ControlStateProps;
+}
+export declare const AngledValve: import("react").FC<AngledValveProps & {
+    symbolKey: string;
+    position: xy.XY;
+    selected: boolean;
+    onChange: (value: AngledValveProps) => void;
+} & {
+    aetherKey?: string | undefined;
+}>;
+export declare const AngledValvePreview: (props: AngledValveProps) => ReactElement;
+export interface PumpProps extends Primitives.PumpProps, Omit<Toggle.UseProps, "aetherKey"> {
+    label?: LabelExtensionProps;
+    control?: ControlStateProps;
+}
+export declare const Pump: import("react").FC<PumpProps & {
+    symbolKey: string;
+    position: xy.XY;
+    selected: boolean;
+    onChange: (value: PumpProps) => void;
+} & {
+    aetherKey?: string | undefined;
+}>;
+export declare const PumpPreview: (props: PumpProps) => ReactElement;
+export interface TankProps extends Primitives.TankProps {
+    label?: LabelExtensionProps;
+}
+export declare const Tank: import("react").FC<TankProps & {
+    symbolKey: string;
+    position: xy.XY;
+    selected: boolean;
+    onChange: (value: TankProps) => void;
+} & {
+    aetherKey?: string | undefined;
+}>;
+export declare const TankPreview: (props: TankProps) => ReactElement;
+export interface ReliefValveProps extends Primitives.ReliefValveProps {
+    label?: LabelExtensionProps;
+}
+export declare const ReliefValve: ({ label, onChange, orientation, color, }: SymbolProps<ReliefValveProps>) => ReactElement;
+export declare const ReliefValvePreview: (props: ReliefValveProps) => ReactElement;
+export interface RegulatorProps extends Primitives.RegulatorProps {
+    label?: LabelExtensionProps;
+}
+export declare const Regulator: ({ label, onChange, orientation, color, }: SymbolProps<RegulatorProps>) => ReactElement;
+export declare const RegulatorPreview: (props: RegulatorProps) => ReactElement;
+export interface BurstDiscProps extends Primitives.BurstDiscProps {
+    label?: LabelExtensionProps;
+}
+export declare const BurstDisc: ({ label, onChange, orientation, color, }: SymbolProps<BurstDiscProps>) => ReactElement;
+export declare const BurstDiscPreview: (props: BurstDiscProps) => ReactElement;
+export interface CapProps extends Primitives.CapProps {
+    label?: LabelExtensionProps;
+}
+export declare const Cap: ({ label, onChange, orientation, color, }: SymbolProps<CapProps>) => ReactElement;
+export declare const CapPreview: (props: CapProps) => ReactElement;
+export interface ManualValveProps extends Primitives.ManualValveProps {
+    label?: LabelExtensionProps;
+}
+export declare const ManualValve: ({ label, onChange, orientation, color, }: SymbolProps<ManualValveProps>) => ReactElement;
+export declare const ManualValvePreview: (props: ManualValveProps) => ReactElement;
+export interface FilterProps extends Primitives.FilterProps {
+    label?: LabelExtensionProps;
+}
+export declare const Filter: ({ label, onChange, orientation, color, }: SymbolProps<FilterProps>) => ReactElement;
+export declare const FilterPreview: (props: FilterProps) => ReactElement;
+export interface NeedleValveProps extends Primitives.NeedleValveProps {
+    label?: LabelExtensionProps;
+}
+export declare const NeedleValve: ({ label, onChange, orientation, color, }: SymbolProps<NeedleValveProps>) => ReactElement;
+export declare const NeedleValvePreview: (props: NeedleValveProps) => ReactElement;
+export interface CheckValveProps extends Primitives.CheckValveProps {
+    label?: LabelExtensionProps;
+}
+export declare const CheckValve: ({ label, onChange, orientation, color, }: SymbolProps<CheckValveProps>) => ReactElement;
+export declare const CheckValvePreview: (props: CheckValveProps) => ReactElement;
+export interface OrificeProps extends Primitives.OrificeProps {
+    label?: LabelExtensionProps;
+}
+export declare const Orifice: ({ label, onChange, orientation, color, }: SymbolProps<OrificeProps>) => ReactElement;
+export declare const OrificePreview: (props: OrificeProps) => ReactElement;
+export interface AngledReliefValveProps extends Primitives.AngledReliefValveProps {
+    label?: LabelExtensionProps;
+}
+export declare const AngledReliefValve: ({ label, onChange, orientation, color, }: SymbolProps<AngledReliefValveProps>) => ReactElement;
+export declare const AngledReliefValvePreview: (props: Primitives.AngledReliefValveProps) => ReactElement;
+export interface ValueProps extends Omit<CoreValue.UseProps, "box" | "aetherKey">, Primitives.ValueProps {
+    position?: xy.XY;
+    label?: LabelExtensionProps;
+    color?: Color.Crude;
+    textColor?: Color.Crude;
+}
+export declare const Value: import("react").FC<ValueProps & {
+    symbolKey: string;
+    position: xy.XY;
+    selected: boolean;
+    onChange: (value: ValueProps) => void;
+} & {
+    aetherKey?: string | undefined;
+}>;
+export declare const ValuePreview: ({ color }: ValueProps) => ReactElement;
+export interface SwitchProps extends Primitives.SwitchProps, Omit<Toggle.UseProps, "aetherKey"> {
+    label?: LabelExtensionProps;
+    control?: ControlStateProps;
+}
+export declare const Switch: import("react").FC<SwitchProps & {
+    symbolKey: string;
+    position: xy.XY;
+    selected: boolean;
+    onChange: (value: SwitchProps) => void;
+} & {
+    aetherKey?: string | undefined;
+}>;
+export declare const SwitchPreview: (props: SwitchProps) => ReactElement;
+export interface ButtonProps extends Omit<Primitives.ButtonProps, "label">, Omit<CoreButton.UseProps, "aetherKey"> {
+    label?: LabelExtensionProps;
+    control?: ControlStateProps;
+}
+export declare const Button: import("react").FC<ButtonProps & {
+    symbolKey: string;
+    position: xy.XY;
+    selected: boolean;
+    onChange: (value: ButtonProps) => void;
+} & {
+    aetherKey?: string | undefined;
+}>;
+export declare const ButtonPreview: ({ label: _, ...props }: SwitchProps) => ReactElement;

package/dist/vis/pid/index.d.ts

@@ -0,0 +1 @@
+export * as PID from '../../vis/pid/registry';

package/dist/vis/pid/primitives/Primitives.d.ts

@@ -0,0 +1,98 @@
+import { type ComponentPropsWithoutRef, type ReactElement, type PropsWithChildren } from "react";
+import { dimensions, type location, direction, xy } from "@synnaxlabs/x";
+import { Color } from '../../../color';
+export interface OrientableProps {
+    orientation?: location.Outer;
+}
+export interface SVGBasedPrimitiveProps extends OrientableProps {
+    color?: Color.Crude;
+    scale?: number;
+}
+export interface DivProps extends Omit<ComponentPropsWithoutRef<"div">, "color">, OrientableProps {
+}
+interface ToggleProps extends Omit<ComponentPropsWithoutRef<"button">, "color" | "value"> {
+    triggered?: boolean;
+    enabled?: boolean;
+    color?: Color.Crude;
+}
+export interface SmartHandlesProps extends PropsWithChildren<{}>, OrientableProps {
+}
+export interface InternalSVGProps extends SVGBasedPrimitiveProps, Omit<ComponentPropsWithoutRef<"svg">, "direction" | "color" | "orientation"> {
+    dimensions: dimensions.Dimensions;
+    color?: Color.Crude;
+    scale?: number;
+}
+export interface FourWayValveProps extends ToggleProps, SVGBasedPrimitiveProps {
+}
+export declare const FourWayValve: ({ className, orientation, scale, color, ...props }: FourWayValveProps) => ReactElement;
+export interface ThreeWayValveProps extends ToggleProps, SVGBasedPrimitiveProps {
+}
+export declare const ThreeWayValve: ({ color, orientation, scale, ...props }: ThreeWayValveProps) => ReactElement;
+export interface ValveProps extends ToggleProps, SVGBasedPrimitiveProps {
+}
+export declare const Valve: ({ orientation, color, scale, ...props }: ValveProps) => ReactElement;
+export interface SolenoidValveProps extends ToggleProps, SVGBasedPrimitiveProps {
+    normallyOpen?: boolean;
+}
+export declare const SolenoidValve: ({ className, color, orientation, normallyOpen, scale, ...props }: SolenoidValveProps) => ReactElement;
+export interface ReliefValveProps extends DivProps, SVGBasedPrimitiveProps {
+}
+export declare const ReliefValve: ({ className, orientation, color, scale, ...props }: ReliefValveProps) => ReactElement;
+export interface CheckValveProps extends DivProps, SVGBasedPrimitiveProps {
+}
+export declare const CheckValve: ({ className, orientation, color, scale, ...props }: CheckValveProps) => ReactElement;
+export interface AngledValveProps extends ToggleProps, SVGBasedPrimitiveProps {
+}
+export declare const AngledValve: ({ color, className, orientation, scale, ...props }: AngledValveProps) => ReactElement;
+export declare const Tag: () => ReactElement;
+export interface ReduceFittingProps extends DivProps, SVGBasedPrimitiveProps {
+}
+export declare const ReduceFitting: ({ className, orientation, color, scale, ...props }: ReduceFittingProps) => ReactElement;
+export interface PumpProps extends ToggleProps, SVGBasedPrimitiveProps {
+}
+export declare const Pump: ({ color, className, orientation, scale, ...props }: PumpProps) => ReactElement;
+export interface BurstDiscProps extends DivProps, SVGBasedPrimitiveProps {
+}
+export declare const BurstDisc: ({ className, color, orientation, scale, ...props }: BurstDiscProps) => ReactElement;
+export interface CapProps extends SVGBasedPrimitiveProps, DivProps {
+}
+export declare const Cap: ({ className, orientation, color, scale, ...props }: CapProps) => ReactElement;
+export interface ManualValveProps extends SVGBasedPrimitiveProps, DivProps {
+}
+export declare const ManualValve: ({ className, orientation, color, scale, ...props }: ManualValveProps) => ReactElement;
+export interface FilterProps extends SVGBasedPrimitiveProps, DivProps {
+}
+export declare const Filter: ({ className, orientation, color, scale, ...props }: FilterProps) => ReactElement;
+type DetailedBorderRadius = Record<location.CornerXYString, xy.XY>;
+type BorderRadius = number | Record<direction.Direction, number> | Record<location.CornerXYString, number> | DetailedBorderRadius;
+export interface TankProps extends DivProps {
+    dimensions?: dimensions.Dimensions;
+    borderRadius?: BorderRadius;
+    color?: Color.Crude;
+}
+export declare const Tank: ({ className, dimensions, borderRadius, color, ...props }: TankProps) => ReactElement;
+export interface RegulatorProps extends DivProps, SVGBasedPrimitiveProps {
+}
+export declare const Regulator: ({ className, orientation, color, scale, ...props }: RegulatorProps) => ReactElement;
+export interface OrificeProps extends DivProps, SVGBasedPrimitiveProps {
+}
+export declare const Orifice: ({ className, orientation, scale, color, ...props }: OrificeProps) => ReactElement;
+export interface NeedleValveProps extends DivProps, SVGBasedPrimitiveProps {
+}
+export declare const NeedleValve: ({ className, orientation, color, scale, ...props }: NeedleValveProps) => ReactElement;
+export interface AngledReliefValveProps extends DivProps, SVGBasedPrimitiveProps {
+}
+export declare const AngledReliefValve: ({ className, orientation, color, scale, ...props }: AngledReliefValveProps) => ReactElement;
+export interface ValueProps extends DivProps {
+    dimensions?: dimensions.Dimensions;
+    color?: Color.Crude;
+}
+export declare const Value: ({ className, color, dimensions, orientation, ...props }: ValueProps) => ReactElement;
+export interface SwitchProps extends ToggleProps, DivProps {
+}
+export declare const Switch: ({ triggered, enabled, color, onClick, orientation, ...props }: SwitchProps) => ReactElement;
+export interface ButtonProps extends DivProps {
+    label?: string;
+}
+export declare const Button: ({ onClick, orientation, label, }: ButtonProps) => ReactElement;
+export {};

package/dist/vis/pid/primitives/Primitives.stories.d.ts

@@ -0,0 +1,5 @@
+import { type Meta, type StoryFn } from "@storybook/react";
+import { Primitives } from '../../../vis/pid/primitives/index';
+declare const story: Meta<typeof Primitives.Tank>;
+export declare const Primary: StoryFn<typeof Primitives.Tank>;
+export default story;

package/dist/vis/pid/primitives/index.d.ts

@@ -0,0 +1 @@
+export * as Primitives from '../../../vis/pid/primitives/Primitives';

package/dist/vis/pid/registry.d.ts

@@ -0,0 +1,17 @@
+import { type FC } from "react";
+import { z } from "zod";
+import { type Theming } from '../../theming';
+import { type SymbolFormProps } from '../../vis/pid/Forms';
+import { type SymbolProps } from '../../vis/pid/Symbols';
+export interface Spec<P extends object> {
+    name: string;
+    variant: string;
+    Form: FC<SymbolFormProps<P>>;
+    Symbol: FC<SymbolProps<P>>;
+    defaultProps: (t: Theming.Theme) => P;
+    Preview: FC<SymbolProps<P>>;
+}
+declare const typeZ: z.ZodEnum<["threeWayValve", "valve", "solenoidValve", "fourWayValve", "angledValve", "pump", "tank", "reliefValve", "regulator", "burstDisc", "cap", "manualValve", "filter", "needleValve", "checkValve", "orifice", "angledReliefValve", "value", "button", "switch"]>;
+export type Variant = z.infer<typeof typeZ>;
+export declare const SYMBOLS: Record<Variant, Spec<any>>;
+export {};

package/dist/vis/render/GLProgram.d.ts

@@ -0,0 +1,44 @@
+import { type Destructor, xy } from "@synnaxlabs/x";
+import { type color } from '../../color/core';
+import { type Context } from '../../vis/render/context';
+/**
+ * A general purpose compiler and utility container for workign with WebGL programs.
+ */
+export declare class GLProgram {
+    /** The render context used by this program. */
+    readonly ctx: Context;
+    /** The underlying webgl program. */
+    readonly prog: WebGLProgram;
+    /** The code for the vertex shader. */
+    private readonly vertShader;
+    /** The code for the fragment shader. */
+    private readonly fragShader;
+    /**
+     * @constructor compiles the given vertex and fragment shaders under the given
+     * render context into a program.
+     *
+     * @param ctx - The render context to use.
+     * @param vertShader - The vertex shader code.
+     * @param fragShader - The fragment shader code.
+     */
+    constructor(ctx: Context, vertShader: string, fragShader: string);
+    /** Sets the current program as the active program used by the context. */
+    setAsActive(): Destructor;
+    /**
+     * Sets a uniform XY coordinate value.
+     *
+     * @param name - The name of the uniform.
+     * @param value - The value to set.
+     */
+    uniformXY(name: string, value: xy.Crude): void;
+    /**
+     * Sets a uniform color value.
+     *
+     * @param name - The name of the uniform.
+     * @param value - The value to set.
+     */
+    uniformColor(name: string, value: color.Color): void;
+    private getUniformLoc;
+    private compile;
+    private compileShader;
+}

package/dist/vis/render/clear/index.d.ts

@@ -0,0 +1 @@
+export * as clear from '../../../vis/render/clear/program';

package/dist/vis/render/clear/program.d.ts

@@ -0,0 +1,14 @@
+import { type Context } from '../../../vis/render/context';
+import { GLProgram } from '../../../vis/render/GLProgram';
+/**
+ * You may be wondering, why does this program that draws a colorless, zero-footprint
+ * triangle exist? It turns out that the WeBGL implementation on windows doesn't actually
+ * clear a scissored region of the screen when you call `gl.clear`, you actually need
+ * to make a draw call to replace what's currently in the framebuffer. This is a
+ * workaround that does exactly that.
+ */
+export declare class Program extends GLProgram {
+    private readonly positionBuffer;
+    constructor(ctx: Context);
+    exec(): void;
+}

package/dist/vis/render/context.d.ts

@@ -0,0 +1,61 @@
+import { type Destructor, box, scale, xy, type runtime } from "@synnaxlabs/x";
+import { type aether } from '../../aether/aether';
+import { SugaredOffscreenCanvasRenderingContext2D } from '../../vis/draw2d/canvas';
+import { Loop } from '../../vis/render/loop';
+export type CanvasVariant = "upper2d" | "lower2d" | "gl";
+/**
+ * A hybrid rendering context containing both 2D and WebGL canvases and contexts.
+ * Implements several utility methods for correctly scaling the canvas, restricting
+ * drawing to a region, and erasing portions of the canvas.
+ */
+export declare class Context {
+    readonly glCanvas: OffscreenCanvas;
+    /** The canvas element used by the 2D canvas. */
+    readonly upper2dCanvas: OffscreenCanvas;
+    /** The canvas element used by the 2D canvas. */
+    readonly lower2dCanvas: OffscreenCanvas;
+    /** The WebGL rendering context.  */
+    readonly gl: WebGL2RenderingContext;
+    /** A 2D canvas that sits below the WebGL canvas. */
+    lower2d: SugaredOffscreenCanvasRenderingContext2D;
+    /** A 2D canvas that sits above the WebGL canvas. */
+    upper2d: SugaredOffscreenCanvasRenderingContext2D;
+    /** The region the canvas occupies in pixel space */
+    region: box.Box;
+    /** The device pixel ratio of the canvas */
+    dpr: number;
+    /** queue render transitions onto the stack */
+    readonly loop: Loop;
+    /** See the @link{clear.Program} for why this is necessary. */
+    private readonly clearProgram?;
+    private readonly os;
+    private static readonly CONTEXT_KEY;
+    static create(ctx: aether.Context, glCanvas: OffscreenCanvas, lower2dCanvas: OffscreenCanvas, upper2dCanvas: OffscreenCanvas, os: runtime.OS): Context;
+    private constructor();
+    static useOptional(ctx: aether.Context): Context | null;
+    static use(ctx: aether.Context): Context;
+    update(ctx: aether.Context): void;
+    /**
+     * Resizes the canvas to the given region and device pixel ratio. Ensuring
+     * that all drawing operations and viewports are scaled correctly.
+     */
+    resize(region: box.Box, dpr: number): void;
+    private resizeCanvas;
+    /** @returns the aspect ratio of the canvas. */
+    get aspect(): number;
+    /**
+     * Takes the given box in PIXEL space and produces a transform
+     * in CLIP space representing the sub-region represented by the box
+     * in the canvas.
+     */
+    scaleRegion(b: box.Box): scale.XY;
+    scissor(region: box.Box, overscan: {
+        x: number;
+        y: number;
+    } | undefined, canvases: CanvasVariant[]): Destructor;
+    private scissorCanvas;
+    private scissorGL;
+    erase(region: box.Box, overscan?: xy.Crude, ...canvases: CanvasVariant[]): void;
+    private eraseGL;
+    private eraseCanvas;
+}

package/dist/vis/render/controller.d.ts

@@ -0,0 +1,14 @@
+import { type aether } from '../../aether/aether';
+export type RequestF = (reason: string) => void;
+export declare const REASON_LAYOUT = "layout";
+export declare const REASON_DATA = "data";
+export declare const REASON_TOOL = "tool";
+export declare class Controller {
+    f: RequestF;
+    static readonly CONTEXT_KEY = "pluto-vis-renderer";
+    private constructor();
+    static control(ctx: aether.Context, f: RequestF): void;
+    static useRequest(ctx: aether.Context): RequestF;
+    static useOptionalRequest(ctx: aether.Context): RequestF | null;
+    static requestRender(ctx: aether.Context, reason: string): void;
+}

package/dist/vis/render/eraser.d.ts

@@ -0,0 +1,19 @@
+import { box, type xy } from "@synnaxlabs/x";
+import { type CanvasVariant, type Context } from '../../vis/render/context';
+export declare class Eraser {
+    prevErase: {
+        one: {
+            x: number;
+            y: number;
+        };
+        two: {
+            x: number;
+            y: number;
+        };
+        root: {
+            x: "left" | "right";
+            y: "bottom" | "top";
+        };
+    };
+    erase(ctx: Context, next: box.Box, prev: box.Box, overscan: xy.Crude, canvases: CanvasVariant[]): void;
+}

package/dist/vis/render/external.d.ts

@@ -0,0 +1,5 @@
+export * from '../../vis/render/context';
+export * from '../../vis/render/eraser';
+export * from '../../vis/render/GLProgram';
+export * from '../../vis/render/loop';
+export * from '../../vis/render/controller';

package/dist/vis/render/index.d.ts

@@ -0,0 +1 @@
+export * as render from '../../vis/render/external';

package/dist/vis/render/loop.d.ts

@@ -0,0 +1,73 @@
+import { type CanvasVariant } from '../../vis/render/context';
+/**
+ * An async function that executes the render in the loop. This function can return an
+ * optional cleanup that is executed before the next render. This cleanup function will
+ * be passed the signature of the previous render request.
+ */
+export type Func = () => Promise<Cleanup | undefined>;
+/**
+ * A request to render a component in the aether visualization tree. Submit a complete
+ * version of this request to the {@link Loop} to render a component.
+ */
+export interface Request {
+    /**
+     * A key identifying the component requesting the render. This helps to prevent
+     * duplicate renders for the same component from being executed.
+     */
+    key: string;
+    /**
+     * A priority ("high" or "low") for the render. High priority renders that have
+     * an equal or greater number of canvases will replace low priority renders already
+     * requested.
+     */
+    priority: Priority;
+    /**
+     * A list of canvases that the component is requesting to render to. This provides
+     * information to cleanup functions about which canvases to clear. The component should
+     * ONLY render to these canvases, otherwise the cleanup function may unnecessarily
+     * clear canvases that should persist.
+     */
+    canvases: CanvasVariant[];
+    /**
+     * An async function that performs the render. This function can return an optional
+     * cleanup that is executed before the next render. This cleanup function will be
+     * passed the signature of the previous render request.
+     */
+    render: Func;
+}
+/**
+ * A cleanup function that receives the request from the previous render. Cleanup
+ * functions should clear canvases and other resources that need to be freed from
+ * the previous render.
+ */
+export type Cleanup = (req: Request) => void;
+export type Priority = "high" | "low";
+/**
+ * Implements the core rendering loop for Synnax's aether components, accepting requests
+ * into a queue and rendering them in sync with the browser animation frame.
+ */
+export declare class Loop {
+    /** Protect concurrent access on the requests map. */
+    private readonly mutex;
+    /** Stores the current requests for rendering. */
+    private readonly requests;
+    /** Stores render cleanup functions for clearing canvases and other resources. */
+    private readonly cleanup;
+    constructor();
+    /**
+     * Sets a new request in the queue according to a set of rules:
+     *
+     * 1. If no request with the same key exists, add the request to the queue.
+     * 2. If a request with the same key exists, replace it if the new request has a
+     * greater or equal priority and a greater or equal number of canvases that are
+     * being rendered to.
+     *
+     * @param req - The request to set.
+     */
+    set(req: Request): Promise<void>;
+    /** Execute the render. */
+    private render;
+    /** Starts the rendering loop. */
+    private start;
+    private sleep;
+}

package/dist/vis/rule/Rule.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { type z } from "zod";
+import { rule } from '../../vis/rule/aether';
+export interface RuleProps extends Omit<z.input<typeof rule.ruleStateZ>, "dragging" | "pixelPosition"> {
+    label?: string;
+    onLabelChange?: (label: string) => void;
+    units?: string;
+    onPositionChange?: (position: number) => void;
+}
+export declare const Rule: import("react").FC<RuleProps & {
+    aetherKey?: string | undefined;
+}>;