@simonklee/yoga 0.2.24

package/dist/index.js

@@ -0,0 +1,1502 @@
+import { dlopen, suffix, JSCallback, FFIType } from "bun:ffi";
+import { join } from "path";
+import { existsSync } from "fs";
+// Import native libraries with { type: "file" } for bun compile support
+// This tells Bun to embed the file and return a real filesystem path
+// Using top-level await import() to load only the current platform's library
+const embeddedLib = await (async () => {
+    try {
+        if (process.platform === "darwin" && process.arch === "arm64") {
+            // @ts-ignore
+            return (await import("../dist/darwin-arm64/libyoga.dylib", { with: { type: "file" } })).default;
+        }
+        else if (process.platform === "darwin" && process.arch === "x64") {
+            // @ts-ignore
+            return (await import("../dist/darwin-x64/libyoga.dylib", { with: { type: "file" } })).default;
+        }
+        else if (process.platform === "linux" && process.arch === "x64") {
+            // @ts-ignore
+            return (await import("../dist/linux-x64/libyoga.so", { with: { type: "file" } })).default;
+        }
+        else if (process.platform === "linux" && process.arch === "arm64") {
+            // @ts-ignore
+            return (await import("../dist/linux-arm64/libyoga.so", { with: { type: "file" } })).default;
+        }
+        else if (process.platform === "win32") {
+            // @ts-ignore
+            return (await import("../dist/windows-x64/yoga.dll", { with: { type: "file" } })).default;
+        }
+    }
+    catch {
+        // Library not found for this platform
+    }
+    return undefined;
+})();
+function getLibPath() {
+    // Check local development path (zig-out) first for development
+    if (process.platform === "win32") {
+        if (existsSync(join(__dirname, "..", "zig-out", "lib", `yoga.${suffix}`))) {
+            return join(__dirname, "..", "zig-out", "lib", `yoga.${suffix}`);
+        }
+        if (existsSync(join(__dirname, "..", "zig-out", "bin", `yoga.${suffix}`))) {
+            return join(__dirname, "..", "zig-out", "bin", `yoga.${suffix}`);
+        }
+    }
+    else {
+        if (existsSync(join(__dirname, "..", "zig-out", "lib", `libyoga.${suffix}`))) {
+            return join(__dirname, "..", "zig-out", "lib", `libyoga.${suffix}`);
+        }
+    }
+    // Check embedded libraries (for bun compile)
+    if (embeddedLib && existsSync(embeddedLib)) {
+        return embeddedLib;
+    }
+    throw new Error(`Could not find native library. ` +
+        `Platform: ${process.platform}-${process.arch}\n` +
+        `Make sure to run 'zig build' or install the package with binaries.`);
+}
+// Yoga enum definitions
+export const Align = {
+    Auto: 0,
+    FlexStart: 1,
+    Center: 2,
+    FlexEnd: 3,
+    Stretch: 4,
+    Baseline: 5,
+    SpaceBetween: 6,
+    SpaceAround: 7,
+    SpaceEvenly: 8,
+};
+export const BoxSizing = {
+    BorderBox: 0,
+    ContentBox: 1,
+};
+export const Dimension = {
+    Width: 0,
+    Height: 1,
+};
+export const Direction = {
+    Inherit: 0,
+    LTR: 1,
+    RTL: 2,
+};
+export const Display = {
+    Flex: 0,
+    None: 1,
+    Contents: 2,
+};
+export const Edge = {
+    Left: 0,
+    Top: 1,
+    Right: 2,
+    Bottom: 3,
+    Start: 4,
+    End: 5,
+    Horizontal: 6,
+    Vertical: 7,
+    All: 8,
+};
+export const Errata = {
+    None: 0,
+    StretchFlexBasis: 1,
+    AbsolutePositionWithoutInsetsExcludesPadding: 2,
+    AbsolutePercentAgainstInnerSize: 4,
+    All: 2147483647,
+    Classic: 2147483646,
+};
+export const ExperimentalFeature = {
+    WebFlexBasis: 0,
+};
+export const FlexDirection = {
+    Column: 0,
+    ColumnReverse: 1,
+    Row: 2,
+    RowReverse: 3,
+};
+export const Gutter = {
+    Column: 0,
+    Row: 1,
+    All: 2,
+};
+export const Justify = {
+    FlexStart: 0,
+    Center: 1,
+    FlexEnd: 2,
+    SpaceBetween: 3,
+    SpaceAround: 4,
+    SpaceEvenly: 5,
+};
+export const LogLevel = {
+    Error: 0,
+    Warn: 1,
+    Info: 2,
+    Debug: 3,
+    Verbose: 4,
+    Fatal: 5,
+};
+export const MeasureMode = {
+    Undefined: 0,
+    Exactly: 1,
+    AtMost: 2,
+};
+export const NodeType = {
+    Default: 0,
+    Text: 1,
+};
+export const Overflow = {
+    Visible: 0,
+    Hidden: 1,
+    Scroll: 2,
+};
+export const PositionType = {
+    Static: 0,
+    Relative: 1,
+    Absolute: 2,
+};
+export const Unit = {
+    Undefined: 0,
+    Point: 1,
+    Percent: 2,
+    Auto: 3,
+    MaxContent: 4,
+    FitContent: 5,
+    Stretch: 6,
+};
+export const Wrap = {
+    NoWrap: 0,
+    Wrap: 1,
+    WrapReverse: 2,
+};
+// Constants for yoga-layout compatibility
+export const EDGE_LEFT = Edge.Left;
+export const EDGE_TOP = Edge.Top;
+export const EDGE_RIGHT = Edge.Right;
+export const EDGE_BOTTOM = Edge.Bottom;
+export const EDGE_START = Edge.Start;
+export const EDGE_END = Edge.End;
+export const EDGE_HORIZONTAL = Edge.Horizontal;
+export const EDGE_VERTICAL = Edge.Vertical;
+export const EDGE_ALL = Edge.All;
+export const GUTTER_COLUMN = Gutter.Column;
+export const GUTTER_ROW = Gutter.Row;
+export const GUTTER_ALL = Gutter.All;
+export const FLEX_DIRECTION_COLUMN = FlexDirection.Column;
+export const FLEX_DIRECTION_COLUMN_REVERSE = FlexDirection.ColumnReverse;
+export const FLEX_DIRECTION_ROW = FlexDirection.Row;
+export const FLEX_DIRECTION_ROW_REVERSE = FlexDirection.RowReverse;
+export const JUSTIFY_FLEX_START = Justify.FlexStart;
+export const JUSTIFY_CENTER = Justify.Center;
+export const JUSTIFY_FLEX_END = Justify.FlexEnd;
+export const JUSTIFY_SPACE_BETWEEN = Justify.SpaceBetween;
+export const JUSTIFY_SPACE_AROUND = Justify.SpaceAround;
+export const JUSTIFY_SPACE_EVENLY = Justify.SpaceEvenly;
+export const ALIGN_AUTO = Align.Auto;
+export const ALIGN_FLEX_START = Align.FlexStart;
+export const ALIGN_CENTER = Align.Center;
+export const ALIGN_FLEX_END = Align.FlexEnd;
+export const ALIGN_STRETCH = Align.Stretch;
+export const ALIGN_BASELINE = Align.Baseline;
+export const ALIGN_SPACE_BETWEEN = Align.SpaceBetween;
+export const ALIGN_SPACE_AROUND = Align.SpaceAround;
+export const ALIGN_SPACE_EVENLY = Align.SpaceEvenly;
+export const WRAP_NO_WRAP = Wrap.NoWrap;
+export const WRAP_WRAP = Wrap.Wrap;
+export const WRAP_WRAP_REVERSE = Wrap.WrapReverse;
+export const OVERFLOW_VISIBLE = Overflow.Visible;
+export const OVERFLOW_HIDDEN = Overflow.Hidden;
+export const OVERFLOW_SCROLL = Overflow.Scroll;
+export const DISPLAY_FLEX = Display.Flex;
+export const DISPLAY_NONE = Display.None;
+export const DISPLAY_CONTENTS = Display.Contents;
+export const BOX_SIZING_BORDER_BOX = BoxSizing.BorderBox;
+export const BOX_SIZING_CONTENT_BOX = BoxSizing.ContentBox;
+export const DIMENSION_WIDTH = Dimension.Width;
+export const DIMENSION_HEIGHT = Dimension.Height;
+export const POSITION_TYPE_STATIC = PositionType.Static;
+export const POSITION_TYPE_RELATIVE = PositionType.Relative;
+export const POSITION_TYPE_ABSOLUTE = PositionType.Absolute;
+export const DIRECTION_INHERIT = Direction.Inherit;
+export const DIRECTION_LTR = Direction.LTR;
+export const DIRECTION_RTL = Direction.RTL;
+export const UNIT_UNDEFINED = Unit.Undefined;
+export const UNIT_POINT = Unit.Point;
+export const UNIT_PERCENT = Unit.Percent;
+export const UNIT_AUTO = Unit.Auto;
+export const UNIT_MAX_CONTENT = Unit.MaxContent;
+export const UNIT_FIT_CONTENT = Unit.FitContent;
+export const UNIT_STRETCH = Unit.Stretch;
+export const MEASURE_MODE_UNDEFINED = MeasureMode.Undefined;
+export const MEASURE_MODE_EXACTLY = MeasureMode.Exactly;
+export const MEASURE_MODE_AT_MOST = MeasureMode.AtMost;
+export const NODE_TYPE_DEFAULT = NodeType.Default;
+export const NODE_TYPE_TEXT = NodeType.Text;
+export const LOG_LEVEL_ERROR = LogLevel.Error;
+export const LOG_LEVEL_WARN = LogLevel.Warn;
+export const LOG_LEVEL_INFO = LogLevel.Info;
+export const LOG_LEVEL_DEBUG = LogLevel.Debug;
+export const LOG_LEVEL_VERBOSE = LogLevel.Verbose;
+export const LOG_LEVEL_FATAL = LogLevel.Fatal;
+export const EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS = ExperimentalFeature.WebFlexBasis;
+export const ERRATA_NONE = Errata.None;
+export const ERRATA_STRETCH_FLEX_BASIS = Errata.StretchFlexBasis;
+export const ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING = Errata.AbsolutePositionWithoutInsetsExcludesPadding;
+export const ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE = Errata.AbsolutePercentAgainstInnerSize;
+export const ERRATA_ALL = Errata.All;
+export const ERRATA_CLASSIC = Errata.Classic;
+function parseValue(value) {
+    if (value === undefined) {
+        return { unit: Unit.Undefined, asNumber: undefined };
+    }
+    if (value === "auto") {
+        return { unit: Unit.Auto, asNumber: undefined };
+    }
+    if (typeof value === "string" && value.endsWith("%")) {
+        return { unit: Unit.Percent, asNumber: parseFloat(value) };
+    }
+    return { unit: Unit.Point, asNumber: value };
+}
+// Default value for freed nodes (matches yoga-layout behavior)
+const UNDEFINED_VALUE = { unit: Unit.Undefined, value: NaN };
+// Helper to unpack Value from u64 (lower 32 bits = unit, upper 32 bits = value as f32 bits)
+function unpackValue(packed) {
+    const p = BigInt(packed);
+    const unit = Number(p & 0xffffffffn);
+    const valueBits = Number((p >> 32n) & 0xffffffffn);
+    // Convert u32 bits back to f32
+    const buffer = new ArrayBuffer(4);
+    const view = new DataView(buffer);
+    view.setUint32(0, valueBits, true);
+    const value = view.getFloat32(0, true);
+    return { unit, value };
+}
+// Load the library
+const lib = dlopen(getLibPath(), {
+    // Config functions
+    ygConfigNew: { args: [], returns: "ptr" },
+    ygConfigFree: { args: ["ptr"], returns: "void" },
+    ygConfigGetDefault: { args: [], returns: "ptr" },
+    ygConfigSetUseWebDefaults: { args: ["ptr", "bool"], returns: "void" },
+    ygConfigGetUseWebDefaults: { args: ["ptr"], returns: "bool" },
+    ygConfigSetPointScaleFactor: { args: ["ptr", "f32"], returns: "void" },
+    ygConfigGetPointScaleFactor: { args: ["ptr"], returns: "f32" },
+    ygConfigSetErrata: { args: ["ptr", "i32"], returns: "void" },
+    ygConfigGetErrata: { args: ["ptr"], returns: "i32" },
+    ygConfigSetExperimentalFeatureEnabled: {
+        args: ["ptr", "i32", "bool"],
+        returns: "void",
+    },
+    ygConfigIsExperimentalFeatureEnabled: {
+        args: ["ptr", "i32"],
+        returns: "bool",
+    },
+    // Node creation and management
+    ygNodeNew: { args: [], returns: "ptr" },
+    ygNodeNewWithConfig: { args: ["ptr"], returns: "ptr" },
+    ygNodeClone: { args: ["ptr"], returns: "ptr" },
+    ygNodeFree: { args: ["ptr"], returns: "void" },
+    ygNodeFreeRecursive: { args: ["ptr"], returns: "void" },
+    ygNodeReset: { args: ["ptr"], returns: "void" },
+    ygNodeCopyStyle: { args: ["ptr", "ptr"], returns: "void" },
+    ygNodeSetIsReferenceBaseline: { args: ["ptr", "bool"], returns: "void" },
+    ygNodeIsReferenceBaseline: { args: ["ptr"], returns: "bool" },
+    ygNodeSetAlwaysFormsContainingBlock: {
+        args: ["ptr", "bool"],
+        returns: "void",
+    },
+    // Node hierarchy management
+    ygNodeInsertChild: { args: ["ptr", "ptr", "u64"], returns: "void" },
+    ygNodeRemoveChild: { args: ["ptr", "ptr"], returns: "void" },
+    ygNodeRemoveAllChildren: { args: ["ptr"], returns: "void" },
+    ygNodeGetChild: { args: ["ptr", "u64"], returns: "ptr" },
+    ygNodeGetChildCount: { args: ["ptr"], returns: "u64" },
+    ygNodeGetParent: { args: ["ptr"], returns: "ptr" },
+    // Layout calculation
+    ygNodeCalculateLayout: { args: ["ptr", "f32", "f32", "i32"], returns: "void" },
+    ygNodeGetHasNewLayout: { args: ["ptr"], returns: "bool" },
+    ygNodeSetHasNewLayout: { args: ["ptr", "bool"], returns: "void" },
+    ygNodeMarkDirty: { args: ["ptr"], returns: "void" },
+    ygNodeIsDirty: { args: ["ptr"], returns: "bool" },
+    // Layout result access
+    ygNodeLayoutGetLeft: { args: ["ptr"], returns: "f32" },
+    ygNodeLayoutGetTop: { args: ["ptr"], returns: "f32" },
+    ygNodeLayoutGetRight: { args: ["ptr"], returns: "f32" },
+    ygNodeLayoutGetBottom: { args: ["ptr"], returns: "f32" },
+    ygNodeLayoutGetWidth: { args: ["ptr"], returns: "f32" },
+    ygNodeLayoutGetHeight: { args: ["ptr"], returns: "f32" },
+    ygNodeLayoutGetBorder: { args: ["ptr", "i32"], returns: "f32" },
+    ygNodeLayoutGetMargin: { args: ["ptr", "i32"], returns: "f32" },
+    ygNodeLayoutGetPadding: { args: ["ptr", "i32"], returns: "f32" },
+    ygNodeLayoutGetRawWidth: { args: ["ptr"], returns: "f32" },
+    ygNodeLayoutGetRawHeight: { args: ["ptr"], returns: "f32" },
+    // Style properties - Layout
+    ygNodeStyleSetDirection: { args: ["ptr", "i32"], returns: "void" },
+    ygNodeStyleGetDirection: { args: ["ptr"], returns: "i32" },
+    ygNodeStyleSetFlexDirection: { args: ["ptr", "i32"], returns: "void" },
+    ygNodeStyleGetFlexDirection: { args: ["ptr"], returns: "i32" },
+    ygNodeStyleSetJustifyContent: { args: ["ptr", "i32"], returns: "void" },
+    ygNodeStyleGetJustifyContent: { args: ["ptr"], returns: "i32" },
+    ygNodeStyleSetAlignContent: { args: ["ptr", "i32"], returns: "void" },
+    ygNodeStyleGetAlignContent: { args: ["ptr"], returns: "i32" },
+    ygNodeStyleSetAlignItems: { args: ["ptr", "i32"], returns: "void" },
+    ygNodeStyleGetAlignItems: { args: ["ptr"], returns: "i32" },
+    ygNodeStyleSetAlignSelf: { args: ["ptr", "i32"], returns: "void" },
+    ygNodeStyleGetAlignSelf: { args: ["ptr"], returns: "i32" },
+    ygNodeStyleSetPositionType: { args: ["ptr", "i32"], returns: "void" },
+    ygNodeStyleGetPositionType: { args: ["ptr"], returns: "i32" },
+    ygNodeStyleSetFlexWrap: { args: ["ptr", "i32"], returns: "void" },
+    ygNodeStyleGetFlexWrap: { args: ["ptr"], returns: "i32" },
+    ygNodeStyleSetOverflow: { args: ["ptr", "i32"], returns: "void" },
+    ygNodeStyleGetOverflow: { args: ["ptr"], returns: "i32" },
+    ygNodeStyleSetDisplay: { args: ["ptr", "i32"], returns: "void" },
+    ygNodeStyleGetDisplay: { args: ["ptr"], returns: "i32" },
+    ygNodeStyleSetBoxSizing: { args: ["ptr", "i32"], returns: "void" },
+    ygNodeStyleGetBoxSizing: { args: ["ptr"], returns: "i32" },
+    // Style properties - Flex
+    ygNodeStyleSetFlex: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleGetFlex: { args: ["ptr"], returns: "f32" },
+    ygNodeStyleSetFlexGrow: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleGetFlexGrow: { args: ["ptr"], returns: "f32" },
+    ygNodeStyleSetFlexShrink: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleGetFlexShrink: { args: ["ptr"], returns: "f32" },
+    ygNodeStyleSetFlexBasis: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetFlexBasisPercent: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetFlexBasisAuto: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetFlexBasisMaxContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetFlexBasisFitContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetFlexBasisStretch: { args: ["ptr"], returns: "void" },
+    // Style properties - Position
+    ygNodeStyleSetPosition: { args: ["ptr", "i32", "f32"], returns: "void" },
+    ygNodeStyleSetPositionPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
+    ygNodeStyleSetPositionAuto: { args: ["ptr", "i32"], returns: "void" },
+    // Style properties - Margin
+    ygNodeStyleSetMargin: { args: ["ptr", "i32", "f32"], returns: "void" },
+    ygNodeStyleSetMarginPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
+    ygNodeStyleSetMarginAuto: { args: ["ptr", "i32"], returns: "void" },
+    // Style properties - Padding
+    ygNodeStyleSetPadding: { args: ["ptr", "i32", "f32"], returns: "void" },
+    ygNodeStyleSetPaddingPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
+    // Style properties - Border
+    ygNodeStyleSetBorder: { args: ["ptr", "i32", "f32"], returns: "void" },
+    ygNodeStyleGetBorder: { args: ["ptr", "i32"], returns: "f32" },
+    // Style properties - Gap
+    ygNodeStyleSetGap: { args: ["ptr", "i32", "f32"], returns: "void" },
+    ygNodeStyleSetGapPercent: { args: ["ptr", "i32", "f32"], returns: "void" },
+    // Style properties - Size
+    ygNodeStyleSetWidth: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetWidthPercent: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetWidthAuto: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetWidthMaxContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetWidthFitContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetWidthStretch: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetHeight: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetHeightPercent: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetHeightAuto: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetHeightMaxContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetHeightFitContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetHeightStretch: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMinWidth: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetMinWidthPercent: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetMinWidthMaxContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMinWidthFitContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMinWidthStretch: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMinHeight: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetMinHeightPercent: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetMinHeightMaxContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMinHeightFitContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMinHeightStretch: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMaxWidth: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetMaxWidthPercent: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetMaxWidthMaxContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMaxWidthFitContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMaxWidthStretch: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMaxHeight: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetMaxHeightPercent: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleSetMaxHeightMaxContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMaxHeightFitContent: { args: ["ptr"], returns: "void" },
+    ygNodeStyleSetMaxHeightStretch: { args: ["ptr"], returns: "void" },
+    // Style properties - Aspect Ratio
+    ygNodeStyleSetAspectRatio: { args: ["ptr", "f32"], returns: "void" },
+    ygNodeStyleGetAspectRatio: { args: ["ptr"], returns: "f32" },
+    // Node context
+    ygNodeSetContext: { args: ["ptr", "ptr"], returns: "void" },
+    ygNodeGetContext: { args: ["ptr"], returns: "ptr" },
+    // Callback functions
+    ygNodeSetMeasureFunc: { args: ["ptr", "ptr"], returns: "void" },
+    ygNodeUnsetMeasureFunc: { args: ["ptr"], returns: "void" },
+    ygNodeHasMeasureFunc: { args: ["ptr"], returns: "bool" },
+    ygNodeSetBaselineFunc: { args: ["ptr", "ptr"], returns: "void" },
+    ygNodeUnsetBaselineFunc: { args: ["ptr"], returns: "void" },
+    ygNodeHasBaselineFunc: { args: ["ptr"], returns: "bool" },
+    ygNodeSetDirtiedFunc: { args: ["ptr", "ptr"], returns: "void" },
+    ygNodeUnsetDirtiedFunc: { args: ["ptr"], returns: "void" },
+    ygNodeGetDirtiedFunc: { args: ["ptr"], returns: "ptr" },
+    // Callback helper functions
+    ygCreateSize: { args: ["f32", "f32"], returns: "u64" },
+    ygStoreMeasureResult: { args: ["f32", "f32"], returns: "void" },
+    ygStoreBaselineResult: { args: ["f32"], returns: "void" },
+    ygNodeSetMeasureFuncTrampoline: { args: ["ptr", "ptr"], returns: "void" },
+    ygNodeUnsetMeasureFuncTrampoline: { args: ["ptr"], returns: "void" },
+    ygNodeSetBaselineFuncTrampoline: { args: ["ptr", "ptr"], returns: "void" },
+    ygNodeUnsetBaselineFuncTrampoline: { args: ["ptr"], returns: "void" },
+    ygNodeFreeCallbacks: { args: ["ptr"], returns: "void" },
+    // Value getters (packed: lower 32 bits = unit, upper 32 bits = value)
+    ygNodeStyleGetWidthPacked: { args: ["ptr"], returns: "u64" },
+    ygNodeStyleGetHeightPacked: { args: ["ptr"], returns: "u64" },
+    ygNodeStyleGetMinWidthPacked: { args: ["ptr"], returns: "u64" },
+    ygNodeStyleGetMinHeightPacked: { args: ["ptr"], returns: "u64" },
+    ygNodeStyleGetMaxWidthPacked: { args: ["ptr"], returns: "u64" },
+    ygNodeStyleGetMaxHeightPacked: { args: ["ptr"], returns: "u64" },
+    ygNodeStyleGetMarginPacked: { args: ["ptr", "i32"], returns: "u64" },
+    ygNodeStyleGetPaddingPacked: { args: ["ptr", "i32"], returns: "u64" },
+    ygNodeStyleGetPositionPacked: { args: ["ptr", "i32"], returns: "u64" },
+    ygNodeStyleGetGapPacked: { args: ["ptr", "i32"], returns: "u64" },
+    ygNodeStyleGetFlexBasisPacked: { args: ["ptr"], returns: "u64" },
+});
+const yg = lib.symbols;
+// ============================================================================
+// Node class - yoga-layout compatible API
+// ============================================================================
+export class Node {
+    ptr;
+    _freed = false;
+    measureCallback = null;
+    baselineCallback = null;
+    dirtiedCallback = null;
+    constructor(ptr) {
+        this.ptr = ptr;
+    }
+    /** Check if the node has been freed */
+    isFreed() {
+        return this._freed;
+    }
+    static create(config) {
+        const ptr = config
+            ? yg.ygNodeNewWithConfig(config["ptr"])
+            : yg.ygNodeNew();
+        if (!ptr)
+            throw new Error("Failed to create node");
+        return new Node(ptr);
+    }
+    static createDefault() {
+        return Node.create();
+    }
+    static createWithConfig(config) {
+        return Node.create(config);
+    }
+    static destroy(node) {
+        node.free();
+    }
+    free() {
+        if (this._freed)
+            return; // Already freed, no-op
+        // Clean up callbacks before freeing the node
+        this.unsetMeasureFunc();
+        this.unsetBaselineFunc();
+        this.unsetDirtiedFunc();
+        yg.ygNodeFree(this.ptr);
+        this._freed = true;
+    }
+    freeRecursive() {
+        if (this._freed)
+            return; // Already freed, no-op
+        // Clean up this node's callbacks before freeing
+        // Note: Child nodes' JSCallback objects are not tracked here - if you have
+        // references to child Node objects, their callbacks become invalid after this call
+        this.cleanupCallbacks();
+        yg.ygNodeFreeRecursive(this.ptr);
+        this._freed = true;
+    }
+    reset() {
+        if (this._freed)
+            return;
+        // Clean up callbacks before reset since reset clears all state
+        this.cleanupCallbacks();
+        yg.ygNodeReset(this.ptr);
+    }
+    /** Internal helper to close JSCallback objects without calling native unset functions */
+    cleanupCallbacks() {
+        if (this.measureCallback) {
+            this.measureCallback.close();
+            this.measureCallback = null;
+        }
+        if (this.baselineCallback) {
+            this.baselineCallback.close();
+            this.baselineCallback = null;
+        }
+        if (this.dirtiedCallback) {
+            this.dirtiedCallback.close();
+            this.dirtiedCallback = null;
+        }
+    }
+    clone() {
+        if (this._freed)
+            throw new Error("Cannot clone freed node");
+        const ptr = yg.ygNodeClone(this.ptr);
+        if (!ptr)
+            throw new Error("Failed to clone node");
+        return new Node(ptr);
+    }
+    copyStyle(node) {
+        if (this._freed)
+            return;
+        yg.ygNodeCopyStyle(this.ptr, node.ptr);
+    }
+    setIsReferenceBaseline(isReferenceBaseline) {
+        if (this._freed)
+            return;
+        yg.ygNodeSetIsReferenceBaseline(this.ptr, isReferenceBaseline);
+    }
+    isReferenceBaseline() {
+        if (this._freed)
+            return false;
+        return yg.ygNodeIsReferenceBaseline(this.ptr);
+    }
+    setAlwaysFormsContainingBlock(alwaysFormsContainingBlock) {
+        if (this._freed)
+            return;
+        yg.ygNodeSetAlwaysFormsContainingBlock(this.ptr, alwaysFormsContainingBlock);
+    }
+    // Hierarchy
+    insertChild(child, index) {
+        if (this._freed)
+            return;
+        yg.ygNodeInsertChild(this.ptr, child.ptr, index);
+    }
+    removeChild(child) {
+        if (this._freed)
+            return;
+        yg.ygNodeRemoveChild(this.ptr, child.ptr);
+    }
+    removeAllChildren() {
+        if (this._freed)
+            return;
+        yg.ygNodeRemoveAllChildren(this.ptr);
+    }
+    getChild(index) {
+        if (this._freed)
+            return null;
+        const ptr = yg.ygNodeGetChild(this.ptr, index);
+        return ptr ? new Node(ptr) : null;
+    }
+    getChildCount() {
+        if (this._freed)
+            return 0;
+        return Number(yg.ygNodeGetChildCount(this.ptr));
+    }
+    getParent() {
+        if (this._freed)
+            return null;
+        const ptr = yg.ygNodeGetParent(this.ptr);
+        return ptr ? new Node(ptr) : null;
+    }
+    // Layout
+    calculateLayout(width, height, direction = Direction.LTR) {
+        if (this._freed)
+            return;
+        const w = width === "auto" || width === undefined ? NaN : width;
+        const h = height === "auto" || height === undefined ? NaN : height;
+        yg.ygNodeCalculateLayout(this.ptr, w, h, direction);
+    }
+    hasNewLayout() {
+        if (this._freed)
+            return false;
+        return yg.ygNodeGetHasNewLayout(this.ptr);
+    }
+    markLayoutSeen() {
+        if (this._freed)
+            return;
+        yg.ygNodeSetHasNewLayout(this.ptr, false);
+    }
+    markDirty() {
+        if (this._freed)
+            return;
+        yg.ygNodeMarkDirty(this.ptr);
+    }
+    isDirty() {
+        if (this._freed)
+            return true; // yoga-layout returns true for freed nodes
+        return yg.ygNodeIsDirty(this.ptr);
+    }
+    // Layout results
+    getComputedLayout() {
+        if (this._freed)
+            return { left: 0, top: 0, right: 0, bottom: 0, width: 0, height: 0 };
+        return {
+            left: yg.ygNodeLayoutGetLeft(this.ptr),
+            top: yg.ygNodeLayoutGetTop(this.ptr),
+            right: yg.ygNodeLayoutGetRight(this.ptr),
+            bottom: yg.ygNodeLayoutGetBottom(this.ptr),
+            width: yg.ygNodeLayoutGetWidth(this.ptr),
+            height: yg.ygNodeLayoutGetHeight(this.ptr),
+        };
+    }
+    getComputedLeft() {
+        if (this._freed)
+            return 0;
+        return yg.ygNodeLayoutGetLeft(this.ptr);
+    }
+    getComputedTop() {
+        if (this._freed)
+            return 0;
+        return yg.ygNodeLayoutGetTop(this.ptr);
+    }
+    getComputedRight() {
+        if (this._freed)
+            return 0;
+        return yg.ygNodeLayoutGetRight(this.ptr);
+    }
+    getComputedBottom() {
+        if (this._freed)
+            return 0;
+        return yg.ygNodeLayoutGetBottom(this.ptr);
+    }
+    getComputedWidth() {
+        if (this._freed)
+            return 0;
+        return yg.ygNodeLayoutGetWidth(this.ptr);
+    }
+    getComputedHeight() {
+        if (this._freed)
+            return 0;
+        return yg.ygNodeLayoutGetHeight(this.ptr);
+    }
+    getComputedRawWidth() {
+        if (this._freed)
+            return 0;
+        return yg.ygNodeLayoutGetRawWidth(this.ptr);
+    }
+    getComputedRawHeight() {
+        if (this._freed)
+            return 0;
+        return yg.ygNodeLayoutGetRawHeight(this.ptr);
+    }
+    getComputedBorder(edge) {
+        if (this._freed)
+            return 0;
+        return yg.ygNodeLayoutGetBorder(this.ptr, edge);
+    }
+    getComputedMargin(edge) {
+        if (this._freed)
+            return 0;
+        return yg.ygNodeLayoutGetMargin(this.ptr, edge);
+    }
+    getComputedPadding(edge) {
+        if (this._freed)
+            return 0;
+        return yg.ygNodeLayoutGetPadding(this.ptr, edge);
+    }
+    // Style setters
+    setDirection(direction) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetDirection(this.ptr, direction);
+    }
+    getDirection() {
+        if (this._freed)
+            return Direction.Inherit;
+        return yg.ygNodeStyleGetDirection(this.ptr);
+    }
+    setFlexDirection(flexDirection) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetFlexDirection(this.ptr, flexDirection);
+    }
+    getFlexDirection() {
+        if (this._freed)
+            return FlexDirection.Column;
+        return yg.ygNodeStyleGetFlexDirection(this.ptr);
+    }
+    setJustifyContent(justifyContent) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetJustifyContent(this.ptr, justifyContent);
+    }
+    getJustifyContent() {
+        if (this._freed)
+            return Justify.FlexStart;
+        return yg.ygNodeStyleGetJustifyContent(this.ptr);
+    }
+    setAlignContent(alignContent) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetAlignContent(this.ptr, alignContent);
+    }
+    getAlignContent() {
+        if (this._freed)
+            return Align.Auto;
+        return yg.ygNodeStyleGetAlignContent(this.ptr);
+    }
+    setAlignItems(alignItems) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetAlignItems(this.ptr, alignItems);
+    }
+    getAlignItems() {
+        if (this._freed)
+            return Align.Auto;
+        return yg.ygNodeStyleGetAlignItems(this.ptr);
+    }
+    setAlignSelf(alignSelf) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetAlignSelf(this.ptr, alignSelf);
+    }
+    getAlignSelf() {
+        if (this._freed)
+            return Align.Auto;
+        return yg.ygNodeStyleGetAlignSelf(this.ptr);
+    }
+    setPositionType(positionType) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetPositionType(this.ptr, positionType);
+    }
+    getPositionType() {
+        if (this._freed)
+            return PositionType.Static;
+        return yg.ygNodeStyleGetPositionType(this.ptr);
+    }
+    setFlexWrap(flexWrap) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetFlexWrap(this.ptr, flexWrap);
+    }
+    getFlexWrap() {
+        if (this._freed)
+            return Wrap.NoWrap;
+        return yg.ygNodeStyleGetFlexWrap(this.ptr);
+    }
+    setOverflow(overflow) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetOverflow(this.ptr, overflow);
+    }
+    getOverflow() {
+        if (this._freed)
+            return Overflow.Visible;
+        return yg.ygNodeStyleGetOverflow(this.ptr);
+    }
+    setDisplay(display) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetDisplay(this.ptr, display);
+    }
+    getDisplay() {
+        if (this._freed)
+            return Display.Flex;
+        return yg.ygNodeStyleGetDisplay(this.ptr);
+    }
+    setBoxSizing(boxSizing) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetBoxSizing(this.ptr, boxSizing);
+    }
+    getBoxSizing() {
+        if (this._freed)
+            return BoxSizing.BorderBox;
+        return yg.ygNodeStyleGetBoxSizing(this.ptr);
+    }
+    setFlex(flex) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetFlex(this.ptr, flex);
+    }
+    getFlex() {
+        if (this._freed)
+            return NaN;
+        return yg.ygNodeStyleGetFlex(this.ptr);
+    }
+    setFlexGrow(flexGrow) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetFlexGrow(this.ptr, flexGrow);
+    }
+    getFlexGrow() {
+        if (this._freed)
+            return NaN;
+        return yg.ygNodeStyleGetFlexGrow(this.ptr);
+    }
+    setFlexShrink(flexShrink) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetFlexShrink(this.ptr, flexShrink);
+    }
+    getFlexShrink() {
+        if (this._freed)
+            return NaN;
+        return yg.ygNodeStyleGetFlexShrink(this.ptr);
+    }
+    setFlexBasis(flexBasis) {
+        if (this._freed)
+            return;
+        const { unit, asNumber } = parseValue(flexBasis);
+        if (unit === Unit.Auto) {
+            yg.ygNodeStyleSetFlexBasisAuto(this.ptr);
+        }
+        else if (unit === Unit.Percent) {
+            yg.ygNodeStyleSetFlexBasisPercent(this.ptr, asNumber);
+        }
+        else if (unit === Unit.Point && asNumber !== undefined) {
+            yg.ygNodeStyleSetFlexBasis(this.ptr, asNumber);
+        }
+    }
+    setFlexBasisPercent(flexBasis) {
+        if (this._freed)
+            return;
+        if (flexBasis !== undefined) {
+            yg.ygNodeStyleSetFlexBasisPercent(this.ptr, flexBasis);
+        }
+    }
+    setFlexBasisAuto() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetFlexBasisAuto(this.ptr);
+    }
+    setFlexBasisMaxContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetFlexBasisMaxContent(this.ptr);
+    }
+    setFlexBasisFitContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetFlexBasisFitContent(this.ptr);
+    }
+    setFlexBasisStretch() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetFlexBasisStretch(this.ptr);
+    }
+    setPosition(edge, position) {
+        if (this._freed)
+            return;
+        const { unit, asNumber } = parseValue(position);
+        if (unit === Unit.Percent) {
+            yg.ygNodeStyleSetPositionPercent(this.ptr, edge, asNumber);
+        }
+        else if (unit === Unit.Point && asNumber !== undefined) {
+            yg.ygNodeStyleSetPosition(this.ptr, edge, asNumber);
+        }
+    }
+    setPositionPercent(edge, position) {
+        if (this._freed)
+            return;
+        if (position !== undefined) {
+            yg.ygNodeStyleSetPositionPercent(this.ptr, edge, position);
+        }
+    }
+    setPositionAuto(edge) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetPositionAuto(this.ptr, edge);
+    }
+    setMargin(edge, margin) {
+        if (this._freed)
+            return;
+        const { unit, asNumber } = parseValue(margin);
+        if (unit === Unit.Auto) {
+            yg.ygNodeStyleSetMarginAuto(this.ptr, edge);
+        }
+        else if (unit === Unit.Percent) {
+            yg.ygNodeStyleSetMarginPercent(this.ptr, edge, asNumber);
+        }
+        else if (unit === Unit.Point && asNumber !== undefined) {
+            yg.ygNodeStyleSetMargin(this.ptr, edge, asNumber);
+        }
+    }
+    setMarginPercent(edge, margin) {
+        if (this._freed)
+            return;
+        if (margin !== undefined) {
+            yg.ygNodeStyleSetMarginPercent(this.ptr, edge, margin);
+        }
+    }
+    setMarginAuto(edge) {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMarginAuto(this.ptr, edge);
+    }
+    setPadding(edge, padding) {
+        if (this._freed)
+            return;
+        const { unit, asNumber } = parseValue(padding);
+        if (unit === Unit.Percent) {
+            yg.ygNodeStyleSetPaddingPercent(this.ptr, edge, asNumber);
+        }
+        else if (unit === Unit.Point && asNumber !== undefined) {
+            yg.ygNodeStyleSetPadding(this.ptr, edge, asNumber);
+        }
+    }
+    setPaddingPercent(edge, padding) {
+        if (this._freed)
+            return;
+        if (padding !== undefined) {
+            yg.ygNodeStyleSetPaddingPercent(this.ptr, edge, padding);
+        }
+    }
+    setBorder(edge, border) {
+        if (this._freed)
+            return;
+        if (border !== undefined) {
+            yg.ygNodeStyleSetBorder(this.ptr, edge, border);
+        }
+    }
+    getBorder(edge) {
+        if (this._freed)
+            return NaN;
+        return yg.ygNodeStyleGetBorder(this.ptr, edge);
+    }
+    setGap(gutter, gap) {
+        if (this._freed)
+            return;
+        const { unit, asNumber } = parseValue(gap);
+        if (unit === Unit.Percent) {
+            yg.ygNodeStyleSetGapPercent(this.ptr, gutter, asNumber);
+        }
+        else if (unit === Unit.Point && asNumber !== undefined) {
+            yg.ygNodeStyleSetGap(this.ptr, gutter, asNumber);
+        }
+    }
+    setGapPercent(gutter, gap) {
+        if (this._freed)
+            return;
+        if (gap !== undefined) {
+            yg.ygNodeStyleSetGapPercent(this.ptr, gutter, gap);
+        }
+    }
+    setWidth(width) {
+        if (this._freed)
+            return;
+        const { unit, asNumber } = parseValue(width);
+        if (unit === Unit.Auto) {
+            yg.ygNodeStyleSetWidthAuto(this.ptr);
+        }
+        else if (unit === Unit.Percent) {
+            yg.ygNodeStyleSetWidthPercent(this.ptr, asNumber);
+        }
+        else if (unit === Unit.Point && asNumber !== undefined) {
+            yg.ygNodeStyleSetWidth(this.ptr, asNumber);
+        }
+    }
+    setWidthPercent(width) {
+        if (this._freed)
+            return;
+        if (width !== undefined) {
+            yg.ygNodeStyleSetWidthPercent(this.ptr, width);
+        }
+    }
+    setWidthAuto() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetWidthAuto(this.ptr);
+    }
+    setWidthMaxContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetWidthMaxContent(this.ptr);
+    }
+    setWidthFitContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetWidthFitContent(this.ptr);
+    }
+    setWidthStretch() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetWidthStretch(this.ptr);
+    }
+    setHeight(height) {
+        if (this._freed)
+            return;
+        const { unit, asNumber } = parseValue(height);
+        if (unit === Unit.Auto) {
+            yg.ygNodeStyleSetHeightAuto(this.ptr);
+        }
+        else if (unit === Unit.Percent) {
+            yg.ygNodeStyleSetHeightPercent(this.ptr, asNumber);
+        }
+        else if (unit === Unit.Point && asNumber !== undefined) {
+            yg.ygNodeStyleSetHeight(this.ptr, asNumber);
+        }
+    }
+    setHeightPercent(height) {
+        if (this._freed)
+            return;
+        if (height !== undefined) {
+            yg.ygNodeStyleSetHeightPercent(this.ptr, height);
+        }
+    }
+    setHeightAuto() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetHeightAuto(this.ptr);
+    }
+    setHeightMaxContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetHeightMaxContent(this.ptr);
+    }
+    setHeightFitContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetHeightFitContent(this.ptr);
+    }
+    setHeightStretch() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetHeightStretch(this.ptr);
+    }
+    setMinWidth(minWidth) {
+        if (this._freed)
+            return;
+        const { unit, asNumber } = parseValue(minWidth);
+        if (unit === Unit.Percent) {
+            yg.ygNodeStyleSetMinWidthPercent(this.ptr, asNumber);
+        }
+        else if (unit === Unit.Point && asNumber !== undefined) {
+            yg.ygNodeStyleSetMinWidth(this.ptr, asNumber);
+        }
+    }
+    setMinWidthPercent(minWidth) {
+        if (this._freed)
+            return;
+        if (minWidth !== undefined) {
+            yg.ygNodeStyleSetMinWidthPercent(this.ptr, minWidth);
+        }
+    }
+    setMinWidthMaxContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMinWidthMaxContent(this.ptr);
+    }
+    setMinWidthFitContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMinWidthFitContent(this.ptr);
+    }
+    setMinWidthStretch() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMinWidthStretch(this.ptr);
+    }
+    setMinHeight(minHeight) {
+        if (this._freed)
+            return;
+        const { unit, asNumber } = parseValue(minHeight);
+        if (unit === Unit.Percent) {
+            yg.ygNodeStyleSetMinHeightPercent(this.ptr, asNumber);
+        }
+        else if (unit === Unit.Point && asNumber !== undefined) {
+            yg.ygNodeStyleSetMinHeight(this.ptr, asNumber);
+        }
+    }
+    setMinHeightPercent(minHeight) {
+        if (this._freed)
+            return;
+        if (minHeight !== undefined) {
+            yg.ygNodeStyleSetMinHeightPercent(this.ptr, minHeight);
+        }
+    }
+    setMinHeightMaxContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMinHeightMaxContent(this.ptr);
+    }
+    setMinHeightFitContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMinHeightFitContent(this.ptr);
+    }
+    setMinHeightStretch() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMinHeightStretch(this.ptr);
+    }
+    setMaxWidth(maxWidth) {
+        if (this._freed)
+            return;
+        const { unit, asNumber } = parseValue(maxWidth);
+        if (unit === Unit.Percent) {
+            yg.ygNodeStyleSetMaxWidthPercent(this.ptr, asNumber);
+        }
+        else if (unit === Unit.Point && asNumber !== undefined) {
+            yg.ygNodeStyleSetMaxWidth(this.ptr, asNumber);
+        }
+    }
+    setMaxWidthPercent(maxWidth) {
+        if (this._freed)
+            return;
+        if (maxWidth !== undefined) {
+            yg.ygNodeStyleSetMaxWidthPercent(this.ptr, maxWidth);
+        }
+    }
+    setMaxWidthMaxContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMaxWidthMaxContent(this.ptr);
+    }
+    setMaxWidthFitContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMaxWidthFitContent(this.ptr);
+    }
+    setMaxWidthStretch() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMaxWidthStretch(this.ptr);
+    }
+    setMaxHeight(maxHeight) {
+        if (this._freed)
+            return;
+        const { unit, asNumber } = parseValue(maxHeight);
+        if (unit === Unit.Percent) {
+            yg.ygNodeStyleSetMaxHeightPercent(this.ptr, asNumber);
+        }
+        else if (unit === Unit.Point && asNumber !== undefined) {
+            yg.ygNodeStyleSetMaxHeight(this.ptr, asNumber);
+        }
+    }
+    setMaxHeightPercent(maxHeight) {
+        if (this._freed)
+            return;
+        if (maxHeight !== undefined) {
+            yg.ygNodeStyleSetMaxHeightPercent(this.ptr, maxHeight);
+        }
+    }
+    setMaxHeightMaxContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMaxHeightMaxContent(this.ptr);
+    }
+    setMaxHeightFitContent() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMaxHeightFitContent(this.ptr);
+    }
+    setMaxHeightStretch() {
+        if (this._freed)
+            return;
+        yg.ygNodeStyleSetMaxHeightStretch(this.ptr);
+    }
+    setAspectRatio(aspectRatio) {
+        if (this._freed)
+            return;
+        if (aspectRatio !== undefined) {
+            yg.ygNodeStyleSetAspectRatio(this.ptr, aspectRatio);
+        }
+    }
+    getAspectRatio() {
+        if (this._freed)
+            return NaN;
+        return yg.ygNodeStyleGetAspectRatio(this.ptr);
+    }
+    // Value getters (return {unit, value} like yoga-layout)
+    getWidth() {
+        if (this._freed)
+            return UNDEFINED_VALUE;
+        return unpackValue(yg.ygNodeStyleGetWidthPacked(this.ptr));
+    }
+    getHeight() {
+        if (this._freed)
+            return UNDEFINED_VALUE;
+        return unpackValue(yg.ygNodeStyleGetHeightPacked(this.ptr));
+    }
+    getMinWidth() {
+        if (this._freed)
+            return UNDEFINED_VALUE;
+        return unpackValue(yg.ygNodeStyleGetMinWidthPacked(this.ptr));
+    }
+    getMinHeight() {
+        if (this._freed)
+            return UNDEFINED_VALUE;
+        return unpackValue(yg.ygNodeStyleGetMinHeightPacked(this.ptr));
+    }
+    getMaxWidth() {
+        if (this._freed)
+            return UNDEFINED_VALUE;
+        return unpackValue(yg.ygNodeStyleGetMaxWidthPacked(this.ptr));
+    }
+    getMaxHeight() {
+        if (this._freed)
+            return UNDEFINED_VALUE;
+        return unpackValue(yg.ygNodeStyleGetMaxHeightPacked(this.ptr));
+    }
+    getMargin(edge) {
+        if (this._freed)
+            return UNDEFINED_VALUE;
+        return unpackValue(yg.ygNodeStyleGetMarginPacked(this.ptr, edge));
+    }
+    getPadding(edge) {
+        if (this._freed)
+            return UNDEFINED_VALUE;
+        return unpackValue(yg.ygNodeStyleGetPaddingPacked(this.ptr, edge));
+    }
+    getPosition(edge) {
+        if (this._freed)
+            return UNDEFINED_VALUE;
+        return unpackValue(yg.ygNodeStyleGetPositionPacked(this.ptr, edge));
+    }
+    getGap(gutter) {
+        if (this._freed)
+            return UNDEFINED_VALUE;
+        return unpackValue(yg.ygNodeStyleGetGapPacked(this.ptr, gutter));
+    }
+    getFlexBasis() {
+        if (this._freed)
+            return UNDEFINED_VALUE;
+        return unpackValue(yg.ygNodeStyleGetFlexBasisPacked(this.ptr));
+    }
+    // Callback functions
+    setMeasureFunc(measureFunc) {
+        if (this._freed)
+            return;
+        this.unsetMeasureFunc(); // Clean up existing callback
+        if (measureFunc) {
+            // Use trampoline approach to work around ARM64 ABI limitations
+            // The trampoline doesn't return the result directly - instead it stores
+            // the result via ygStoreMeasureResult, and our Zig wrapper reads it
+            this.measureCallback = new JSCallback((nodePtr, width, widthMode, height, heightMode) => {
+                const result = measureFunc(width, widthMode, height, heightMode);
+                // Store the result for the Zig wrapper to read
+                yg.ygStoreMeasureResult(result.width, result.height);
+            }, {
+                args: [
+                    FFIType.ptr,
+                    FFIType.f32,
+                    FFIType.u32,
+                    FFIType.f32,
+                    FFIType.u32,
+                ],
+                returns: FFIType.void,
+            });
+            if (this.measureCallback.ptr) {
+                yg.ygNodeSetMeasureFuncTrampoline(this.ptr, this.measureCallback.ptr);
+            }
+        }
+    }
+    unsetMeasureFunc() {
+        if (this._freed)
+            return; // Skip if already freed
+        if (this.measureCallback) {
+            this.measureCallback.close();
+            this.measureCallback = null;
+        }
+        yg.ygNodeUnsetMeasureFuncTrampoline(this.ptr);
+    }
+    hasMeasureFunc() {
+        if (this._freed)
+            return false;
+        return yg.ygNodeHasMeasureFunc(this.ptr);
+    }
+    setBaselineFunc(baselineFunc) {
+        if (this._freed)
+            return;
+        this.unsetBaselineFunc(); // Clean up existing callback
+        if (baselineFunc) {
+            // Use trampoline approach to work around ARM64 ABI limitations
+            // The trampoline stores the result via ygStoreBaselineResult
+            this.baselineCallback = new JSCallback((nodePtr, width, height) => {
+                const result = baselineFunc(width, height);
+                yg.ygStoreBaselineResult(result);
+            }, {
+                args: [FFIType.ptr, FFIType.f32, FFIType.f32],
+                returns: FFIType.void,
+            });
+            if (this.baselineCallback.ptr) {
+                yg.ygNodeSetBaselineFuncTrampoline(this.ptr, this.baselineCallback.ptr);
+            }
+        }
+    }
+    unsetBaselineFunc() {
+        if (this._freed)
+            return; // Skip if already freed
+        if (this.baselineCallback) {
+            this.baselineCallback.close();
+            this.baselineCallback = null;
+        }
+        yg.ygNodeUnsetBaselineFuncTrampoline(this.ptr);
+    }
+    hasBaselineFunc() {
+        if (this._freed)
+            return false;
+        return yg.ygNodeHasBaselineFunc(this.ptr);
+    }
+    setDirtiedFunc(dirtiedFunc) {
+        if (this._freed)
+            return;
+        this.unsetDirtiedFunc(); // Clean up existing callback
+        if (dirtiedFunc) {
+            // Capture this node instance for the callback
+            const node = this;
+            // Create a JSCallback that matches Yoga's expected dirtied function signature
+            this.dirtiedCallback = new JSCallback((nodePtr) => {
+                dirtiedFunc(node);
+            }, {
+                args: [FFIType.ptr],
+                returns: FFIType.void,
+            });
+            if (this.dirtiedCallback.ptr) {
+                yg.ygNodeSetDirtiedFunc(this.ptr, this.dirtiedCallback.ptr);
+            }
+        }
+    }
+    unsetDirtiedFunc() {
+        if (this._freed)
+            return; // Skip if already freed
+        if (this.dirtiedCallback) {
+            this.dirtiedCallback.close();
+            this.dirtiedCallback = null;
+        }
+        yg.ygNodeUnsetDirtiedFunc(this.ptr);
+    }
+    hasDirtiedFunc() {
+        if (this._freed)
+            return false;
+        return Boolean(yg.ygNodeGetDirtiedFunc(this.ptr));
+    }
+}
+// ============================================================================
+// Config class
+// ============================================================================
+export class Config {
+    ptr;
+    constructor(ptr) {
+        this.ptr = ptr;
+    }
+    static create() {
+        const ptr = yg.ygConfigNew();
+        if (!ptr)
+            throw new Error("Failed to create config");
+        return new Config(ptr);
+    }
+    static destroy(config) {
+        config.free();
+    }
+    free() {
+        yg.ygConfigFree(this.ptr);
+    }
+    setUseWebDefaults(useWebDefaults) {
+        yg.ygConfigSetUseWebDefaults(this.ptr, useWebDefaults);
+    }
+    useWebDefaults() {
+        return yg.ygConfigGetUseWebDefaults(this.ptr);
+    }
+    setPointScaleFactor(pointScaleFactor) {
+        yg.ygConfigSetPointScaleFactor(this.ptr, pointScaleFactor);
+    }
+    getPointScaleFactor() {
+        return yg.ygConfigGetPointScaleFactor(this.ptr);
+    }
+    setErrata(errata) {
+        yg.ygConfigSetErrata(this.ptr, errata);
+    }
+    getErrata() {
+        return yg.ygConfigGetErrata(this.ptr);
+    }
+    setExperimentalFeatureEnabled(feature, enabled) {
+        yg.ygConfigSetExperimentalFeatureEnabled(this.ptr, feature, enabled);
+    }
+    isExperimentalFeatureEnabled(feature) {
+        return yg.ygConfigIsExperimentalFeatureEnabled(this.ptr, feature);
+    }
+}
+// Default export for yoga-layout compatibility
+export default {
+    Node,
+    Config,
+    // Enums
+    Align,
+    BoxSizing,
+    Dimension,
+    Direction,
+    Display,
+    Edge,
+    Errata,
+    ExperimentalFeature,
+    FlexDirection,
+    Gutter,
+    Justify,
+    LogLevel,
+    MeasureMode,
+    NodeType,
+    Overflow,
+    PositionType,
+    Unit,
+    Wrap,
+    // Constants
+    EDGE_LEFT,
+    EDGE_TOP,
+    EDGE_RIGHT,
+    EDGE_BOTTOM,
+    EDGE_START,
+    EDGE_END,
+    EDGE_HORIZONTAL,
+    EDGE_VERTICAL,
+    EDGE_ALL,
+    FLEX_DIRECTION_COLUMN,
+    FLEX_DIRECTION_COLUMN_REVERSE,
+    FLEX_DIRECTION_ROW,
+    FLEX_DIRECTION_ROW_REVERSE,
+    JUSTIFY_FLEX_START,
+    JUSTIFY_CENTER,
+    JUSTIFY_FLEX_END,
+    JUSTIFY_SPACE_BETWEEN,
+    JUSTIFY_SPACE_AROUND,
+    JUSTIFY_SPACE_EVENLY,
+    ALIGN_AUTO,
+    ALIGN_FLEX_START,
+    ALIGN_CENTER,
+    ALIGN_FLEX_END,
+    ALIGN_STRETCH,
+    ALIGN_BASELINE,
+    ALIGN_SPACE_BETWEEN,
+    ALIGN_SPACE_AROUND,
+    ALIGN_SPACE_EVENLY,
+    WRAP_NO_WRAP,
+    WRAP_WRAP,
+    WRAP_WRAP_REVERSE,
+    OVERFLOW_VISIBLE,
+    OVERFLOW_HIDDEN,
+    OVERFLOW_SCROLL,
+    DISPLAY_FLEX,
+    DISPLAY_NONE,
+    DISPLAY_CONTENTS,
+    POSITION_TYPE_STATIC,
+    POSITION_TYPE_RELATIVE,
+    POSITION_TYPE_ABSOLUTE,
+    DIRECTION_INHERIT,
+    DIRECTION_LTR,
+    DIRECTION_RTL,
+    BOX_SIZING_BORDER_BOX,
+    BOX_SIZING_CONTENT_BOX,
+    DIMENSION_WIDTH,
+    DIMENSION_HEIGHT,
+    GUTTER_COLUMN,
+    GUTTER_ROW,
+    GUTTER_ALL,
+    UNIT_UNDEFINED,
+    UNIT_POINT,
+    UNIT_PERCENT,
+    UNIT_AUTO,
+    UNIT_MAX_CONTENT,
+    UNIT_FIT_CONTENT,
+    UNIT_STRETCH,
+    MEASURE_MODE_UNDEFINED,
+    MEASURE_MODE_EXACTLY,
+    MEASURE_MODE_AT_MOST,
+    NODE_TYPE_DEFAULT,
+    NODE_TYPE_TEXT,
+    LOG_LEVEL_ERROR,
+    LOG_LEVEL_WARN,
+    LOG_LEVEL_INFO,
+    LOG_LEVEL_DEBUG,
+    LOG_LEVEL_VERBOSE,
+    LOG_LEVEL_FATAL,
+    EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS,
+    ERRATA_NONE,
+    ERRATA_STRETCH_FLEX_BASIS,
+    ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING,
+    ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE,
+    ERRATA_ALL,
+    ERRATA_CLASSIC,
+};