taffy-wasm 0.9.2 → 0.9.5

package/taffy_wasm.d.ts

@@ -2,1113 +2,1937 @@
 /* eslint-disable */
 
 /**
- * How lines of content are aligned along the cross axis when there is extra space.
+ * 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: 200,
+ *   height: "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 are packed toward the start of the cross axis.
+   * Lines packed toward the start of the cross axis
    */
   Start = 0,
   /**
-   * Lines are packed toward the end of the cross axis.
+   * Lines packed toward the end of the cross axis
    */
   End = 1,
   /**
-   * Lines are packed toward the start of the flex-direction cross axis.
+   * Lines packed toward the start of the flex container
    */
   FlexStart = 2,
   /**
-   * Lines are packed toward the end of the flex-direction cross axis.
+   * Lines packed toward the end of the flex container
    */
   FlexEnd = 3,
   /**
-   * Lines are packed toward the center of the cross axis.
+   * Lines centered within the container
    */
   Center = 4,
   /**
-   * Lines are evenly distributed; the first line is at the start, the last at the end.
+   * Lines stretched to fill the container
    */
-  SpaceBetween = 5,
+  Stretch = 5,
   /**
-   * Lines are evenly distributed with equal space around them.
+   * Lines evenly distributed with first/last at edges
    */
-  SpaceAround = 6,
+  SpaceBetween = 6,
   /**
-   * Lines are evenly distributed with equal space between them.
+   * Lines evenly distributed with equal space around each
    */
-  SpaceEvenly = 7,
+  SpaceAround = 7,
   /**
-   * Lines are stretched to take up the remaining space.
+   * Lines evenly distributed with equal space between each
    */
-  Stretch = 8,
+  SpaceEvenly = 8,
 }
 
 /**
- * How items are aligned along the cross axis.
+ * 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 are aligned at the start of the cross axis.
+   * Items aligned to the start of the cross axis
    */
   Start = 0,
   /**
-   * Items are aligned at the end of the cross axis.
+   * Items aligned to the end of the cross axis
    */
   End = 1,
   /**
-   * Items are aligned at the start of the flex-direction cross axis.
+   * Items aligned to the start of the flex container
    */
   FlexStart = 2,
   /**
-   * Items are aligned at the end of the flex-direction cross axis.
+   * Items aligned to the end of the flex container
    */
   FlexEnd = 3,
   /**
-   * Items are aligned at the center of the cross axis.
+   * Items centered along the cross axis
    */
   Center = 4,
   /**
-   * Items are aligned based on their baselines.
+   * Items aligned to their text baselines
    */
   Baseline = 5,
   /**
-   * Items are stretched to fill the container along the cross axis.
+   * Items stretched to fill the container
    */
   Stretch = 6,
 }
 
 /**
- * How a single item is aligned along the cross axis, overriding `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 {
   /**
-   * items are aligned at the start of the cross axis.
-   */
-  Start = 0,
-  /**
-   * Items are aligned at the end of the cross axis.
-   */
-  End = 1,
-  /**
-   * Items are aligned at the start of the flex-direction cross axis.
-   */
-  FlexStart = 2,
-  /**
-   * Items are aligned at the end of the flex-direction cross axis.
-   */
-  FlexEnd = 3,
-  /**
-   * Items are aligned at the center of the cross axis.
+   * Inherits the parent container's `align-items` value
    */
-  Center = 4,
+  Auto = 0,
   /**
-   * Items are aligned based on their baselines.
+   * Item aligned to the start of the cross axis
    */
-  Baseline = 5,
+  Start = 1,
   /**
-   * Items are stretched to fill the container along the cross axis.
+   * Item aligned to the end of the cross axis
    */
-  Stretch = 6,
-}
-
-export class AvailableSpace {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * The available width (None means undefined/max-content).
-   */
-  get width(): number | undefined;
+  End = 2,
   /**
-   * The available width (None means undefined/max-content).
+   * Item aligned to the start of the flex container
    */
-  set width(value: number | null | undefined);
+  FlexStart = 3,
   /**
-   * The available height (None means undefined/max-content).
+   * Item aligned to the end of the flex container
    */
-  get height(): number | undefined;
+  FlexEnd = 4,
   /**
-   * The available height (None means undefined/max-content).
+   * Item centered along the cross axis
    */
-  set height(value: number | null | undefined);
-}
-
-export class Dimension {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
+  Center = 5,
   /**
-   * The numeric value of the dimension.
-   * - For `Pixels`, this is the number of pixels.
-   * - For `Percent`, this is the percentage value (0.0 to 100.0, or sometimes 0.0 to 1.0 depending on context, handled by internal logic).
-   * - For `Auto`, this value is typically ignored.
+   * Item aligned to its text baseline
    */
-  value: number;
+  Baseline = 6,
   /**
-   * The unit of the dimension.
+   * Item stretched to fill the container
    */
-  unit: DimensionUnit;
+  Stretch = 7,
 }
 
 /**
- * The unit of a dimension.
+ * Box sizing enumeration
+ *
+ * Controls how the total width and height of an element is calculated.
+ * 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 DimensionUnit {
-  /**
-   * The dimension is specified in logical pixels.
-   */
-  Pixels = 0,
+export enum BoxSizing {
   /**
-   * The dimension is specified as a percentage of the parent's size.
+   * The width and height properties include padding and border
    */
-  Percent = 1,
+  BorderBox = 0,
   /**
-   * The dimension is determined automatically based on content or context.
+   * The width and height properties include only the content
    */
-  Auto = 2,
+  ContentBox = 1,
 }
 
 /**
- * The display style of a node.
+ * 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 {
   /**
-   * The node is hidden and does not take up space.
+   * Block-level layout where element takes the full available width
    */
-  None = 0,
+  Block = 0,
   /**
-   * The node behaves as a flex container.
+   * Flexbox layout for one-dimensional item arrangement
    */
   Flex = 1,
   /**
-   * The node behaves as a grid container.
+   * CSS Grid layout for two-dimensional item arrangement
    */
   Grid = 2,
   /**
-   * The node behaves as a block element.
+   * Element is removed from layout calculation entirely
    */
-  Block = 3,
+  None = 3,
 }
 
 /**
- * The direction of the main axis for a flex container.
+ * 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 {
   /**
-   * Items are placed horizontally from left to right.
+   * Main axis runs horizontally from left to right
    */
   Row = 0,
   /**
-   * Items are placed vertically from top to bottom.
+   * Main axis runs vertically from top to bottom
    */
   Column = 1,
   /**
-   * Items are placed horizontally from right to left.
+   * Main axis runs horizontally from right to left
    */
   RowReverse = 2,
   /**
-   * Items are placed vertically from bottom to top.
+   * Main axis runs vertically from bottom to top
    */
   ColumnReverse = 3,
 }
 
 /**
- * Whether flex items are forced into a single line or can wrap onto multiple lines.
+ * 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 {
   /**
-   * Items are forced into a single line.
+   * All flex items are placed on a single line
    */
   NoWrap = 0,
   /**
-   * Items wrap onto multiple lines.
+   * Flex items wrap onto multiple lines from top to bottom
    */
   Wrap = 1,
   /**
-   * Items wrap onto multiple lines in reverse order.
+   * Flex items wrap onto multiple lines from bottom to top
    */
   WrapReverse = 2,
 }
 
 /**
- * Grid auto-placement algorithm controls how auto-placed items get flowed into the grid.
- */
-export enum GridAutoFlow {
-  /**
-   * Items are placed by filling each row in turn, adding new rows as necessary.
-   */
-  Row = 0,
-  /**
-   * Items are placed by filling each column in turn, adding new columns as necessary.
-   */
-  Column = 1,
-  /**
-   * Items are placed by filling each row, attempting to fill holes earlier in the grid.
-   */
-  RowDense = 2,
-  /**
-   * Items are placed by filling each column, attempting to fill holes earlier in the grid.
-   */
-  ColumnDense = 3,
-}
-
-/**
- * How items are distributed along the main axis.
+ * 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 are packed toward the start of the layout direction.
+   * Items packed toward the start of the main axis
    */
   Start = 0,
   /**
-   * Items are packed toward the end of the layout direction.
+   * Items packed toward the end of the main axis
    */
   End = 1,
   /**
-   * Items are packed toward the start of the flex-direction.
+   * Items packed toward the start of the flex container
    */
   FlexStart = 2,
   /**
-   * Items are packed toward the end of the flex-direction.
+   * Items packed toward the end of the flex container
    */
   FlexEnd = 3,
   /**
-   * Items are centered along the line.
+   * Items centered along the main axis
    */
   Center = 4,
   /**
-   * Items are evenly distributed; the first item is at the start, the last at the end.
-   */
-  SpaceBetween = 5,
-  /**
-   * Items are evenly distributed with equal space around them.
-   */
-  SpaceAround = 6,
-  /**
-   * Items are evenly distributed with equal space between them using the same gap at ends.
-   */
-  SpaceEvenly = 7,
-}
-
-export class Layout {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * The absolute x-coordinate of the node relative to its parent.
-   */
-  x: number;
-  /**
-   * The absolute y-coordinate of the node relative to its parent.
-   */
-  y: number;
-  /**
-   * The computed width of the node.
-   */
-  width: number;
-  /**
-   * The computed height of the node.
-   */
-  height: number;
-}
-
-export class Line {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * The start line index (1-based).
-   */
-  get start(): number | undefined;
-  /**
-   * The start line index (1-based).
+   * Items stretched along the main axis
    */
-  set start(value: number | null | undefined);
+  Stretch = 5,
   /**
-   * The end line index (1-based).
+   * Items evenly distributed with first/last at edges
    */
-  get end(): number | undefined;
+  SpaceBetween = 6,
   /**
-   * The end line index (1-based).
+   * Items evenly distributed with equal space around each
    */
-  set end(value: number | null | undefined);
-}
-
-export class Point {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * The x-coordinate (horizontal).
-   */
-  x: number;
+  SpaceAround = 7,
   /**
-   * The y-coordinate (vertical).
+   * Items evenly distributed with equal space between each
    */
-  y: number;
+  SpaceEvenly = 8,
 }
 
 /**
- * Positioning strategy for a node.
+ * 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 enum Position {
-  /**
-   * Relative to its normal position in the flow.
-   */
-  Static = 0,
-  /**
-   * Relative to its normal position in the flow.
-   */
-  Relative = 1,
-  /**
-   * Removed from the flow and positioned relative to its containing block.
-   */
-  Absolute = 2,
-}
-
-export class Rect {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * The left edge value.
-   */
-  left: number;
-  /**
-   * The right edge value.
-   */
-  right: number;
-  /**
-   * The top edge value.
-   */
-  top: number;
-  /**
-   * The bottom edge value.
-   */
-  bottom: number;
-}
-
-export class Size {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * The width dimension.
-   */
-  width: number;
-  /**
-   * The height dimension.
-   */
-  height: number;
-}
-
-export class Style {
+export class Layout {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * The display mode of the node (e.g. Flex, Grid, None).
-   */
-  get display(): Display | undefined;
-  /**
-   * The display mode of the node (e.g. Flex, Grid, None).
-   */
-  set display(value: Display | null | undefined);
-  /**
-   * The positioning strategy (e.g. Relative, Absolute).
-   */
-  get position(): Position | undefined;
-  /**
-   * The positioning strategy (e.g. Relative, Absolute).
-   */
-  set position(value: Position | null | undefined);
-  /**
-   * The width of the node.
-   */
-  get width(): Dimension | undefined;
-  /**
-   * The width of the node.
-   */
-  set width(value: Dimension | null | undefined);
-  /**
-   * The height of the node.
-   */
-  get height(): Dimension | undefined;
-  /**
-   * The height of the node.
-   */
-  set height(value: Dimension | null | undefined);
-  /**
-   * The minimum width of the node.
-   */
-  get min_width(): Dimension | undefined;
-  /**
-   * The minimum width of the node.
-   */
-  set min_width(value: Dimension | null | undefined);
-  /**
-   * The minimum height of the node.
-   */
-  get min_height(): Dimension | undefined;
-  /**
-   * The minimum height of the node.
-   */
-  set min_height(value: Dimension | null | undefined);
-  /**
-   * The maximum width of the node.
-   */
-  get max_width(): Dimension | undefined;
-  /**
-   * The maximum width of the node.
-   */
-  set max_width(value: Dimension | null | undefined);
-  /**
-   * The maximum height of the node.
-   */
-  get max_height(): Dimension | undefined;
-  /**
-   * The maximum height of the node.
-   */
-  set max_height(value: Dimension | null | undefined);
-  /**
-   * The offset from the left edge (used with Position::Absolute/Relative).
-   */
-  get left(): Dimension | undefined;
-  /**
-   * The offset from the left edge (used with Position::Absolute/Relative).
-   */
-  set left(value: Dimension | null | undefined);
-  /**
-   * The offset from the right edge.
-   */
-  get right(): Dimension | undefined;
-  /**
-   * The offset from the right edge.
-   */
-  set right(value: Dimension | null | undefined);
-  /**
-   * The offset from the top edge.
-   */
-  get top(): Dimension | undefined;
-  /**
-   * The offset from the top edge.
-   */
-  set top(value: Dimension | null | undefined);
-  /**
-   * The offset from the bottom edge.
-   */
-  get bottom(): Dimension | undefined;
-  /**
-   * The offset from the bottom edge.
-   */
-  set bottom(value: Dimension | null | undefined);
-  /**
-   * The margin on the left side.
-   */
-  get margin_left(): Dimension | undefined;
-  /**
-   * The margin on the left side.
+   * Gets the top border width
+   *
+   * @returns - The computed top border width in pixels
    */
-  set margin_left(value: Dimension | null | undefined);
+  readonly borderTop: number;
   /**
-   * The margin on the right side.
+   * Gets the top margin
+   *
+   * @returns - The computed top margin in pixels
    */
-  get margin_right(): Dimension | undefined;
+  readonly marginTop: number;
   /**
-   * The margin on the right side.
+   * Gets the left border width
+   *
+   * @returns - The computed left border width in pixels
    */
-  set margin_right(value: Dimension | null | undefined);
+  readonly borderLeft: number;
   /**
-   * The margin on the top side.
+   * Gets the left margin
+   *
+   * @returns - The computed left margin in pixels
    */
-  get margin_top(): Dimension | undefined;
+  readonly marginLeft: number;
   /**
-   * The margin on the top side.
+   * Gets the top padding
+   *
+   * @returns - The computed top padding in pixels
    */
-  set margin_top(value: Dimension | null | undefined);
+  readonly paddingTop: number;
   /**
-   * The margin on the bottom side.
+   * Gets the right border width
+   *
+   * @returns - The computed right border width in pixels
    */
-  get margin_bottom(): Dimension | undefined;
+  readonly borderRight: number;
   /**
-   * The margin on the bottom side.
+   * Gets the right margin
+   *
+   * @returns - The computed right margin in pixels
    */
-  set margin_bottom(value: Dimension | null | undefined);
+  readonly marginRight: number;
   /**
-   * The padding on the left side.
+   * Gets the left padding
+   *
+   * @returns - The computed left padding in pixels
    */
-  get padding_left(): Dimension | undefined;
+  readonly paddingLeft: number;
   /**
-   * The padding on the left side.
+   * Gets the bottom border width
+   *
+   * @returns - The computed bottom border width in pixels
    */
-  set padding_left(value: Dimension | null | undefined);
+  readonly borderBottom: number;
   /**
-   * The padding on the right side.
+   * 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
    */
-  get padding_right(): Dimension | undefined;
+  readonly contentWidth: number;
   /**
-   * The padding on the right side.
+   * Gets the bottom margin
+   *
+   * @returns - The computed bottom margin in pixels
    */
-  set padding_right(value: Dimension | null | undefined);
+  readonly marginBottom: number;
   /**
-   * The padding on the top side.
+   * Gets the right padding
+   *
+   * @returns - The computed right padding in pixels
    */
-  get padding_top(): Dimension | undefined;
+  readonly paddingRight: number;
   /**
-   * The padding on the top side.
+   * 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
    */
-  set padding_top(value: Dimension | null | undefined);
+  readonly contentHeight: number;
   /**
-   * The padding on the bottom side.
+   * Gets the bottom padding
+   *
+   * @returns - The computed bottom padding in pixels
    */
-  get padding_bottom(): Dimension | undefined;
+  readonly paddingBottom: number;
   /**
-   * The padding on the bottom side.
+   * 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)
    */
-  set padding_bottom(value: Dimension | null | undefined);
+  readonly scrollbarWidth: number;
   /**
-   * The flex direction (e.g. Row, Column).
+   * 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)
    */
-  get flex_direction(): FlexDirection | undefined;
+  readonly scrollbarHeight: number;
   /**
-   * The flex direction (e.g. Row, Column).
+   * 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
    */
-  set flex_direction(value: FlexDirection | null | undefined);
+  readonly x: number;
   /**
-   * Whether flex items should wrap.
+   * 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
    */
-  get flex_wrap(): FlexWrap | undefined;
+  readonly y: number;
   /**
-   * Whether flex items should wrap.
+   * 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
    */
-  set flex_wrap(value: FlexWrap | null | undefined);
+  readonly order: number;
   /**
-   * How much the item will grow relative to the rest of the flexible items.
+   * 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
    */
-  get flex_grow(): number | undefined;
+  readonly width: number;
   /**
-   * How much the item will grow relative to the rest of the flexible items.
+   * 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
    */
-  set flex_grow(value: number | null | undefined);
-  /**
-   * How much the item will shrink relative to the rest of the flexible items.
-   */
-  get flex_shrink(): number | undefined;
-  /**
-   * How much the item will shrink relative to the rest of the flexible items.
-   */
-  set flex_shrink(value: number | null | undefined);
-  /**
-   * The initial main size of a flex item.
-   */
-  get flex_basis(): Dimension | undefined;
-  /**
-   * The initial main size of a flex item.
-   */
-  set flex_basis(value: Dimension | null | undefined);
-  /**
-   * How items are distributed along the main axis.
-   */
-  get justify_content(): JustifyContent | undefined;
-  /**
-   * How items are distributed along the main axis.
-   */
-  set justify_content(value: JustifyContent | null | undefined);
+  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 {
   /**
-   * How items are aligned along the cross axis.
+   * Content is not clipped and may render outside the container
    */
-  get align_items(): AlignItems | undefined;
+  Visible = 0,
   /**
-   * How items are aligned along the cross axis.
+   * Content is clipped at the container boundary
    */
-  set align_items(value: AlignItems | null | undefined);
+  Hidden = 1,
   /**
-   * How a single item is aligned along the cross axis.
+   * Always display scrollbars for scrollable content
    */
-  get align_self(): AlignSelf | undefined;
+  Scroll = 2,
   /**
-   * How a single item is aligned along the cross axis.
+   * Display scrollbars only when content overflows (internally maps to Scroll)
    */
-  set align_self(value: AlignSelf | null | undefined);
+  Auto = 3,
+}
+
+/**
+ * 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 {
   /**
-   * How lines of content are aligned along the cross axis.
+   * Element participates in normal document flow
    */
-  get align_content(): AlignContent | undefined;
+  Relative = 0,
   /**
-   * How lines of content are aligned along the cross axis.
+   * Element is positioned relative to its nearest positioned ancestor
    */
-  set align_content(value: AlignContent | null | undefined);
+  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: `0`
+ * 
+ */
+export class Style {
+  free(): void;
+  [Symbol.dispose](): void;
   /**
-   * The gap between rows (flex/grid).
+   * 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();
+   * console.log(style.display);  // Display.Block
+   * ```
    */
-  get row_gap(): Dimension | undefined;
-  /**
-   * The gap between rows (flex/grid).
+  constructor();
+  /**
+   * 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 row_gap(value: Dimension | null | undefined);
+  alignSelf: AlignSelf | undefined;
+  /**
+   * Gets the box sizing mode
+   *
+   * Determines whether padding and border are included in dimensions.
+   *
+   * @returns - The current [`BoxSizing`](JsBoxSizing) value
+   *
+   * @defaultValue `BoxSizing.BorderBox`
+   */
+  boxSizing: BoxSizing;
+  /**
+   * Gets the flex-basis
+   *
+   * The initial size of a flex item before growing/shrinking.
+   *
+   * @returns - A `Dimension` value (`number`, `\"{number}%\"`, or `\"auto\"`)
+   */
+  flexBasis: Dimension;
+  /**
+   * 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: Rect<LengthPercentage>;
+  /**
+   * Gets the margin
+   *
+   * Outer spacing around the element.
+   *
+   * @returns - A `Rect<LengthPercentageAuto>` with left, right, top, bottom margins
+   */
+  margin: Rect<LengthPercentageAuto>;
+  /**
+   * 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
+   */
+  alignItems: AlignItems | undefined;
+  /**
+   * 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)
+   */
+  flexShrink: number;
+  /**
+   * 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
+   *
+   * Inner spacing between the element's border and content.
+   *
+   * @returns - A `Rect<LengthPercentage>` with left, right, top, bottom padding
+   */
+  padding: Rect<LengthPercentage>;
+  /**
+   * Gets the aspect ratio
+   *
+   * The ratio of width to height. Used to maintain proportions.
+   *
+   * @returns - The aspect ratio value, or `undefined` if not set
+   */
+  aspectRatio: number | undefined;
+  /**
+   * Gets the maximum size constraints
+   *
+   * @returns - A `Size<Dimension>` object with maximum width and height
+   */
+  maxSize: Size<Dimension>;
+  /**
+   * Gets the minimum size constraints
+   *
+   * @returns - A `Size<Dimension>` object with minimum width and height
+   */
+  minSize: Size<Dimension>;
+  /**
+   * Gets the overflow behavior
+   *
+   * Controls how content that exceeds the container is handled.
+   *
+   * @returns - A `Point<Overflow>` with `x` and `y` overflow settings
+   */
+  overflow: Point<Overflow>;
+  /**
+   * Gets the position mode
+   *
+   * Determines how the element is positioned within its parent.
+   *
+   * @returns - The current [`Position`](JsPosition) value
+   *
+   * @defaultValue - `Position.Relative`
+   */
+  position: Position;
   /**
-   * The gap between columns (flex/grid).
-   */
-  get column_gap(): Dimension | undefined;
+   * 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
+   */
+  alignContent: AlignContent | undefined;
   /**
-   * The gap between columns (flex/grid).
-   */
-  set column_gap(value: Dimension | null | undefined);
+   * 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)
+   */
+  flexGrow: number;
   /**
-   * Algorithm for auto-placing items in the grid.
+   * Gets the flex wrap mode
+   *
+   * Controls whether flex items wrap to new lines.
+   *
+   * @returns - The current [`FlexWrap`](JsFlexWrap) value
+   *
+   * @defaultValue - `FlexWrap.NoWrap`
    */
-  get grid_auto_flow(): GridAutoFlow | undefined;
-  /**
-   * Algorithm for auto-placing items in the grid.
+  flexWrap: FlexWrap;
+  /**
+   * Gets the flex direction
+   *
+   * Defines the main axis direction for flex items.
+   *
+   * @returns - The current [`FlexDirection`](JsFlexDirection) value
+   *
+   * @defaultValue - `FlexDirection.Row`
+   */
+  flexDirection: FlexDirection;
+  /**
+   * 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
+   */
+  justifyContent: JustifyContent | undefined;
+  /**
+   * Gets the gap
+   *
+   * Spacing between flex/grid items.
+   *
+   * @returns - A `Size<LengthPercentage>` with column (width) and row (height) gaps
    */
-  set grid_auto_flow(value: GridAutoFlow | null | undefined);
+  gap: Size<LengthPercentage>;
   /**
-   * Text alignment.
+   * Gets the size (width and height)
+   *
+   * @returns - A `Size<Dimension>` object with `width` and `height` properties
    */
-  get text_align(): TextAlign | undefined;
+  size: Size<Dimension>;
   /**
-   * Text alignment.
+   * Gets the inset
+   *
+   * Positioning offsets for absolutely positioned elements.
+   *
+   * @returns - A `Rect<LengthPercentageAuto>` with left, right, top, bottom offsets
    */
-  set text_align(value: TextAlign | null | undefined);
-}
-
-export class TaffyNode {
-  free(): void;
-  [Symbol.dispose](): void;
-  get_layout(): Layout;
-  remove_child(child: TaffyNode): void;
-  set_children(children: Uint32Array): void;
-  compute_layout(available_space: any): void;
-  constructor(style: any);
-  free(): void;
-  style(): any;
-  add_child(child: TaffyNode): void;
-  set_style(style: any): void;
-  id: number;
+  inset: Rect<LengthPercentageAuto>;
 }
 
 /**
- * Text alignment within a node (mostly ignored in flex/grid layout but preserved for compatibility).
+ * 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 enum TextAlign {
-  Auto = 0,
-  Left = 1,
-  Right = 2,
-  Center = 3,
-  Justify = 4,
-}
-
-export class TrackDefinition {
+export class TaffyError {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * The numeric value of the track size.
-   */
-  value: number;
-  /**
-   * The unit of the track size.
+   * 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"
    */
-  unit: TrackUnit;
+  readonly message: string;
 }
 
 /**
- * The unit for a grid track definition.
+ * 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 enum TrackUnit {
-  /**
-   * The track size is specified in logical pixels.
-   */
-  Pixels = 0,
-  /**
-   * The track size is specified as a percentage of the container.
-   */
-  Percent = 1,
-  /**
-   * The track size is a fraction of the remaining free space (fr unit).
-   */
-  Fraction = 2,
-  /**
-   * The track size is determined automatically.
-   */
-  Auto = 3,
-  /**
-   * The track size is the minimum size needed to fit the content.
-   */
-  MinContent = 4,
+export class TaffyTree {
+  free(): void;
+  [Symbol.dispose](): void;
   /**
-   * The track size is the maximum size needed to fit the content.
-   */
-  MaxContent = 5,
+   * 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)
+   *
+   * 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
+   *
+   * @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
+   *
+   * @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
+   *
+   * 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 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;
+  /**
+   * 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: 800, height: 600 }
+   *
+   * // Flexible width, fixed height
+   * { width: "MaxContent", height: 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: 800, height: 600 });
+   * ```
+   */
+  computeLayout(node: bigint, available_space: Size<AvailableSpace>): void;
+  /**
+   * 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, 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
+   *
+   * @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
+   *
+   * 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 total count of all nodes
+   *
+   * @example
+   * ```typescript
+   * const count: number = tree.totalNodeCount();
+   * ```
+   */
+  totalNodeCount(): number;
+  /**
+   * 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.
+   *
+   * @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 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
+   *
+   * @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 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
+   *
+   * @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
+   *
+   * 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: 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
+   *
+   * 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
+   *
+   * 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)
+   *
+   * 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
+   *
+   * @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
+   *
+   * 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: 800, height: 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 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
+   *
+   * @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 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: 100, height: 50 };
+   * const nodeId: bigint = tree.newLeaf(style);
+   * ```
+   */
+  newLeaf(style: Style): bigint;
+  /**
+   * 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 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;
 }
 
-/**
- * Adds a child node to a parent node.
- *
- * # Arguments
- *
- * * `parent` - The ID of the parent node.
- * * `child` - The ID of the child node to add.
- *
- * # Errors
- *
- * Returns a `JsValue` error if the operation fails (e.g., recursive hierarchy).
- */
-export function add_child(parent: number, child: number): void;
-
-/**
- * Auto dimension constant
- */
-export function auto(): Dimension;
-
-/**
- * Clear all nodes
- */
-export function clear(): void;
-
-/**
- * Computes the layout for a tree starting from the specified root node.
- *
- * # Arguments
- *
- * * `root` - The ID of the root node of the tree to lay out.
- * * `available_space` - The available space constraints for the layout.
- *
- * # Errors
- *
- * Returns a `JsValue` error if the layout computation fails.
- */
-export function compute_layout(root: number, available_space: any): void;
-
-/**
- * Helper function to create a dimension
- */
-export function dimension(value: number, unit: DimensionUnit): Dimension;
-
-/**
- * Retrieves the list of children IDs for a given node.
- *
- * # Arguments
- *
- * * `parent` - The ID of the parent node.
- *
- * # Returns
- *
- * A boxed array of child node IDs (`Box<[u32]>`).
- *
- * # Errors
- *
- * Returns a `JsValue` error if the node does not exist.
- */
-export function get_children(parent: number): Uint32Array;
-
-/**
- * Retrieves the computed layout information for a specific node.
- *
- * # Arguments
- *
- * * `node` - The ID of the node to query.
- *
- * # Returns
- *
- * A `Layout` object containing the x, y, width, and height of the node.
- *
- * # Errors
- *
- * Returns a `JsValue` error if the node does not exist or layout information is unavailable.
- */
-export function get_layout(node: number): any;
-
-/**
- * Retrieves the parent ID of a given node.
- *
- * # Arguments
- *
- * * `node` - The ID of the node to query.
- *
- * # Returns
- *
- * An `Option<u32>` containing the parent ID if it exists, or `None` if the node is a root or orphan.
- *
- * # Errors
- *
- * Returns a `JsValue` error if internal tree access fails.
- */
-export function get_parent(node: number): number | undefined;
-
-/**
- * Initialize console error panic hook
- */
-export function init(): void;
-
-/**
- * Marks a node and its ancestors as dirty, requiring a layout re-computation.
- *
- * # Arguments
- *
- * * `node` - The ID of the node to mark dirty.
- *
- * # Errors
- *
- * Returns a `JsValue` error if the node does not exist.
- */
-export function mark_dirty(node: number): void;
-
-/**
- * Creates a new leaf node with the specified style.
- *
- * # Arguments
- *
- * * `style` - The style object to apply to the new node.
- *
- * # Returns
- *
- * The ID of the created node as a `u32`.
- *
- * # Errors
- *
- * Returns a `JsValue` error if the style cannot be deserialized or if node creation fails.
- */
-export function new_leaf(style: any): number;
-
-/**
- * Creates a new node with children and the specified style.
- *
- * # Arguments
- *
- * * `style` - The style object to apply to the new node.
- * * `children` - An array of child node IDs (`u32`) to attach to this node.
- *
- * # Returns
- *
- * The ID of the created node as a `u32`.
- *
- * # Errors
- *
- * Returns a `JsValue` error if the style cannot be deserialized or if node creation fails.
- */
-export function new_with_children(style: any, children: Uint32Array): number;
-
-/**
- * Get the total number of nodes
- */
-export function node_count(): number;
-
-/**
- * Helper function to create a percent dimension
- */
-export function percent(value: number): Dimension;
-
-/**
- * Helper function to create a pixel dimension
- */
-export function px(value: number): Dimension;
-
-/**
- * Removes a child node from a parent node.
- *
- * # Arguments
- *
- * * `parent` - The ID of the parent node.
- * * `child` - The ID of the child node to remove.
- *
- * # Errors
- *
- * Returns a `JsValue` error if the child is not found in the parent.
- */
-export function remove_child(parent: number, child: number): void;
-
-/**
- * Removes a node from the tree and frees its resources.
- *
- * # Arguments
- *
- * * `node` - The ID of the node to remove.
- *
- * # Errors
- *
- * Returns a `JsValue` error if the node does not exist or cannot be removed.
- */
-export function remove_node(node: number): void;
-
-/**
- * Sets the children of a node, replacing any existing children.
- *
- * # Arguments
- *
- * * `parent` - The ID of the parent node.
- * * `children` - An array of child node IDs to set.
- *
- * # Errors
- *
- * Returns a `JsValue` error if the operation fails.
- */
-export function set_children(parent: number, children: Uint32Array): void;
-
-/**
- * Updates the style of an existing node.
- *
- * # Arguments
- *
- * * `node` - The ID of the node to update.
- * * `style` - The new style object to apply.
- *
- * # Errors
- *
- * Returns a `JsValue` error if the style cannot be deserialized or if the node does not exist.
- */
-export function set_style(node: number, style: any): void;
-
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly __wbg_availablespace_free: (a: number, b: number) => void;
-  readonly __wbg_dimension_free: (a: number, b: number) => void;
-  readonly __wbg_get_availablespace_height: (a: number) => number;
-  readonly __wbg_get_availablespace_width: (a: number) => number;
-  readonly __wbg_get_dimension_unit: (a: number) => number;
-  readonly __wbg_get_dimension_value: (a: number) => number;
-  readonly __wbg_get_layout_height: (a: number) => number;
-  readonly __wbg_get_layout_width: (a: number) => number;
-  readonly __wbg_get_layout_y: (a: number) => number;
-  readonly __wbg_get_line_end: (a: number) => number;
-  readonly __wbg_get_line_start: (a: number) => number;
-  readonly __wbg_get_style_align_content: (a: number) => number;
-  readonly __wbg_get_style_align_items: (a: number) => number;
-  readonly __wbg_get_style_align_self: (a: number) => number;
-  readonly __wbg_get_style_bottom: (a: number) => number;
-  readonly __wbg_get_style_column_gap: (a: number) => number;
-  readonly __wbg_get_style_display: (a: number) => number;
-  readonly __wbg_get_style_flex_basis: (a: number) => number;
-  readonly __wbg_get_style_flex_direction: (a: number) => number;
-  readonly __wbg_get_style_flex_wrap: (a: number) => number;
-  readonly __wbg_get_style_grid_auto_flow: (a: number) => number;
-  readonly __wbg_get_style_height: (a: number) => number;
-  readonly __wbg_get_style_justify_content: (a: number) => number;
-  readonly __wbg_get_style_left: (a: number) => number;
-  readonly __wbg_get_style_margin_bottom: (a: number) => number;
-  readonly __wbg_get_style_margin_left: (a: number) => number;
-  readonly __wbg_get_style_margin_right: (a: number) => number;
-  readonly __wbg_get_style_margin_top: (a: number) => number;
-  readonly __wbg_get_style_max_height: (a: number) => number;
-  readonly __wbg_get_style_max_width: (a: number) => number;
-  readonly __wbg_get_style_min_height: (a: number) => number;
-  readonly __wbg_get_style_min_width: (a: number) => number;
-  readonly __wbg_get_style_padding_bottom: (a: number) => number;
-  readonly __wbg_get_style_padding_left: (a: number) => number;
-  readonly __wbg_get_style_padding_right: (a: number) => number;
-  readonly __wbg_get_style_padding_top: (a: number) => number;
-  readonly __wbg_get_style_position: (a: number) => number;
-  readonly __wbg_get_style_right: (a: number) => number;
-  readonly __wbg_get_style_row_gap: (a: number) => number;
-  readonly __wbg_get_style_text_align: (a: number) => number;
-  readonly __wbg_get_style_top: (a: number) => number;
-  readonly __wbg_get_style_width: (a: number) => number;
-  readonly __wbg_get_taffynode_id: (a: number) => number;
-  readonly __wbg_get_trackdefinition_unit: (a: number) => number;
-  readonly __wbg_line_free: (a: number, b: number) => void;
-  readonly __wbg_point_free: (a: number, b: number) => void;
-  readonly __wbg_set_availablespace_height: (a: number, b: number) => void;
-  readonly __wbg_set_availablespace_width: (a: number, b: number) => void;
-  readonly __wbg_set_dimension_unit: (a: number, b: number) => void;
-  readonly __wbg_set_dimension_value: (a: number, b: number) => void;
-  readonly __wbg_set_layout_height: (a: number, b: number) => void;
-  readonly __wbg_set_layout_width: (a: number, b: number) => void;
-  readonly __wbg_set_layout_y: (a: number, b: number) => void;
-  readonly __wbg_set_line_end: (a: number, b: number) => void;
-  readonly __wbg_set_line_start: (a: number, b: number) => void;
-  readonly __wbg_set_style_align_content: (a: number, b: number) => void;
-  readonly __wbg_set_style_align_items: (a: number, b: number) => void;
-  readonly __wbg_set_style_align_self: (a: number, b: number) => void;
-  readonly __wbg_set_style_bottom: (a: number, b: number) => void;
-  readonly __wbg_set_style_column_gap: (a: number, b: number) => void;
-  readonly __wbg_set_style_display: (a: number, b: number) => void;
-  readonly __wbg_set_style_flex_basis: (a: number, b: number) => void;
-  readonly __wbg_set_style_flex_direction: (a: number, b: number) => void;
-  readonly __wbg_set_style_flex_wrap: (a: number, b: number) => void;
-  readonly __wbg_set_style_grid_auto_flow: (a: number, b: number) => void;
-  readonly __wbg_set_style_height: (a: number, b: number) => void;
-  readonly __wbg_set_style_justify_content: (a: number, b: number) => void;
-  readonly __wbg_set_style_left: (a: number, b: number) => void;
-  readonly __wbg_set_style_margin_bottom: (a: number, b: number) => void;
-  readonly __wbg_set_style_margin_left: (a: number, b: number) => void;
-  readonly __wbg_set_style_margin_right: (a: number, b: number) => void;
-  readonly __wbg_set_style_margin_top: (a: number, b: number) => void;
-  readonly __wbg_set_style_max_height: (a: number, b: number) => void;
-  readonly __wbg_set_style_max_width: (a: number, b: number) => void;
-  readonly __wbg_set_style_min_height: (a: number, b: number) => void;
-  readonly __wbg_set_style_min_width: (a: number, b: number) => void;
-  readonly __wbg_set_style_padding_bottom: (a: number, b: number) => void;
-  readonly __wbg_set_style_padding_left: (a: number, b: number) => void;
-  readonly __wbg_set_style_padding_right: (a: number, b: number) => void;
-  readonly __wbg_set_style_padding_top: (a: number, b: number) => void;
-  readonly __wbg_set_style_position: (a: number, b: number) => void;
-  readonly __wbg_set_style_right: (a: number, b: number) => void;
-  readonly __wbg_set_style_row_gap: (a: number, b: number) => void;
-  readonly __wbg_set_style_text_align: (a: number, b: number) => void;
-  readonly __wbg_set_style_top: (a: number, b: number) => void;
-  readonly __wbg_set_style_width: (a: number, b: number) => void;
-  readonly __wbg_set_taffynode_id: (a: number, b: number) => void;
-  readonly __wbg_set_trackdefinition_unit: (a: number, b: number) => void;
-  readonly __wbg_style_free: (a: number, b: number) => void;
-  readonly __wbg_taffynode_free: (a: number, b: number) => void;
-  readonly __wbg_trackdefinition_free: (a: number, b: number) => void;
-  readonly add_child: (a: number, b: number) => [number, number];
-  readonly auto: () => number;
-  readonly clear: () => [number, number];
-  readonly compute_layout: (a: number, b: any) => [number, number];
-  readonly dimension: (a: number, b: number) => number;
-  readonly get_children: (a: number) => [number, number, number, number];
-  readonly get_layout: (a: number) => [number, number, number];
-  readonly get_parent: (a: number) => [number, number, number];
-  readonly init: () => void;
-  readonly mark_dirty: (a: number) => [number, number];
-  readonly new_leaf: (a: any) => [number, number, number];
-  readonly new_with_children: (a: any, b: number, c: number) => [number, number, number];
-  readonly node_count: () => number;
-  readonly percent: (a: number) => number;
-  readonly px: (a: number) => number;
-  readonly remove_child: (a: number, b: number) => [number, number];
-  readonly remove_node: (a: number) => [number, number];
-  readonly set_children: (a: number, b: number, c: number) => [number, number];
-  readonly set_style: (a: number, b: any) => [number, number];
-  readonly taffynode_add_child: (a: number, b: number) => [number, number];
-  readonly taffynode_compute_layout: (a: number, b: any) => [number, number];
-  readonly taffynode_free: (a: number) => [number, number];
-  readonly taffynode_get_layout: (a: number) => [number, number, number];
-  readonly taffynode_new: (a: any) => [number, number, number];
-  readonly taffynode_remove_child: (a: number, b: number) => [number, number];
-  readonly taffynode_set_children: (a: number, b: number, c: number) => [number, number];
-  readonly taffynode_set_style: (a: number, b: any) => [number, number];
-  readonly taffynode_style: (a: number) => [number, number, number];
-  readonly __wbg_set_layout_x: (a: number, b: number) => void;
-  readonly __wbg_set_point_x: (a: number, b: number) => void;
-  readonly __wbg_set_point_y: (a: number, b: number) => void;
-  readonly __wbg_set_rect_bottom: (a: number, b: number) => void;
-  readonly __wbg_set_rect_left: (a: number, b: number) => void;
-  readonly __wbg_set_rect_right: (a: number, b: number) => void;
-  readonly __wbg_set_rect_top: (a: number, b: number) => void;
-  readonly __wbg_set_size_height: (a: number, b: number) => void;
-  readonly __wbg_set_size_width: (a: number, b: number) => void;
-  readonly __wbg_set_trackdefinition_value: (a: number, b: number) => void;
-  readonly __wbg_set_style_flex_grow: (a: number, b: number) => void;
-  readonly __wbg_set_style_flex_shrink: (a: number, b: number) => void;
-  readonly __wbg_get_style_flex_grow: (a: number) => number;
-  readonly __wbg_get_style_flex_shrink: (a: number) => number;
-  readonly __wbg_get_layout_x: (a: number) => number;
-  readonly __wbg_get_point_x: (a: number) => number;
-  readonly __wbg_get_point_y: (a: number) => number;
-  readonly __wbg_get_rect_bottom: (a: number) => number;
-  readonly __wbg_get_rect_left: (a: number) => number;
-  readonly __wbg_get_rect_right: (a: number) => number;
-  readonly __wbg_get_rect_top: (a: number) => number;
-  readonly __wbg_get_size_height: (a: number) => number;
-  readonly __wbg_get_size_width: (a: number) => number;
-  readonly __wbg_get_trackdefinition_value: (a: number) => number;
-  readonly __wbg_rect_free: (a: number, b: number) => void;
   readonly __wbg_layout_free: (a: number, b: number) => void;
-  readonly __wbg_size_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 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_boxSizing: (a: number) => number;
+  readonly style_display: (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_justifyContent: (a: number) => number;
+  readonly style_margin: (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_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_boxSizing: (a: number, b: number) => void;
+  readonly style_set_display: (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_justifyContent: (a: number, b: any) => void;
+  readonly style_set_margin: (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 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_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_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_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_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_totalNodeCount: (a: 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_exn_store: (a: number) => void;
@@ -1116,6 +1940,7 @@ export interface InitOutput {
   readonly __wbindgen_externrefs: WebAssembly.Table;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __externref_table_dealloc: (a: number) => void;
+  readonly __externref_drop_slice: (a: number, b: number) => void;
   readonly __wbindgen_start: () => void;
 }