taffy-js 0.2.2 → 0.2.4

package/taffy_js.d.ts

@@ -2,818 +2,2039 @@
 /* eslint-disable */
 
 /**
- * Multi-line content alignment enum (Align Content)
- * 
- * Controls spacing distribution between lines in a multi-line flex container.
- * Corresponds to CSS `align-content` property. Only effective when `flex-wrap: wrap`.
- * 
- * # Variants
- * - `SpaceBetween`: Lines evenly distributed, first/last lines flush with edges
- * - `SpaceAround`: Equal space on both sides of each line
- * - `SpaceEvenly`: All spacing completely equal
+ * Available space constraint for layout computation.
+ *
+ * Specifies how much space is available for a node during layout calculation.
+ * This is passed to `computeLayout()` to define the container constraints.
+ *
+ * @remarks
+ * - Use `number` when you have a fixed container size
+ * - Use `"minContent"` to shrink-wrap to the minimum content size
+ * - Use `"maxContent"` to expand to fit all content without wrapping
+ *
+ * @example
+ * ```typescript
+ * import init, { TaffyTree, Style, type AvailableSpace, type Size } from 'taffy-js';
+ *
+ * await init();
+ * const tree = new TaffyTree();
+ * const root: bigint = tree.newLeaf(new Style());
+ *
+ * // Fixed size container with type annotation
+ * const fixedSpace: Size<AvailableSpace> = {
+ *   width: 800,
+ *   height: 600
+ * };
+ * tree.computeLayout(root, fixedSpace);
+ *
+ * // Flexible width, fixed height
+ * const flexibleSpace: Size<AvailableSpace> = {
+ *   width: "maxContent",
+ *   height: 400
+ * };
+ * tree.computeLayout(root, flexibleSpace);
+ * ```
+ */
+export type AvailableSpace = number | "minContent" | "maxContent";
+
+/**
+ * Generic size type with width and height.
+ *
+ * A two-dimensional container for width and height values. The type parameter `T`
+ * determines what kind of values are stored.
+ *
+ * @typeParam T - The type of each dimension (e.g., `number`, `Dimension`, `AvailableSpace`)
+ *
+ * @property width - The horizontal dimension value
+ * @property height - The vertical dimension value
+ *
+ * @example
+ * ```typescript
+ * import type { Size, Dimension, AvailableSpace } from 'taffy-js';
+ *
+ * // Size with explicit type parameters
+ * const pixelSize: Size<number> = { width: 200, height: 100 };
+ *
+ * const dimensionSize: Size<Dimension> = {
+ *   width: { Length: 200 },
+ *   height: { Percent: 50 }
+ * };
+ *
+ * const availableSize: Size<AvailableSpace> = {
+ *   width: 800,
+ *   height: "MaxContent"
+ * };
+ * ```
+ */
+export interface Size<T> {
+  /** The horizontal dimension value */
+  width: T;
+  /** The vertical dimension value */
+  height: T;
+}
+
+/**
+ * Custom measure function for leaf nodes with text or other dynamic content.
+ *
+ * This callback is invoked during layout computation for leaf nodes that need
+ * custom sizing based on their content (e.g., text nodes that need text measurement).
+ *
+ * @param knownDimensions - Dimensions already determined by constraints. Each dimension
+ *                          is `number` if known, or `null` if needs to be measured.
+ * @param availableSpace - The available space constraints for the node. Can be definite
+ *                         pixels, "minContent", or "maxContent".
+ * @param node - The node ID (`bigint`) of the node being measured
+ * @param context - User-provided context attached to the node via `newLeafWithContext()`
+ * @param style - The node's current Style configuration
+ *
+ * @returns - The measured size of the content in pixels
+ *
+ * @example
+ * ```typescript
+ * import init, { TaffyTree, Style, type MeasureFunction, type Size } from 'taffy-js';
+ *
+ * interface TextContext {
+ *   text: string;
+ *   fontSize: number;
+ * }
+ *
+ * await init();
+ * const tree = new TaffyTree();
+ *
+ * const style = new Style();
+ * const context: TextContext = { text: "Hello, World!", fontSize: 16 };
+ * const textNode: bigint = tree.newLeafWithContext(style, context);
+ *
+ * // Typed measure function
+ * const measureText: MeasureFunction = (
+ *   knownDimensions,
+ *   availableSpace,
+ *   node,
+ *   context,
+ *   style
+ * ): Size<number> => {
+ *   const ctx = context as TextContext | undefined;
+ *   if (!ctx?.text) return { width: 0, height: 0 };
+ *
+ *   const width = knownDimensions.width ?? measureTextWidth(ctx.text, ctx.fontSize);
+ *   const height = knownDimensions.height ?? ctx.fontSize * 1.2;
+ *
+ *   return { width, height };
+ * };
+ *
+ * tree.computeLayoutWithMeasure(
+ *   textNode,
+ *   { width: 200, height: "maxContent" },
+ *   measureText
+ * );
+ * ```
+ */
+export type MeasureFunction = (
+  knownDimensions: Size<number | null>,
+  availableSpace: Size<AvailableSpace>,
+  node: bigint,
+  context: any,
+  style: Style,
+) => Size<number>;
+
+/**
+ * Dimension type supporting length, percentage, or auto values.
+ *
+ * Used for sizing properties like `width`, `height`, `flexBasis`, etc.
+ *
+ * @remarks
+ * - `number`: Fixed size in pixels
+ * - `"{number}%"`: Percentage of parent's size (0-100)
+ * - `"auto"`: Size determined by content or layout algorithm
+ *
+ * @example
+ * ```typescript
+ * import { Style, type Dimension, type Size } from 'taffy-js';
+ *
+ * const style = new Style();
+ *
+ * // With explicit type annotations
+ * const fixedSize: Size<Dimension> = {
+ *   width: 200,
+ *   height: 100
+ * };
+ *
+ * const percentSize: Size<Dimension> = {
+ *   width: "50%",
+ *   height: "100%"
+ * };
+ *
+ * const autoSize: Size<Dimension> = {
+ *   width: "auto",
+ *   height: "auto"
+ * };
+ *
+ * style.size = fixedSize;
+ * ```
+ */
+export type Dimension = number | `${number}%` | "auto";
+
+/**
+ * Length or percentage value (no auto support).
+ *
+ * Used for properties that require explicit values, such as `padding`, `border`, and `gap`.
+ *
+ * @remarks
+ * - `number`: Fixed size in pixels
+ * - `"{number}%"`: Percentage of parent's size (0-100)
+ *
+ * @example
+ * ```typescript
+ * import { Style, type LengthPercentage, type Rect, type Size } from 'taffy-js';
+ *
+ * const style = new Style();
+ *
+ * const padding: Rect<LengthPercentage> = {
+ *   left: 10,
+ *   right: 10,
+ *   top: 5,
+ *   bottom: 5
+ * };
+ *
+ * const gap: Size<LengthPercentage> = {
+ *   width: "5%",
+ *   height: "5%"
+ * };
+ *
+ * style.padding = padding;
+ * style.gap = gap;
+ * ```
+ */
+export type LengthPercentage = number | `${number}%`;
+
+/**
+ * Length, percentage, or auto value.
+ *
+ * Used for properties that support auto values, such as `margin` and `inset`.
+ *
+ * @remarks
+ * - `number`: Fixed size in pixels
+ * - `"{number}%"`: Percentage of parent's size (0-100)
+ * - `"auto"`: Automatic value (behavior depends on property)
+ *
+ * @example
+ * ```typescript
+ * import { Style, type LengthPercentageAuto, type Rect } from 'taffy-js';
+ *
+ * const style = new Style();
+ *
+ * // Auto margins for horizontal centering
+ * const centerMargin: Rect<LengthPercentageAuto> = {
+ *   left: "auto",
+ *   right: "auto",
+ *   top: 0,
+ *   bottom: 0
+ * };
+ *
+ * style.margin = centerMargin;
+ * ```
+ */
+export type LengthPercentageAuto = number | `${number}%` | "auto";
+
+/**
+ * Point with x and y coordinates/values.
+ *
+ * Used for properties that have separate horizontal (x) and vertical (y) values,
+ * such as `overflow`.
+ *
+ * @typeParam T - The type of each coordinate
+ *
+ * @property x - The horizontal value
+ * @property y - The vertical value
+ *
+ * @example
+ * ```typescript
+ * import { Style, Overflow, type Point } from 'taffy-js';
+ *
+ * const style = new Style();
+ *
+ * const overflow: Point<typeof Overflow[keyof typeof Overflow]> = {
+ *   x: Overflow.Hidden,
+ *   y: Overflow.Scroll
+ * };
+ *
+ * style.overflow = overflow;
+ * ```
+ */
+export interface Point<T> {
+  /** The horizontal (x-axis) value */
+  x: T;
+  /** The vertical (y-axis) value */
+  y: T;
+}
+
+/**
+ * Rectangle with left, right, top, and bottom values.
+ *
+ * Used for box model properties like `margin`, `padding`, `border`, and `inset`.
+ *
+ * @typeParam T - The type of each side value
+ *
+ * @property left - The left side value
+ * @property right - The right side value
+ * @property top - The top side value
+ * @property bottom - The bottom side value
+ *
+ * @example
+ * ```typescript
+ * import { Style, type Rect, type LengthPercentage, type LengthPercentageAuto } from 'taffy-js';
+ *
+ * const style = new Style();
+ *
+ * // Typed padding
+ * const padding: Rect<LengthPercentage> = {
+ *   left: 10,
+ *   right: 10,
+ *   top: 10,
+ *   bottom: 10
+ * };
+ *
+ * // Typed margin with auto
+ * const margin: Rect<LengthPercentageAuto> = {
+ *   left: "auto",
+ *   right: "auto",
+ *   top: 10,
+ *   bottom: 30
+ * };
+ *
+ * style.padding = padding;
+ * style.margin = margin;
+ * ```
+ */
+export interface Rect<T> {
+  /** The left side value */
+  left: T;
+  /** The right side value */
+  right: T;
+  /** The top side value */
+  top: T;
+  /** The bottom side value */
+  bottom: T;
+}
+
+/**
+ * Detailed layout information (for grid layouts).
+ *
+ * Returned by `detailedLayoutInfo()` for nodes using CSS Grid layout.
+ * Contains detailed information about grid tracks and item placement.
+ *
+ * @remarks
+ * This is only available when the `detailed_layout_info` feature is enabled.
+ *
+ * @example
+ * ```typescript
+ * import type { DetailedLayoutInfo, DetailedGridInfo } from 'taffy-js';
+ *
+ * const info: DetailedLayoutInfo = tree.detailedLayoutInfo(gridNode);
+ *
+ * if (info !== "None" && typeof info === 'object' && 'Grid' in info) {
+ *   const grid: DetailedGridInfo = info.Grid;
+ *   console.log('Rows:', grid.rows.sizes);
+ *   console.log('Columns:', grid.columns.sizes);
+ * }
+ * ```
+ */
+export type DetailedLayoutInfo = DetailedGridInfo | null;
+
+/**
+ * Detailed information about a grid layout.
+ *
+ * Contains information about grid rows, columns, and item placement.
+ *
+ * @property rows - Information about row tracks
+ * @property columns - Information about column tracks
+ * @property items - Array of item placement information
+ */
+export interface DetailedGridInfo {
+  /** Information about the grid's row tracks */
+  rows: DetailedGridTracksInfo;
+  /** Information about the grid's column tracks */
+  columns: DetailedGridTracksInfo;
+  /** Placement information for each grid item */
+  items: DetailedGridItemsInfo[];
+}
+
+/**
+ * Information about grid tracks (rows or columns).
+ *
+ * Provides detailed sizing and gutter information for a set of grid tracks.
+ *
+ * @property negative_implicit_tracks - Number of implicit tracks before explicit tracks
+ * @property explicit_tracks - Number of explicitly defined tracks
+ * @property positive_implicit_tracks - Number of implicit tracks after explicit tracks
+ * @property gutters - Array of gutter sizes between tracks (in pixels)
+ * @property sizes - Array of track sizes (in pixels)
+ */
+export interface DetailedGridTracksInfo {
+  /** Number of implicit tracks before explicit tracks (for negative line numbers) */
+  negative_implicit_tracks: number;
+  /** Number of tracks explicitly defined in grid-template-rows/columns */
+  explicit_tracks: number;
+  /** Number of implicit tracks created after explicit tracks */
+  positive_implicit_tracks: number;
+  /** Gap sizes between tracks in pixels */
+  gutters: number[];
+  /** Computed sizes of each track in pixels */
+  sizes: number[];
+}
+
+/**
+ * Information about a grid item's placement.
+ *
+ * Specifies which grid lines the item spans on both axes.
+ * Line numbers are 1-indexed, with 1 being the first line.
+ *
+ * @property row_start - Starting row line number (1-indexed)
+ * @property row_end - Ending row line number (exclusive)
+ * @property column_start - Starting column line number (1-indexed)
+ * @property column_end - Ending column line number (exclusive)
+ */
+export interface DetailedGridItemsInfo {
+  /** Starting row line (1-indexed) */
+  row_start: number;
+  /** Ending row line (exclusive) */
+  row_end: number;
+  /** Starting column line (1-indexed) */
+  column_start: number;
+  /** Ending column line (exclusive) */
+  column_end: number;
+}
+
+/**
+ * Multi-line content alignment enumeration
+ *
+ * Controls the distribution of space between and around content items along the cross axis
+ * in a multi-line flex container. This corresponds to the CSS `align-content` property.
+ *
+ * **Note**: This property only has effect when `flex-wrap` is set to `Wrap` or `WrapReverse`.
+ *
+ * @example
+ * ```typescript
+ * import { AlignContent, FlexWrap } from 'taffy-js';
+ *
+ * style.flexWrap = FlexWrap.Wrap;
+ * style.alignContent = AlignContent.SpaceBetween;  // Distribute lines evenly
+ * ```
  */
 export enum AlignContent {
+  /**
+   * Lines packed toward the start of the cross axis
+   */
   Start = 0,
+  /**
+   * Lines packed toward the end of the cross axis
+   */
   End = 1,
+  /**
+   * Lines packed toward the start of the flex container
+   */
   FlexStart = 2,
+  /**
+   * Lines packed toward the end of the flex container
+   */
   FlexEnd = 3,
+  /**
+   * Lines centered within the container
+   */
   Center = 4,
+  /**
+   * Lines stretched to fill the container
+   */
   Stretch = 5,
+  /**
+   * Lines evenly distributed with first/last at edges
+   */
   SpaceBetween = 6,
+  /**
+   * Lines evenly distributed with equal space around each
+   */
   SpaceAround = 7,
+  /**
+   * Lines evenly distributed with equal space between each
+   */
   SpaceEvenly = 8,
 }
 
 /**
- * Cross-axis alignment enum for children (Align Items)
- * 
- * Defines how all children are aligned on the cross axis in a Flex/Grid container.
- * 
- * # Variants
- * - `Start/FlexStart`: Align to cross axis start
- * - `End/FlexEnd`: Align to cross axis end
- * - `Center`: Center alignment
- * - `Baseline`: Baseline alignment (text baseline)
- * - `Stretch`: Stretch to fill container
+ * Cross-axis alignment enumeration for all children
+ *
+ * Defines the default alignment for all flex/grid items along the cross axis.
+ * This corresponds to the CSS `align-items` property.
+ *
+ * @example
+ * ```typescript
+ * import { AlignItems } from 'taffy-js';
+ *
+ * style.alignItems = AlignItems.Center;   // Center items on cross axis
+ * style.alignItems = AlignItems.Stretch;  // Stretch items to fill container
+ * ```
  */
 export enum AlignItems {
+  /**
+   * Items aligned to the start of the cross axis
+   */
   Start = 0,
+  /**
+   * Items aligned to the end of the cross axis
+   */
   End = 1,
+  /**
+   * Items aligned to the start of the flex container
+   */
   FlexStart = 2,
+  /**
+   * Items aligned to the end of the flex container
+   */
   FlexEnd = 3,
+  /**
+   * Items centered along the cross axis
+   */
   Center = 4,
+  /**
+   * Items aligned to their text baselines
+   */
   Baseline = 5,
+  /**
+   * Items stretched to fill the container
+   */
   Stretch = 6,
 }
 
 /**
- * Cross-axis alignment enum for single element (Align Self)
- * 
- * Overrides parent's `align-items` for a single child element's cross-axis alignment.
- * 
- * # Variants
- * - `Auto`: Inherit parent's `align-items` value
- * - Other values have same meaning as `AlignItems`
+ * Cross-axis alignment enumeration for a single element
+ *
+ * Overrides the parent's `align-items` value for a specific child element.
+ * This corresponds to the CSS `align-self` property.
+ *
+ * @example
+ * ```typescript
+ * import { AlignSelf } from 'taffy-js';
+ *
+ * style.alignSelf = AlignSelf.Auto;    // Use parent's align-items
+ * style.alignSelf = AlignSelf.Center;  // Override to center this item
+ * ```
  */
 export enum AlignSelf {
+  /**
+   * Inherits the parent container's `align-items` value
+   */
   Auto = 0,
+  /**
+   * Item aligned to the start of the cross axis
+   */
   Start = 1,
+  /**
+   * Item aligned to the end of the cross axis
+   */
   End = 2,
+  /**
+   * Item aligned to the start of the flex container
+   */
   FlexStart = 3,
+  /**
+   * Item aligned to the end of the flex container
+   */
   FlexEnd = 4,
+  /**
+   * Item centered along the cross axis
+   */
   Center = 5,
+  /**
+   * Item aligned to its text baseline
+   */
   Baseline = 6,
+  /**
+   * Item stretched to fill the container
+   */
   Stretch = 7,
 }
 
 /**
- * Box sizing enum
- * 
+ * Box sizing enumeration
+ *
  * Controls how the total width and height of an element is calculated.
- * 
- * # Variants
- * - `BorderBox`: Width and height include content, padding, and border (default)
- * - `ContentBox`: Width and height include only the content
+ * This corresponds to the CSS `box-sizing` property.
+ *
+ * @example
+ * ```typescript
+ * import { BoxSizing } from 'taffy-js';
+ *
+ * style.boxSizing = BoxSizing.BorderBox;   // Size includes padding and border
+ * style.boxSizing = BoxSizing.ContentBox;  // Size is content only
+ * ```
  */
 export enum BoxSizing {
+  /**
+   * The width and height properties include padding and border
+   */
   BorderBox = 0,
+  /**
+   * The width and height properties include only the content
+   */
   ContentBox = 1,
 }
 
 /**
- * Display mode enum
- * 
- * Controls the layout algorithm type for an element. Corresponds to CSS `display` property.
- * 
- * # Variants
- * - `Block`: Block-level layout, element takes full width
- * - `Flex`: Flexbox layout, one-dimensional layout model
- * - `Grid`: CSS Grid layout, two-dimensional layout model  
- * - `None`: Hidden, element does not participate in layout calculation
+ * Display mode enumeration
+ *
+ * Controls the layout algorithm type for an element. This corresponds to the CSS `display` property
+ * and determines how an element and its children are laid out.
+ *
+ * @example
+ * ```typescript
+ * import { Display } from 'taffy-js';
+ *
+ * style.display = Display.Flex;  // Enable flexbox layout
+ * style.display = Display.Grid;  // Enable grid layout
+ * style.display = Display.None;  // Hide element from layout
+ * ```
  */
 export enum Display {
+  /**
+   * Block-level layout where element takes the full available width
+   */
   Block = 0,
+  /**
+   * Flexbox layout for one-dimensional item arrangement
+   */
   Flex = 1,
+  /**
+   * CSS Grid layout for two-dimensional item arrangement
+   */
   Grid = 2,
+  /**
+   * Element is removed from layout calculation entirely
+   */
   None = 3,
 }
 
 /**
- * Flex main axis direction enum
- * 
- * Defines the direction children are laid out in a flex container. Corresponds to CSS `flex-direction` property.
- * 
- * # Variants
- * - `Row`: Horizontal direction, left to right (LTR mode)
- * - `Column`: Vertical direction, top to bottom
- * - `RowReverse`: Horizontal reverse, right to left
- * - `ColumnReverse`: Vertical reverse, bottom to top
+ * Flex direction enumeration
+ *
+ * Defines the main axis direction for flex item layout. This corresponds to the CSS
+ * `flex-direction` property and determines how flex items are placed within the container.
+ *
+ * @example
+ * ```typescript
+ * import { FlexDirection } from 'taffy-js';
+ *
+ * style.flexDirection = FlexDirection.Row;     // Horizontal, left to right
+ * style.flexDirection = FlexDirection.Column;  // Vertical, top to bottom
+ * ```
  */
 export enum FlexDirection {
+  /**
+   * Main axis runs horizontally from left to right
+   */
   Row = 0,
+  /**
+   * Main axis runs vertically from top to bottom
+   */
   Column = 1,
+  /**
+   * Main axis runs horizontally from right to left
+   */
   RowReverse = 2,
+  /**
+   * Main axis runs vertically from bottom to top
+   */
   ColumnReverse = 3,
 }
 
 /**
- * Flex wrap mode enum
- * 
- * Controls whether flex items wrap onto multiple lines. Corresponds to CSS `flex-wrap` property.
- * 
- * # Variants
- * - `NoWrap`: No wrapping, all items compressed into single line/column
- * - `Wrap`: Automatic wrapping, items flow to next line when container overflows
- * - `WrapReverse`: Reverse wrapping, new lines appear above or to the left
+ * Flex wrap mode enumeration
+ *
+ * Controls whether flex items wrap onto multiple lines when they overflow the container.
+ * This corresponds to the CSS `flex-wrap` property.
+ *
+ * @example
+ * ```typescript
+ * import { FlexWrap } from 'taffy-js';
+ *
+ * style.flexWrap = FlexWrap.NoWrap;  // All items on single line
+ * style.flexWrap = FlexWrap.Wrap;    // Items wrap to new lines
+ * ```
  */
 export enum FlexWrap {
+  /**
+   * All flex items are placed on a single line
+   */
   NoWrap = 0,
+  /**
+   * Flex items wrap onto multiple lines from top to bottom
+   */
   Wrap = 1,
+  /**
+   * Flex items wrap onto multiple lines from bottom to top
+   */
   WrapReverse = 2,
 }
 
 /**
- * Main axis alignment enum (Justify Content)
- * 
- * Defines alignment and spacing distribution of children along the main axis.
- * Corresponds to CSS `justify-content` property.
- * 
- * # Variants
- * - `Start/FlexStart`: Align to main axis start
- * - `End/FlexEnd`: Align to main axis end
- * - `Center`: Center alignment
- * - `SpaceBetween`: First and last items flush with edges, remaining space distributed evenly
- * - `SpaceAround`: Equal space on both sides of each item
- * - `SpaceEvenly`: All spacing completely equal
+ * Main axis alignment enumeration
+ *
+ * Defines how flex items are aligned and spaced along the main axis.
+ * This corresponds to the CSS `justify-content` property.
+ *
+ * @example
+ * ```typescript
+ * import { JustifyContent } from 'taffy-js';
+ *
+ * style.justifyContent = JustifyContent.Center;        // Center items
+ * style.justifyContent = JustifyContent.SpaceBetween;  // Distribute evenly
+ * ```
  */
 export enum JustifyContent {
+  /**
+   * Items packed toward the start of the main axis
+   */
   Start = 0,
+  /**
+   * Items packed toward the end of the main axis
+   */
   End = 1,
+  /**
+   * Items packed toward the start of the flex container
+   */
   FlexStart = 2,
+  /**
+   * Items packed toward the end of the flex container
+   */
   FlexEnd = 3,
+  /**
+   * Items centered along the main axis
+   */
   Center = 4,
+  /**
+   * Items stretched along the main axis
+   */
   Stretch = 5,
+  /**
+   * Items evenly distributed with first/last at edges
+   */
   SpaceBetween = 6,
+  /**
+   * Items evenly distributed with equal space around each
+   */
   SpaceAround = 7,
+  /**
+   * Items evenly distributed with equal space between each
+   */
   SpaceEvenly = 8,
 }
 
 /**
- * Overflow handling enum
- * 
- * Defines how content that overflows container boundaries is handled.
- * Corresponds to CSS `overflow` property.
- * 
- * # Variants
- * - `Visible`: Content is not clipped
- * - `Hidden`: Content is clipped, overflow hidden
- * - `Scroll`: Always show scrollbars
- * - `Auto`: Show scrollbars when needed (internally mapped to Scroll)
+ * Computed layout result containing position, size, and spacing values for a node.
+ *
+ * This class wraps the native [`taffy::Layout`] and provides read-only access
+ * to all computed layout values. All dimensions are in pixels.
+ *
+ * @example
+ * ```typescript
+ * const layout = tree.getLayout(node);
+ *
+ * console.log("Position:", layout.x, layout.y);
+ * console.log("Size:", layout.width, layout.height);
+ * console.log("Content:", layout.contentWidth, layout.contentHeight);
+ * console.log("Padding:", layout.paddingTop, layout.paddingRight, layout.paddingBottom, layout.paddingLeft);
+ * console.log("Border:", layout.borderTop, layout.borderRight, layout.borderBottom, layout.borderLeft);
+ * console.log("Margin:", layout.marginTop, layout.marginRight, layout.marginBottom, layout.marginLeft);
+ * console.log("Scrollbar:", layout.scrollbarWidth, layout.scrollbarHeight);
+ * console.log("Order:", layout.order);
+ * ```
+ */
+export class Layout {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Gets the top border width
+   *
+   * @returns - The computed top border width in pixels
+   */
+  readonly borderTop: number;
+  /**
+   * Gets the top margin
+   *
+   * @returns - The computed top margin in pixels
+   */
+  readonly marginTop: number;
+  /**
+   * Gets the left border width
+   *
+   * @returns - The computed left border width in pixels
+   */
+  readonly borderLeft: number;
+  /**
+   * Gets the left margin
+   *
+   * @returns - The computed left margin in pixels
+   */
+  readonly marginLeft: number;
+  /**
+   * Gets the top padding
+   *
+   * @returns - The computed top padding in pixels
+   */
+  readonly paddingTop: number;
+  /**
+   * Gets the right border width
+   *
+   * @returns - The computed right border width in pixels
+   */
+  readonly borderRight: number;
+  /**
+   * Gets the right margin
+   *
+   * @returns - The computed right margin in pixels
+   */
+  readonly marginRight: number;
+  /**
+   * Gets the left padding
+   *
+   * @returns - The computed left padding in pixels
+   */
+  readonly paddingLeft: number;
+  /**
+   * Gets the bottom border width
+   *
+   * @returns - The computed bottom border width in pixels
+   */
+  readonly borderBottom: number;
+  /**
+   * Gets the width of the scrollable content
+   *
+   * If the node has overflow content, this represents the total
+   * width of all content (may exceed `width`).
+   *
+   * @returns - The content width in pixels
+   */
+  readonly contentWidth: number;
+  /**
+   * Gets the bottom margin
+   *
+   * @returns - The computed bottom margin in pixels
+   */
+  readonly marginBottom: number;
+  /**
+   * Gets the right padding
+   *
+   * @returns - The computed right padding in pixels
+   */
+  readonly paddingRight: number;
+  /**
+   * Gets the height of the scrollable content
+   *
+   * If the node has overflow content, this represents the total
+   * height of all content (may exceed `height`).
+   *
+   * @returns - The content height in pixels
+   */
+  readonly contentHeight: number;
+  /**
+   * Gets the bottom padding
+   *
+   * @returns - The computed bottom padding in pixels
+   */
+  readonly paddingBottom: number;
+  /**
+   * Gets the width of the vertical scrollbar
+   *
+   * When overflow is set to scroll, this indicates the space
+   * reserved for the vertical scrollbar.
+   *
+   * @returns - The scrollbar width in pixels (0 if no scrollbar)
+   */
+  readonly scrollbarWidth: number;
+  /**
+   * Gets the height of the horizontal scrollbar
+   *
+   * When overflow is set to scroll, this indicates the space
+   * reserved for the horizontal scrollbar.
+   *
+   * @returns - The scrollbar height in pixels (0 if no scrollbar)
+   */
+  readonly scrollbarHeight: number;
+  /**
+   * Gets the X coordinate of the node's top-left corner
+   *
+   * This value is relative to the node's parent. For the root node,
+   * this is always 0.
+   *
+   * @returns - The horizontal position in pixels
+   */
+  readonly x: number;
+  /**
+   * Gets the Y coordinate of the node's top-left corner
+   *
+   * This value is relative to the node's parent. For the root node,
+   * this is always 0.
+   *
+   * @returns - The vertical position in pixels
+   */
+  readonly y: number;
+  /**
+   * Gets the rendering order of the node
+   *
+   * This value determines the z-order for overlapping elements.
+   * Lower values are rendered first (behind higher values).
+   *
+   * @returns - The rendering order as an unsigned 32-bit integer
+   */
+  readonly order: number;
+  /**
+   * Gets the computed width of the node
+   *
+   * This is the final width after layout computation, including
+   * any constraints from min/max size or flex properties.
+   *
+   * @returns - The width in pixels
+   */
+  readonly width: number;
+  /**
+   * Gets the computed height of the node
+   *
+   * This is the final height after layout computation, including
+   * any constraints from min/max size or flex properties.
+   *
+   * @returns - The height in pixels
+   */
+  readonly height: number;
+}
+
+/**
+ * Overflow handling enumeration
+ *
+ * Defines how content that exceeds the container boundaries is handled.
+ * This corresponds to the CSS `overflow` property.
+ *
+ * @example
+ * ```typescript
+ * import { Overflow } from 'taffy-js';
+ *
+ * style.overflow = { x: Overflow.Hidden, y: Overflow.Scroll };
+ * ```
  */
 export enum Overflow {
+  /**
+   * Content is not clipped and may render outside the container
+   */
   Visible = 0,
+  /**
+   * Content is clipped at the container boundary
+   */
   Hidden = 1,
+  /**
+   * Always display scrollbars for scrollable content
+   */
   Scroll = 2,
+  /**
+   * Display scrollbars only when content overflows (internally maps to Scroll)
+   */
   Auto = 3,
 }
 
 /**
- * Position mode enum
- * 
- * Controls element positioning method. Corresponds to CSS `position` property.
- * 
- * # Variants
- * - `Relative`: Relative positioning, element stays in normal document flow
- * - `Absolute`: Absolute positioning, element removed from flow, positioned relative to nearest positioned ancestor
+ * Position mode enumeration
+ *
+ * Controls how an element is positioned within its parent container.
+ * This corresponds to the CSS `position` property.
+ *
+ * @example
+ * ```typescript
+ * import { Position } from 'taffy-js';
+ *
+ * style.position = Position.Relative;  // Normal document flow
+ * style.position = Position.Absolute;  // Removed from flow, uses inset values
+ * ```
  */
 export enum Position {
+  /**
+   * Element participates in normal document flow
+   */
   Relative = 0,
+  /**
+   * Element is positioned relative to its nearest positioned ancestor
+   */
   Absolute = 1,
 }
 
+/**
+ * CSS layout configuration for a node, including flexbox, sizing, spacing, and alignment properties.
+ *
+ * This class holds all CSS layout properties for a node. Create an instance with
+ * `new Style()` and configure properties before passing to `TaffyTree.newLeaf()`.
+ *
+ * @defaultValue
+ * When created, all properties are set to their CSS default values:
+ * - `display`: `Display.Block`
+ * - `position`: `Position.Relative`
+ * - `flexDirection`: `FlexDirection.Row`
+ * - `flexWrap`: `FlexWrap.NoWrap`
+ * - `flexGrow`: `0`
+ * - `flexShrink`: `1`
+ * - All alignment properties: `undefined` (use default behavior)
+ * - All dimensions: `"Auto"`
+ * - All spacing: `{ Length: 0 }`
+ *
+ */
 export class Style {
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Creates a new Style instance with default values.
-   * 
-   * All properties are initialized to their CSS default values:
-   * - display: Block
-   * - position: Relative
-   * - flex_direction: Row
-   * - All dimensions: Auto
-   * - All spacing (margin, padding, border): 0
-   * 
-   * # Returns
-   * A new Style instance with default configuration.
-   * 
-   * # Example
-   * ```javascript
+   * Creates a new Style instance with default values
+   *
+   * @returns - A new `Style` object with all properties set to CSS defaults
+   *
+   * @example
+   * ```typescript
    * const style = new Style();
-   * style.display = Display.Flex;
+   * console.log(style.display);  // Display.Block
    * ```
    */
   constructor();
   /**
-   * Gets the align-self property. Overrides parent's align-items for this element.
-   * Returns AlignSelf.Auto if not explicitly set.
-   */
-  get align_self(): AlignSelf | undefined;
-  /**
-   * Sets the align-self property. Use AlignSelf.Auto to inherit from parent.
+   * Gets the align-self property
+   *
+   * Overrides the parent's align-items for this specific element.
+   *
+   * @returns - The current [`AlignSelf`](JsAlignSelf) value (returns `Auto` if not set)
    */
-  set align_self(value: AlignSelf | null | undefined);
+  alignSelf: AlignSelf | undefined;
   /**
-   * Gets the box sizing mode (BorderBox or ContentBox).
+   * Gets the box sizing mode
+   *
+   * Determines whether padding and border are included in dimensions.
+   *
+   * @returns - The current [`BoxSizing`](JsBoxSizing) value
+   *
+   * @defaultValue `BoxSizing.BorderBox`
    */
-  box_sizing: BoxSizing;
+  boxSizing: BoxSizing;
   /**
-   * Gets the flex-basis as a JsDimension (Length, Percent, or Auto).
-   * Flex-basis defines the initial main size before grow/shrink.
+   * Gets the flex-basis
+   *
+   * The initial size of a flex item before growing/shrinking.
+   *
+   * @returns - A `Dimension` value (`{ Length: n }`, `{ Percent: n }`, or `"Auto"`)
    */
-  flex_basis: any;
+  flexBasis: Dimension;
   /**
-   * Gets the border width as a JsRect<JsLengthPercentage>.
-   * Border width defines the thickness of element borders.
-   * Supports Length or Percent for each edge (not Auto).
+   * Gets the border width
+   *
+   * Width of the element's border on each side.
+   *
+   * @returns - A `Rect<LengthPercentage>` with left, right, top, bottom border widths
    */
-  border: any;
+  border: Rect<LengthPercentage>;
   /**
-   * Gets the margin as a JsRect<JsLengthPercentageAuto>.
-   * Margin is the outer spacing around the element's border.
-   * Supports Length, Percent, or Auto for each edge.
+   * Gets the margin
+   *
+   * Outer spacing around the element.
+   *
+   * @returns - A `Rect<LengthPercentageAuto>` with left, right, top, bottom margins
    */
-  margin: any;
+  margin: Rect<LengthPercentageAuto>;
   /**
-   * Gets the align-items property. Controls cross-axis alignment of children.
+   * Gets the align-items property
+   *
+   * Defines the default alignment for all children on the cross axis.
+   *
+   * @returns - The current [`AlignItems`](JsAlignItems) value, or `undefined` if not set
    */
-  get align_items(): AlignItems | undefined;
+  alignItems: AlignItems | undefined;
   /**
-   * Sets the align-items property. Affects all children's cross-axis alignment.
+   * Gets the flex shrink factor
+   *
+   * Determines how much the item shrinks relative to siblings when
+   * there is insufficient space.
+   *
+   * @returns - The flex shrink factor (default: 1)
    */
-  set align_items(value: AlignItems | null | undefined);
+  flexShrink: number;
   /**
-   * Gets the flex shrink factor. Determines how much the item shrinks relative to siblings.
-   */
-  flex_shrink: number;
-  /**
-   * Gets the display mode (Block, Flex, Grid, or None).
+   * Gets the display mode
+   *
+   * Determines the layout algorithm used for this element and its children.
+   *
+   * @returns - The current [`Display`](JsDisplay) value
+   *
+   * @defaultValue - `Display.Block`
    */
   display: Display;
   /**
-   * Gets the padding as a JsRect<JsLengthPercentage>.
-   * Padding is the inner spacing between the border and content.
-   * Supports Length or Percent for each edge (not Auto).
+   * Gets the padding
+   *
+   * Inner spacing between the element's border and content.
+   *
+   * @returns - A `Rect<LengthPercentage>` with left, right, top, bottom padding
    */
-  padding: any;
+  padding: Rect<LengthPercentage>;
   /**
-   * Gets the aspect ratio (width / height). Returns None if not set.
+   * Gets the aspect ratio
+   *
+   * The ratio of width to height. Used to maintain proportions.
+   *
+   * @returns - The aspect ratio value, or `undefined` if not set
    */
-  get aspect_ratio(): number | undefined;
+  aspectRatio: number | undefined;
   /**
-   * Sets the aspect ratio. For example, 16/9 = 1.777... for widescreen.
-   * Set to None to remove the constraint.
+   * Gets the maximum size constraints
+   *
+   * @returns - A `Size<Dimension>` object with maximum width and height
    */
-  set aspect_ratio(value: number | null | undefined);
+  maxSize: Size<Dimension>;
   /**
-   * Gets the maximum size constraints as a JsSize<JsDimension>.
-   * Prevents the element from growing beyond these values.
+   * Gets the minimum size constraints
+   *
+   * @returns - A `Size<Dimension>` object with minimum width and height
    */
-  max_size: any;
+  minSize: Size<Dimension>;
   /**
-   * Gets the minimum size constraints as a JsSize<JsDimension>.
-   * Prevents the element from shrinking below these values.
+   * Gets the overflow behavior
+   *
+   * Controls how content that exceeds the container is handled.
+   *
+   * @returns - A `Point<Overflow>` with `x` and `y` overflow settings
    */
-  min_size: any;
+  overflow: Point<Overflow>;
   /**
-   * Gets the overflow behavior as a JS object with {x, y} properties.
-   */
-  overflow: any;
-  /**
-   * Gets the position mode (Relative or Absolute).
+   * Gets the position mode
+   *
+   * Determines how the element is positioned within its parent.
+   *
+   * @returns - The current [`Position`](JsPosition) value
+   *
+   * @defaultValue - `Position.Relative`
    */
   position: Position;
   /**
-   * Gets the align-content property. Controls spacing between lines in multi-line flex.
+   * Gets the align-content property
+   *
+   * Controls distribution of space between lines in a multi-line flex container.
+   *
+   * @returns - The current [`AlignContent`](JsAlignContent) value, or `undefined` if not set
    */
-  get align_content(): AlignContent | undefined;
+  alignContent: AlignContent | undefined;
   /**
-   * Sets the align-content property. Only effective when flex-wrap is enabled.
+   * Gets the flex grow factor
+   *
+   * Determines how much the item grows relative to siblings when
+   * there is extra space available.
+   *
+   * @returns - The flex grow factor (default: 0)
    */
-  set align_content(value: AlignContent | null | undefined);
+  flexGrow: number;
   /**
-   * Gets the flex grow factor. Determines how much the item grows relative to siblings.
+   * Gets the flex wrap mode
+   *
+   * Controls whether flex items wrap to new lines.
+   *
+   * @returns - The current [`FlexWrap`](JsFlexWrap) value
+   *
+   * @defaultValue - `FlexWrap.NoWrap`
    */
-  flex_grow: number;
+  flexWrap: FlexWrap;
   /**
-   * Gets the flex wrap mode (NoWrap, Wrap, WrapReverse).
+   * Gets the flex direction
+   *
+   * Defines the main axis direction for flex items.
+   *
+   * @returns - The current [`FlexDirection`](JsFlexDirection) value
+   *
+   * @defaultValue - `FlexDirection.Row`
    */
-  flex_wrap: FlexWrap;
+  flexDirection: FlexDirection;
   /**
-   * Gets the flex direction (Row, Column, RowReverse, ColumnReverse).
+   * Gets the justify-content property
+   *
+   * Defines alignment and spacing of items along the main axis.
+   *
+   * @returns - The current [`JustifyContent`](JsJustifyContent) value, or `undefined` if not set
    */
-  flex_direction: FlexDirection;
+  justifyContent: JustifyContent | undefined;
   /**
-   * Gets the justify-content property. Controls main-axis alignment and spacing.
+   * Gets the gap
+   *
+   * Spacing between flex/grid items.
+   *
+   * @returns - A `Size<LengthPercentage>` with column (width) and row (height) gaps
    */
-  get justify_content(): JustifyContent | undefined;
+  gap: Size<LengthPercentage>;
   /**
-   * Sets the justify-content property. Distributes space along the main axis.
+   * Gets the size (width and height)
+   *
+   * @returns - A `Size<Dimension>` object with `width` and `height` properties
    */
-  set justify_content(value: JustifyContent | null | undefined);
+  size: Size<Dimension>;
   /**
-   * Gets the gap between children as a JsSize<JsLengthPercentage>.
-   * Used in Flex and Grid layouts to add spacing between items.
-   * - width: column gap (horizontal spacing)
-   * - height: row gap (vertical spacing)
+   * Gets the inset
+   *
+   * Positioning offsets for absolutely positioned elements.
+   *
+   * @returns - A `Rect<LengthPercentageAuto>` with left, right, top, bottom offsets
    */
-  gap: any;
-  /**
-   * Gets the size (width, height) as a JsSize<JsDimension>.
-   * Each dimension can be Length, Percent, or Auto.
-   */
-  size: any;
+  inset: Rect<LengthPercentageAuto>;
+}
+
+/**
+ * Error class thrown when a Taffy operation fails, containing a human-readable error message.
+ *
+ * This class wraps the native [`taffy::TaffyError`] type and exposes it to JavaScript
+ * with a readable error message. It is thrown as a JavaScript exception on failure.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *  tree.remove(node);
+ * } catch (e) {
+ *   if (e instanceof TaffyError) {
+ *      console.error(e.message);
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * The underlying Taffy errors include:
+ * - `InvalidInputNode`: Node ID doesn't exist in the tree
+ * - `InvalidParentNode`: Specified parent node doesn't exist
+ * - `ChildIndexOutOfBounds`: Child index exceeds available children
+ */
+export class TaffyError {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
   /**
-   * Gets the inset (absolute positioning offsets) as a JsRect<JsLengthPercentageAuto>.
-   * Only effective when position is Absolute.
-   * Defines the distance from each edge of the containing block.
+   * Gets the human-readable error message
+   *
+   * @returns - A string describing what went wrong.
+   *
+   * @remarks
+   * Examples:
+   * - "Node with id 1234 is not present in the Taffy tree"
+   * - "Index 5 is out of bounds for node with 3 children"
    */
-  inset: any;
+  readonly message: string;
 }
 
+/**
+ * The main layout tree class for creating nodes, computing layouts, and managing a tree of styled elements.
+ *
+ * TaffyTree is the entry point for the Taffy layout engine. It manages
+ * a tree of nodes and computes their layouts using CSS Flexbox and Grid algorithms.
+ *
+ */
 export class TaffyTree {
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Marks a node as dirty, requiring re-layout.
-   * 
-   * Call this when a node's content changes (e.g., text content)
-   * but its style hasn't. Style changes automatically mark nodes dirty.
-   * 
-   * # Arguments
-   * * `node` - The node ID to mark dirty.
+   * Marks a node as dirty (requiring re-layout)
+   *
+   * Use this when a node's content has changed but its style hasn't.
+   * For example, when text content changes and needs remeasuring.
+   *
+   * @param node - The node ID to mark dirty
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * // After updating text content
+   * tree.setNodeContext(nodeId, { text: "Updated text" });
+   * tree.markDirty(nodeId);
+   * tree.computeLayout(rootId, availableSpace);
+   * ```
    */
   markDirty(node: bigint): void;
   /**
-   * Prints the tree structure to the console (for debugging).
-   * 
-   * # Arguments
-   * * `node` - The root node ID to start printing from.
+   * Prints the tree structure to the console (for debugging)
+   *
+   * Outputs a text representation of the tree structure starting from
+   * the given node. Useful for debugging layout issues.
+   *
+   * @param node - The root node ID to print from
+   *
+   * @example
+   * ```typescript
+   * tree.printTree(rootId);
+   * // Output appears in browser console
+   * ```
    */
   printTree(node: bigint): void;
   /**
-   * Gets the number of children of a node.
-   * 
-   * # Arguments
-   * * `parent` - The parent node ID.
-   * 
-   * # Returns
-   * The number of children.
+   * Gets the number of children of a node
+   *
+   * @param parent - The parent node ID
+   *
+   * @returns - The number of direct children
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * const count: number = tree.childCount(parentId);
+   * ```
    */
   childCount(parent: bigint): number;
   /**
-   * Removes a specific child from a parent.
-   * 
-   * # Arguments
-   * * `parent` - The parent node ID.
-   * * `child` - The child node ID to remove.
-   * 
-   * # Returns
-   * * `Ok(u64)` - The ID of the removed child.
-   * * `Err(JsValue)` - Error if parent or child doesn't exist.
+   * Removes a specific child from a parent
+   *
+   * @param parent - The parent node ID
+   * @param child - The child node ID to remove
+   *
+   * @returns - The removed child ID (`bigint`)
+   *
+   * @throws `TaffyError` if the parent or child node does not exist
+   *
+   * @example
+   * ```typescript
+   * tree.removeChild(parentId, childId);
+   * ```
    */
   removeChild(parent: bigint, child: bigint): bigint;
   /**
-   * Replaces all children of a node.
-   * 
-   * Previous children are detached but not removed from the tree.
-   * 
-   * # Arguments
-   * * `parent` - The parent node ID.
-   * * `children` - Array of new child node IDs.
+   * Replaces all children of a node
+   *
+   * Any existing children are removed and replaced with the new array.
+   *
+   * @param parent - The parent node ID
+   * @param children - Array of new child node IDs
+   *
+   * @throws `TaffyError` if the parent node does not exist
+   *
+   * @example
+   * ```typescript
+   * const children = BigUint64Array.from([child1, child2, child3]);
+   * tree.setChildren(parentId, children);
+   * ```
    */
   setChildren(parent: bigint, children: BigUint64Array): void;
   /**
-   * Creates a new TaffyTree with pre-allocated capacity.
-   * 
-   * Use this when you know approximately how many nodes you'll create
-   * to avoid reallocation overhead.
-   * 
-   * # Arguments
-   * * `capacity` - The number of nodes to pre-allocate space for.
-   * 
-   * # Returns
-   * A new TaffyTree instance with pre-allocated capacity.
+   * Creates a new TaffyTree with pre-allocated capacity
+   *
+   * Use this when you know approximately how many nodes will be in the tree.
+   * This can improve performance by reducing memory reallocations.
+   *
+   * @param capacity - The number of nodes to pre-allocate space for
+   *
+   * @example
+   * ```typescript
+   * const tree: TaffyTree = TaffyTree.withCapacity(1000);
+   * ```
    */
   static withCapacity(capacity: number): TaffyTree;
   /**
-   * Gets a child at a specific index.
-   * 
-   * # Arguments
-   * * `parent` - The parent node ID.
-   * * `index` - The zero-based index.
-   * 
-   * # Returns
-   * * `Ok(u64)` - The child node ID at the given index.
-   * * `Err(JsValue)` - Error if index is out of bounds.
+   * Computes the layout for a subtree
+   *
+   * This is the main layout computation method. Call this on the root node
+   * to compute layouts for all nodes in the tree.
+   *
+   * @param node - The root node ID to compute layout for
+   * @param available_space - The available space constraints
+   *
+   * @example
+   * ```typescript
+   * // Fixed size container
+   * { width: { Definite: 800 }, height: { Definite: 600 } }
+   *
+   * // Flexible width, fixed height
+   * { width: "MaxContent", height: { Definite: 600 } }
+   *
+   * // Minimum content size
+   * { width: "MinContent", height: "MinContent" }
+   * ```
+   *
+   * @throws `TaffyError` if the node does not exist or available space is invalid
+   *
+   * @example
+   * ```typescript
+   * tree.computeLayout(rootId, { width: { Definite: 800 }, height: { Definite: 600 } });
+   * ```
    */
-  getChildAtIndex(parent: bigint, index: number): bigint;
+  computeLayout(node: bigint, available_space: Size<AvailableSpace>): void;
   /**
-   * Computes the layout for a subtree.
-   * 
-   * Runs the layout algorithm (Flexbox/Grid/Block) on the given node
-   * and all its descendants. Results are cached and can be retrieved
-   * with `getLayout()`.
-   * 
-   * # Arguments
-   * * `node` - The root node ID for layout computation.
-   * * `available_space` - The available space constraint, e.g.:
-   *   `{ width: { Definite: 800 }, height: { Definite: 600 } }`
-   *   
-   * Available space options per dimension:
-   * - `{ Definite: number }` - A specific size in pixels
-   * - `"MinContent"` - Use minimum content size
-   * - `"MaxContent"` - Use maximum content size
-   */
-  computeLayout(node: bigint, available_space: any): void;
-  /**
-   * Enables rounding of layout values to whole pixels.
-   * 
-   * When enabled, all computed layout values (x, y, width, height) are
-   * rounded to the nearest integer. This is the default behavior.
+   * Enables rounding of layout values to whole pixels
+   *
+   * When enabled (default), computed layout values like position and size
+   * are rounded to the nearest integer. This prevents sub-pixel rendering
+   * issues in most rendering contexts.
+   *
+   * @example
+   * ```typescript
+   * tree.enableRounding();
+   * ```
    */
   enableRounding(): void;
   /**
-   * Disables rounding of layout values.
-   * 
-   * When disabled, layout values may have fractional pixel values.
-   * Use `unroundedLayout()` to get the pre-rounding values.
+   * Disables rounding of layout values
+   *
+   * When disabled, computed layout values retain their fractional precision.
+   * Use this when you need sub-pixel accuracy or when performing custom
+   * rounding.
+   *
+   * @example
+   * ```typescript
+   * tree.disableRounding();
+   * const layout = tree.getLayout(node);
+   * console.log(layout.x);
+   * ```
    */
   disableRounding(): void;
   /**
-   * Gets the context value for a node.
-   * 
-   * # Arguments
-   * * `node` - The node ID.
-   * 
-   * # Returns
-   * The context value, or `undefined` if not set.
+   * Gets the context value for a node
+   *
+   * @param node - The node ID
+   *
+   * @returns - The attached context value, or `undefined` if none is set
+   *
+   * @example
+   * ```typescript
+   * interface Context { text: string };
+   * const context = tree.getNodeContext(nodeId) as Context | undefined;
+   * if (context) {
+   *   console.log(context.text);
+   * }
+   * ```
    */
   getNodeContext(node: bigint): any;
   /**
-   * Sets a context value for a node.
-   * 
-   * Context values are passed to the measure function during layout.
-   * Use this to attach data like text content or custom metadata.
-   * 
-   * # Arguments
-   * * `node` - The node ID.
-   * * `context` - Any JavaScript value.
+   * Sets a context value for a node
+   *
+   * The context can be any JavaScript value and is passed to the measure
+   * function during layout computation.
+   *
+   * @param node - The node ID
+   * @param context - Any JavaScript value to attach
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * interface Context { text: string };
+   * tree.setNodeContext(nodeId, { text: "Updated text" } as Context);
+   * ```
    */
   setNodeContext(node: bigint, context: any): void;
   /**
-   * Gets the total number of nodes in the tree.
-   * 
-   * # Returns
-   * The count of all nodes (including removed nodes that haven't been reclaimed).
+   * Gets the total number of nodes in the tree
+   *
+   * @returns - The total count of all nodes
+   *
+   * @example
+   * ```typescript
+   * const count: number = tree.totalNodeCount();
+   * ```
    */
   totalNodeCount(): number;
   /**
-   * Gets the unrounded (fractional) layout for a node.
-   * 
+   * Gets the unrounded (fractional) layout for a node
+   *
+   * Returns the raw computed values before any rounding is applied.
    * Useful when you need sub-pixel precision.
-   * 
-   * # Arguments
-   * * `node` - The node ID to query.
-   * 
-   * # Returns
-   * A layout object with potentially fractional values.
-   */
-  unroundedLayout(node: bigint): any;
-  /**
-   * Creates a new node with the given children.
-   * 
-   * # Arguments
-   * * `style` - The Style object to apply to this node.
-   * * `children` - Array of child node IDs.
-   * 
-   * # Returns
-   * * `Ok(u64)` - The node ID of the newly created node.
-   * * `Err(JsValue)` - Error message if creation fails.
+   *
+   * @param node - The node ID
+   *
+   * @returns - The unrounded `Layout`
+   *
+   * @example
+   * ```typescript
+   * const layout: Layout = tree.unroundedLayout(nodeId);
+   * console.log(`Exact width: ${layout.width}`);
+   * ```
+   */
+  unroundedLayout(node: bigint): Layout;
+  /**
+   * Creates a new node with the given children
+   *
+   * Use this to create container nodes that have child elements.
+   * The children must already exist in the tree.
+   *
+   * @param style - The style configuration for the node
+   * @param children - Array of child node IDs (as BigUint64Array)
+   *
+   * @returns - The node ID (`bigint`)
+   *
+   * @throws `TaffyError` if the node cannot be created
+   *
+   * @example
+   * ```typescript
+   * const containerStyle = new Style();
+   * containerStyle.display = Display.Flex;
+   *
+   * const child1: bigint = tree.newLeaf(new Style());
+   * const child2: bigint = tree.newLeaf(new Style());
+   *
+   * const container: bigint = tree.newWithChildren(
+   *   containerStyle,
+   *   BigUint64Array.from([child1, child2])
+   * );
+   * ```
    */
   newWithChildren(style: Style, children: BigUint64Array): bigint;
   /**
-   * Gets a mutable reference to the context value for a node.
-   * 
-   * Note: In WASM, this returns a clone since we can't return mutable references.
-   * 
-   * # Arguments
-   * * `node` - The node ID.
-   * 
-   * # Returns
-   * The context value, or `undefined` if not set.
+   * Gets the child at a specific index
+   *
+   * @param parent - The parent node ID
+   * @param index - The index of the child (0-based)
+   *
+   * @returns - The child node ID (`bigint`)
+   *
+   * @throws `TaffyError` if the parent node does not exist or index is out of bounds
+   *
+   * @example
+   * ```typescript
+   * const firstChild: bigint = tree.getChildAtIndex(parentId, 0);
+   * ```
+   */
+  getChildAtIndex(parent: bigint, index: number): bigint;
+  /**
+   * Gets a mutable reference to the context value for a node
+   *
+   * In JavaScript, this behaves the same as `getNodeContext()` since
+   * JavaScript objects are always passed by reference.
+   *
+   * @param node - The node ID
+   *
+   * @returns - The attached context value, or `undefined` if none is set
    */
   getNodeContextMut(node: bigint): any;
   /**
-   * Inserts a child at a specific index.
-   * 
-   * Existing children at and after the index are shifted right.
-   * 
-   * # Arguments
-   * * `parent` - The parent node ID.
-   * * `index` - The zero-based index at which to insert.
-   * * `child` - The child node ID to insert.
+   * Inserts a child at a specific index
+   *
+   * @param parent - The parent node ID
+   * @param index - The position to insert at (0-based)
+   * @param child - The child node ID to insert
+   *
+   * @throws `TaffyError` if the parent or child node does not exist, or index is out of bounds
+   *
+   * @example
+   * ```typescript
+   * tree.insertChildAtIndex(parentId, 0, childId);
+   * ```
    */
   insertChildAtIndex(parent: bigint, index: number, child: bigint): void;
   /**
-   * Creates a new leaf node with an attached context value.
-   * 
-   * The context can be any JavaScript value and is useful for associating
-   * custom data (like text content) with a node for use in measure functions.
-   * 
-   * # Arguments
-   * * `style` - The Style object to apply to this node.
-   * * `context` - Any JavaScript value to attach to this node.
-   * 
-   * # Returns
-   * * `Ok(u64)` - The node ID of the newly created node.
-   * * `Err(JsValue)` - Error message if creation fails.
+   * Creates a new leaf node with an attached context value
+   *
+   * The context can be any JavaScript value and is passed to the measure
+   * function during layout computation. This is useful for storing
+   * references to text content or other dynamic data.
+   *
+   * @param style - The style configuration for the node
+   * @param context - Any JavaScript value to attach to the node
+   * @returns - The node ID (`bigint`)
+   * @throws `TaffyError` if the node cannot be created
+   *
+   * @example
+   * ```typescript
+   * interface TextContext { text: string; isBold: boolean; }
+   *
+   * const style = new Style();
+   * const context: TextContext = { text: "Hello, World!", isBold: true };
+   * const nodeId: bigint = tree.newLeafWithContext(style, context);
+   * ```
    */
   newLeafWithContext(style: Style, context: any): bigint;
   /**
-   * Removes a child at a specific index.
-   * 
-   * # Arguments
-   * * `parent` - The parent node ID.
-   * * `index` - The zero-based index of the child to remove.
-   * 
-   * # Returns
-   * * `Ok(u64)` - The ID of the removed child.
-   * * `Err(JsValue)` - Error if index is out of bounds.
+   * Removes a child at a specific index
+   *
+   * @param parent - The parent node ID
+   * @param index - The index of the child to remove (0-based)
+   *
+   * @returns - The removed child ID (`bigint`)
+   *
+   * @throws `TaffyError` if the parent node does not exist or index is out of bounds
+   *
+   * @example
+   * ```typescript
+   * const removedId: bigint = tree.removeChildAtIndex(parentId, 0);
+   * ```
    */
   removeChildAtIndex(parent: bigint, index: number): bigint;
   /**
-   * Removes a range of children from a parent.
-   * 
-   * # Arguments
-   * * `parent` - The parent node ID.
-   * * `start` - The start index (inclusive).
-   * * `end` - The end index (exclusive).
-   */
-  removeChildrenRange(parent: bigint, start: number, end: number): void;
-  /**
-   * Replaces a child at a specific index with a new child.
-   * 
-   * # Arguments
-   * * `parent` - The parent node ID.
-   * * `index` - The zero-based index of the child to replace.
-   * * `child` - The new child node ID.
-   * 
-   * # Returns
-   * * `Ok(u64)` - The ID of the replaced (old) child.
-   * * `Err(JsValue)` - Error if index is out of bounds.
-   */
-  replaceChildAtIndex(parent: bigint, index: number, child: bigint): bigint;
-  /**
-   * Computes layout with a custom measure function for leaf nodes.
-   * 
-   * The measure function is called for leaf nodes to determine their
-   * intrinsic size (e.g., for text measurement).
-   * 
-   * # Arguments
-   * * `node` - The root node ID for layout computation.
-   * * `available_space` - The available space constraint.
-   * * `measure_func` - A JavaScript function with signature:
-   *   `(knownDimensions, availableSpace, context) => { width, height }`
-   *   
-   * The measure function receives:
-   * - `knownDimensions`: `{ width: number | null, height: number | null }`
-   * - `availableSpace`: `{ width: AvailableSpace, height: AvailableSpace }`
-   * - `context`: The context value attached to the node (or undefined)
-   * 
-   * And should return: `{ width: number, height: number }`
-   */
-  computeLayoutWithMeasure(node: bigint, available_space: any, measure_func: Function): void;
-  /**
-   * Gets context values for multiple nodes at once.
-   * 
-   * Useful for batch operations.
-   * 
-   * # Arguments
-   * * `children` - Array of node IDs to query.
-   * 
-   * # Returns
-   * Array of context values in the same order as input.
+   * Removes a range of children
+   *
+   * Removes children from `start_index` (inclusive) to `end_index` (exclusive).
+   *
+   * @param parent - The parent node ID
+   * @param start_index - Start of range (inclusive)
+   * @param end_index - End of range (exclusive)
+   *
+   * @throws `TaffyError` if the parent node does not exist or range is invalid
+   *
+   * @example
+   * ```typescript
+   * tree.removeChildrenRange(parentId, 1, 3);
+   * ```
+   */
+  removeChildrenRange(
+    parent: bigint,
+    start_index: number,
+    end_index: number,
+  ): void;
+  /**
+   * Replaces a child at a specific index
+   *
+   * @param parent - The parent node ID
+   * @param index - The index of the child to replace (0-based)
+   * @param new_child - The new child node ID
+   *
+   * @returns - The replaced (old) child ID (`bigint`)
+   *
+   * @throws `TaffyError` if the parent node does not exist or index is out of bounds
+   *
+   * @example
+   * ```typescript
+   * const oldChildId: bigint = tree.replaceChildAtIndex(parentId, 1, newChildId);
+   * ```
+   */
+  replaceChildAtIndex(parent: bigint, index: number, new_child: bigint): bigint;
+  /**
+   * Computes layout with a custom measure function for leaf nodes
+   *
+   * Use this when you have leaf nodes with dynamic content (like text)
+   * that needs to be measured during layout. The measure function is
+   * called for each leaf node that needs measurement.
+   *
+   * @param node - The root node ID to compute layout for
+   * @param available_space - The available space constraints
+   * @param measure_func - A function that measures leaf node content
+   *
+   * @throws `TaffyError` if the node does not exist or available space is invalid
+   *
+   * @example
+   * ```typescript
+   * tree.computeLayoutWithMeasure(
+   *   rootId,
+   *   { width: { Definite: 800 }, height: "MaxContent" },
+   *   (known, available, node, context, style) => {
+   *     if (context?.text) {
+   *       const measured = measureText(context.text, available.width);
+   *       return { width: measured.width, height: measured.height };
+   *     }
+   *     return { width: 0, height: 0 };
+   *   }
+   * );
+   * ```
+   */
+  computeLayoutWithMeasure(
+    node: bigint,
+    available_space: Size<AvailableSpace>,
+    measure_func: MeasureFunction,
+  ): void;
+  /**
+   * Gets context values for multiple nodes at once
+   *
+   * This is more efficient than calling `getNodeContext()` multiple times
+   * when you need to access contexts for many nodes.
+   *
+   * @param children - Array of node IDs
+   *
+   * @returns - Array of context values (undefined for nodes without context)
+   *
+   * @example
+   * ```typescript
+   * const nodes = BigUint64Array.from([id1, id2]);
+   * const contexts = tree.getDisjointNodeContextMut(nodes);
+   * ```
    */
   getDisjointNodeContextMut(children: BigUint64Array): any[];
   /**
-   * Creates a new empty TaffyTree.
-   * 
-   * This is the primary constructor. Initializes panic hook in debug builds
-   * to provide better error messages in the browser console.
-   * 
-   * # Returns
-   * A new TaffyTree instance with no nodes.
+   * Creates a new empty TaffyTree
+   *
+   * The tree starts with no nodes. Use `newLeaf()` or `newWithChildren()`
+   * to add nodes.
+   *
+   * @example
+   * ```typescript
+   * const tree: TaffyTree = new TaffyTree();
+   * ```
    */
   constructor();
   /**
-   * Removes all nodes from the tree.
-   * 
-   * After calling this, the tree is empty and all previous node IDs are invalid.
+   * Removes all nodes from the tree
+   *
+   * This clears the entire tree, removing all nodes and their relationships.
+   * Use this to reset the tree for reuse.
+   *
+   * @example
+   * ```typescript
+   * tree.clear();
+   * console.log(tree.totalNodeCount());
+   * ```
    */
   clear(): void;
   /**
-   * Checks if a node is dirty (needs re-layout).
-   * 
-   * # Arguments
-   * * `node` - The node ID to check.
-   * 
-   * # Returns
-   * * `Ok(true)` - The node needs re-layout.
-   * * `Ok(false)` - The node's layout is up-to-date.
-   * * `Err(JsValue)` - Error if the node doesn't exist.
+   * Checks if a node is dirty (needs re-layout)
+   *
+   * A node is dirty if its style or content has changed since the last
+   * layout computation.
+   *
+   * @param node - The node ID to check
+   *
+   * @returns - true if dirty, false otherwise
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * if (tree.dirty(nodeId)) {
+   *   tree.computeLayout(rootId, availableSpace);
+   * }
+   * ```
    */
   dirty(node: bigint): boolean;
   /**
-   * Gets the style for a node.
-   * 
-   * # Arguments
-   * * `node` - The node ID to query.
-   * 
-   * # Returns
-   * * `Ok(Style)` - A copy of the node's style.
-   * * `Err(JsValue)` - Error if the node doesn't exist.
+   * Gets the style for a node
+   *
+   * @param node - The node ID
+   *
+   * @returns - The node's `Style`
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * const style: Style = tree.getStyle(nodeId);
+   * console.log('Flex grow:', style.flexGrow);
+   * ```
    */
   getStyle(node: bigint): Style;
   /**
-   * Gets the computed layout for a node.
-   * 
-   * Must be called after `computeLayout()`.
-   * 
-   * # Arguments
-   * * `node` - The node ID to query.
-   * 
-   * # Returns
-   * A layout object: `{ order, size: {width, height}, location: {x, y}, ... }`
-   */
-  getLayout(node: bigint): any;
-  /**
-   * Gets the parent of a node.
-   * 
-   * # Arguments
-   * * `child` - The child node ID.
-   * 
-   * # Returns
-   * * `Some(u64)` - The parent node ID.
-   * * `None` - If the node has no parent (is a root).
+   * Gets the computed layout for a node
+   *
+   * Call this after `computeLayout()` to retrieve the computed position
+   * and size for a node.
+   *
+   * @param node - The node ID
+   *
+   * @returns - The computed `Layout`
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * tree.computeLayout(rootId, { width: { Definite: 800 }, height: { Definite: 600 } });
+   * const layout: Layout = tree.getLayout(nodeId);
+   * console.log(`Position: (${layout.x}, ${layout.y}), Size: ${layout.width}x${layout.height}`);
+   * ```
+   */
+  getLayout(node: bigint): Layout;
+  /**
+   * Gets the parent of a node
+   *
+   * @param child - The child node ID
+   *
+   * @returns - The parent node ID, or `undefined` if the node has no parent
+   *
+   * @example
+   * ```typescript
+   * const parentId: bigint | undefined = tree.parent(childId);
+   * ```
    */
   parent(child: bigint): bigint | undefined;
   /**
-   * Removes a node from the tree.
-   * 
-   * The node is detached from its parent (if any) and removed from the tree.
-   * Child nodes are NOT automatically removed.
-   * 
-   * # Arguments
-   * * `node` - The node ID to remove.
-   * 
-   * # Returns
-   * * `Ok(u64)` - The ID of the removed node.
-   * * `Err(JsValue)` - Error if the node doesn't exist.
+   * Removes a node from the tree
+   *
+   * The node and all its descendants are removed. If the node has a parent,
+   * it is automatically removed from the parent's children.
+   *
+   * @param node - The node ID to remove
+   *
+   * @returns - The removed node ID (`bigint`)
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   const removedId: bigint = tree.remove(nodeId);
+   * } catch (e) {
+   *   console.error("Node doesn't exist");
+   * }
+   * ```
    */
   remove(node: bigint): bigint;
   /**
-   * Gets all children of a node.
-   * 
-   * # Arguments
-   * * `parent` - The parent node ID.
-   * 
-   * # Returns
-   * * `Ok(Box<[u64]>)` - Array of child node IDs.
-   * * `Err(JsValue)` - Error if the node doesn't exist.
+   * Gets all children of a node
+   *
+   * @param parent - The parent node ID
+   *
+   * @returns - Array of child node IDs (`BigUint64Array`)
+   *
+   * @throws `TaffyError` if the parent node does not exist
+   *
+   * @example
+   * ```typescript
+   * const children: BigUint64Array = tree.children(parentId);
+   * ```
    */
   children(parent: bigint): BigUint64Array;
   /**
-   * Creates a new leaf node (no children) with the given style.
-   * 
-   * # Arguments
-   * * `style` - The Style object to apply to this node.
-   * 
-   * # Returns
-   * * `Ok(u64)` - The node ID of the newly created node.
-   * * `Err(JsValue)` - Error message if creation fails.
+   * Creates a new leaf node with the given style
+   *
+   * A leaf node has no children. Use this for elements that contain
+   * content (like text) rather than other elements.
+   *
+   * @param style - The style configuration for the node
+   * @returns - The node ID (`bigint`)
+   * @throws `TaffyError` if the node cannot be created
+   *
+   * @example
+   * ```typescript
+   * const style = new Style();
+   * style.size = { width: { Length: 100 }, height: { Length: 50 } };
+   * const nodeId: bigint = tree.newLeaf(style);
+   * ```
    */
   newLeaf(style: Style): bigint;
   /**
-   * Appends a child node to a parent.
-   * 
-   * The child is added at the end of the parent's children list.
-   * 
-   * # Arguments
-   * * `parent` - The parent node ID.
-   * * `child` - The child node ID to add.
+   * Appends a child node to a parent
+   *
+   * The child is added as the last child of the parent.
+   *
+   * @param parent - The parent node ID
+   * @param child - The child node ID to add
+   *
+   * @throws `TaffyError` if the parent or child node does not exist
+   *
+   * @example
+   * ```typescript
+   * tree.addChild(parentId, childId);
+   * ```
    */
   addChild(parent: bigint, child: bigint): void;
   /**
-   * Sets the style for an existing node.
-   * 
-   * This will mark the node and its ancestors as dirty, triggering
-   * a re-layout on the next `computeLayout()` call.
-   * 
-   * # Arguments
-   * * `node` - The node ID to update.
-   * * `style` - The new Style to apply.
+   * Sets the style for an existing node
+   *
+   * This replaces the node's current style with the provided one.
+   * The node will be marked as dirty and require re-layout.
+   *
+   * @param node - The node ID
+   * @param style - The new style configuration
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * const newStyle = new Style();
+   * newStyle.flexGrow = 2;
+   * tree.setStyle(nodeId, newStyle);
+   * ```
    */
   setStyle(node: bigint, style: Style): void;
 }
 
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+export type InitInput =
+  | RequestInfo
+  | URL
+  | Response
+  | BufferSource
+  | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_layout_free: (a: number, b: number) => void;
   readonly __wbg_style_free: (a: number, b: number) => void;
+  readonly __wbg_taffyerror_free: (a: number, b: number) => void;
   readonly __wbg_taffytree_free: (a: number, b: number) => void;
-  readonly style_align_content: (a: number) => number;
-  readonly style_align_items: (a: number) => number;
-  readonly style_align_self: (a: number) => number;
-  readonly style_aspect_ratio: (a: number) => number;
+  readonly layout_borderBottom: (a: number) => number;
+  readonly layout_borderLeft: (a: number) => number;
+  readonly layout_borderRight: (a: number) => number;
+  readonly layout_borderTop: (a: number) => number;
+  readonly layout_contentHeight: (a: number) => number;
+  readonly layout_contentWidth: (a: number) => number;
+  readonly layout_height: (a: number) => number;
+  readonly layout_marginBottom: (a: number) => number;
+  readonly layout_marginLeft: (a: number) => number;
+  readonly layout_marginRight: (a: number) => number;
+  readonly layout_marginTop: (a: number) => number;
+  readonly layout_order: (a: number) => number;
+  readonly layout_paddingBottom: (a: number) => number;
+  readonly layout_paddingLeft: (a: number) => number;
+  readonly layout_paddingRight: (a: number) => number;
+  readonly layout_paddingTop: (a: number) => number;
+  readonly layout_scrollbarHeight: (a: number) => number;
+  readonly layout_scrollbarWidth: (a: number) => number;
+  readonly layout_width: (a: number) => number;
+  readonly layout_x: (a: number) => number;
+  readonly layout_y: (a: number) => number;
+  readonly style_alignContent: (a: number) => number;
+  readonly style_alignItems: (a: number) => number;
+  readonly style_alignSelf: (a: number) => number;
+  readonly style_aspectRatio: (a: number) => number;
   readonly style_border: (a: number) => any;
-  readonly style_box_sizing: (a: number) => number;
+  readonly style_boxSizing: (a: number) => number;
   readonly style_display: (a: number) => number;
-  readonly style_flex_basis: (a: number) => any;
-  readonly style_flex_direction: (a: number) => number;
-  readonly style_flex_grow: (a: number) => number;
-  readonly style_flex_shrink: (a: number) => number;
-  readonly style_flex_wrap: (a: number) => number;
+  readonly style_flexBasis: (a: number) => any;
+  readonly style_flexDirection: (a: number) => number;
+  readonly style_flexGrow: (a: number) => number;
+  readonly style_flexShrink: (a: number) => number;
+  readonly style_flexWrap: (a: number) => number;
   readonly style_gap: (a: number) => any;
   readonly style_inset: (a: number) => any;
-  readonly style_justify_content: (a: number) => number;
+  readonly style_justifyContent: (a: number) => number;
   readonly style_margin: (a: number) => any;
-  readonly style_max_size: (a: number) => any;
-  readonly style_min_size: (a: number) => any;
+  readonly style_maxSize: (a: number) => any;
+  readonly style_minSize: (a: number) => any;
   readonly style_new: () => number;
   readonly style_overflow: (a: number) => any;
   readonly style_padding: (a: number) => any;
   readonly style_position: (a: number) => number;
-  readonly style_set_align_content: (a: number, b: number) => void;
-  readonly style_set_align_items: (a: number, b: number) => void;
-  readonly style_set_align_self: (a: number, b: number) => void;
-  readonly style_set_aspect_ratio: (a: number, b: number) => void;
+  readonly style_set_alignContent: (a: number, b: any) => void;
+  readonly style_set_alignItems: (a: number, b: any) => void;
+  readonly style_set_alignSelf: (a: number, b: any) => void;
+  readonly style_set_aspectRatio: (a: number, b: any) => void;
   readonly style_set_border: (a: number, b: any) => void;
-  readonly style_set_box_sizing: (a: number, b: number) => void;
+  readonly style_set_boxSizing: (a: number, b: number) => void;
   readonly style_set_display: (a: number, b: number) => void;
-  readonly style_set_flex_basis: (a: number, b: any) => void;
-  readonly style_set_flex_direction: (a: number, b: number) => void;
-  readonly style_set_flex_grow: (a: number, b: number) => void;
-  readonly style_set_flex_shrink: (a: number, b: number) => void;
-  readonly style_set_flex_wrap: (a: number, b: number) => void;
+  readonly style_set_flexBasis: (a: number, b: any) => void;
+  readonly style_set_flexDirection: (a: number, b: number) => void;
+  readonly style_set_flexGrow: (a: number, b: number) => void;
+  readonly style_set_flexShrink: (a: number, b: number) => void;
+  readonly style_set_flexWrap: (a: number, b: number) => void;
   readonly style_set_gap: (a: number, b: any) => void;
   readonly style_set_inset: (a: number, b: any) => void;
-  readonly style_set_justify_content: (a: number, b: number) => void;
+  readonly style_set_justifyContent: (a: number, b: any) => void;
   readonly style_set_margin: (a: number, b: any) => void;
-  readonly style_set_max_size: (a: number, b: any) => void;
-  readonly style_set_min_size: (a: number, b: any) => void;
+  readonly style_set_maxSize: (a: number, b: any) => void;
+  readonly style_set_minSize: (a: number, b: any) => void;
   readonly style_set_overflow: (a: number, b: any) => void;
   readonly style_set_padding: (a: number, b: any) => void;
   readonly style_set_position: (a: number, b: number) => void;
   readonly style_set_size: (a: number, b: any) => void;
   readonly style_size: (a: number) => any;
-  readonly taffytree_addChild: (a: number, b: bigint, c: bigint) => [number, number];
+  readonly taffyerror_message: (a: number) => [number, number];
+  readonly taffytree_addChild: (
+    a: number,
+    b: bigint,
+    c: bigint,
+  ) => [number, number];
   readonly taffytree_childCount: (a: number, b: bigint) => number;
-  readonly taffytree_children: (a: number, b: bigint) => [number, number, number, number];
+  readonly taffytree_children: (
+    a: number,
+    b: bigint,
+  ) => [number, number, number, number];
   readonly taffytree_clear: (a: number) => void;
-  readonly taffytree_computeLayout: (a: number, b: bigint, c: any) => [number, number];
-  readonly taffytree_computeLayoutWithMeasure: (a: number, b: bigint, c: any, d: any) => [number, number];
+  readonly taffytree_computeLayout: (
+    a: number,
+    b: bigint,
+    c: any,
+  ) => [number, number];
+  readonly taffytree_computeLayoutWithMeasure: (
+    a: number,
+    b: bigint,
+    c: any,
+    d: any,
+  ) => [number, number];
   readonly taffytree_dirty: (a: number, b: bigint) => [number, number, number];
   readonly taffytree_disableRounding: (a: number) => void;
   readonly taffytree_enableRounding: (a: number) => void;
-  readonly taffytree_getChildAtIndex: (a: number, b: bigint, c: number) => [bigint, number, number];
-  readonly taffytree_getDisjointNodeContextMut: (a: number, b: number, c: number) => [number, number, number, number];
-  readonly taffytree_getLayout: (a: number, b: bigint) => [number, number, number];
-  readonly taffytree_getNodeContext: (a: number, b: bigint) => [number, number, number];
-  readonly taffytree_getNodeContextMut: (a: number, b: bigint) => [number, number, number];
-  readonly taffytree_getStyle: (a: number, b: bigint) => [number, number, number];
-  readonly taffytree_insertChildAtIndex: (a: number, b: bigint, c: number, d: bigint) => [number, number];
+  readonly taffytree_getChildAtIndex: (
+    a: number,
+    b: bigint,
+    c: number,
+  ) => [bigint, number, number];
+  readonly taffytree_getDisjointNodeContextMut: (
+    a: number,
+    b: number,
+    c: number,
+  ) => [number, number, number, number];
+  readonly taffytree_getLayout: (
+    a: number,
+    b: bigint,
+  ) => [number, number, number];
+  readonly taffytree_getNodeContext: (
+    a: number,
+    b: bigint,
+  ) => [number, number, number];
+  readonly taffytree_getNodeContextMut: (
+    a: number,
+    b: bigint,
+  ) => [number, number, number];
+  readonly taffytree_getStyle: (
+    a: number,
+    b: bigint,
+  ) => [number, number, number];
+  readonly taffytree_insertChildAtIndex: (
+    a: number,
+    b: bigint,
+    c: number,
+    d: bigint,
+  ) => [number, number];
   readonly taffytree_markDirty: (a: number, b: bigint) => [number, number];
   readonly taffytree_new: () => number;
-  readonly taffytree_newLeaf: (a: number, b: number) => [bigint, number, number];
-  readonly taffytree_newLeafWithContext: (a: number, b: number, c: any) => [bigint, number, number];
-  readonly taffytree_newWithChildren: (a: number, b: number, c: number, d: number) => [bigint, number, number];
+  readonly taffytree_newLeaf: (
+    a: number,
+    b: number,
+  ) => [bigint, number, number];
+  readonly taffytree_newLeafWithContext: (
+    a: number,
+    b: number,
+    c: any,
+  ) => [bigint, number, number];
+  readonly taffytree_newWithChildren: (
+    a: number,
+    b: number,
+    c: number,
+    d: number,
+  ) => [bigint, number, number];
   readonly taffytree_parent: (a: number, b: bigint) => [number, bigint];
   readonly taffytree_printTree: (a: number, b: bigint) => void;
   readonly taffytree_remove: (a: number, b: bigint) => [bigint, number, number];
-  readonly taffytree_removeChild: (a: number, b: bigint, c: bigint) => [bigint, number, number];
-  readonly taffytree_removeChildAtIndex: (a: number, b: bigint, c: number) => [bigint, number, number];
-  readonly taffytree_removeChildrenRange: (a: number, b: bigint, c: number, d: number) => [number, number];
-  readonly taffytree_replaceChildAtIndex: (a: number, b: bigint, c: number, d: bigint) => [bigint, number, number];
-  readonly taffytree_setChildren: (a: number, b: bigint, c: number, d: number) => [number, number];
-  readonly taffytree_setNodeContext: (a: number, b: bigint, c: any) => [number, number];
-  readonly taffytree_setStyle: (a: number, b: bigint, c: number) => [number, number];
+  readonly taffytree_removeChild: (
+    a: number,
+    b: bigint,
+    c: bigint,
+  ) => [bigint, number, number];
+  readonly taffytree_removeChildAtIndex: (
+    a: number,
+    b: bigint,
+    c: number,
+  ) => [bigint, number, number];
+  readonly taffytree_removeChildrenRange: (
+    a: number,
+    b: bigint,
+    c: number,
+    d: number,
+  ) => [number, number];
+  readonly taffytree_replaceChildAtIndex: (
+    a: number,
+    b: bigint,
+    c: number,
+    d: bigint,
+  ) => [bigint, number, number];
+  readonly taffytree_setChildren: (
+    a: number,
+    b: bigint,
+    c: number,
+    d: number,
+  ) => [number, number];
+  readonly taffytree_setNodeContext: (
+    a: number,
+    b: bigint,
+    c: any,
+  ) => [number, number];
+  readonly taffytree_setStyle: (
+    a: number,
+    b: bigint,
+    c: number,
+  ) => [number, number];
   readonly taffytree_totalNodeCount: (a: number) => number;
-  readonly taffytree_unroundedLayout: (a: number, b: bigint) => [number, number, number];
+  readonly taffytree_unroundedLayout: (a: number, b: bigint) => number;
   readonly taffytree_withCapacity: (a: number) => number;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
-  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_realloc: (
+    a: number,
+    b: number,
+    c: number,
+    d: number,
+  ) => number;
   readonly __wbindgen_exn_store: (a: number) => void;
   readonly __externref_table_alloc: () => number;
   readonly __wbindgen_externrefs: WebAssembly.Table;
@@ -826,21 +2047,28 @@ export interface InitOutput {
 export type SyncInitInput = BufferSource | WebAssembly.Module;
 
 /**
-* Instantiates the given `module`, which can either be bytes or
-* a precompiled `WebAssembly.Module`.
-*
-* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
-*
-* @returns {InitOutput}
-*/
-export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(
+  module: { module: SyncInitInput } | SyncInitInput,
+): InitOutput;
 
 /**
-* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
-* for everything else, calls `WebAssembly.instantiate` directly.
-*
-* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
-*
-* @returns {Promise<InitOutput>}
-*/
-export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init(
+  module_or_path?:
+    | { module_or_path: InitInput | Promise<InitInput> }
+    | InitInput
+    | Promise<InitInput>,
+): Promise<InitOutput>;