@cimplify/sdk 0.108.0 → 0.110.2

package/dist/vars-Dc_PrhBK.d.ts

@@ -0,0 +1,511 @@
+declare const UI_MAGIC = 826889539;
+declare const UI_VERSION = 1;
+declare const UI_HEADER_BYTES = 12;
+declare const UI_RECORD_HEADER_WORDS = 2;
+declare const UI_EVENT_BYTES = 32;
+declare const NO_NODE = 4294967295;
+declare const UiOp: {
+    readonly create: 1;
+    readonly destroy: 2;
+    readonly insert: 3;
+    readonly remove: 4;
+    readonly root: 5;
+    readonly world_root: 6;
+    readonly unroot: 7;
+    readonly prop: 8;
+    readonly text: 9;
+    readonly number: 10;
+    readonly string: 11;
+    readonly text_ref: 12;
+    readonly label: 13;
+    readonly value: 14;
+    readonly placeholder: 15;
+    readonly image: 16;
+    readonly path: 17;
+    readonly transition: 18;
+    readonly scroll_to: 19;
+    readonly focus: 20;
+    readonly blur: 21;
+    readonly font: 22;
+    readonly anchor: 23;
+    readonly occluded: 24;
+    readonly style: 25;
+    readonly style_clear: 26;
+    readonly tokens: 27;
+    readonly slots: 28;
+    readonly exclusions: 29;
+    readonly text_options: 30;
+    readonly vector_load: 31;
+    readonly vector_unload: 32;
+    readonly vector: 33;
+    readonly vector_detach: 34;
+    readonly vector_play: 35;
+    readonly vector_input: 36;
+    readonly vector_input_name: 37;
+    readonly vector_data: 38;
+    readonly vector_seek: 39;
+};
+declare const UiVectorPlay: {
+    readonly machine: 0;
+    readonly animation: 1;
+    readonly stop: 2;
+};
+type UiVectorPlayKind = (typeof UiVectorPlay)[keyof typeof UiVectorPlay];
+type UiVectorSeekKind = typeof UiVectorPlay.machine | typeof UiVectorPlay.animation;
+declare const UiVectorData: {
+    readonly number: 0;
+    readonly bool: 1;
+    readonly color: 2;
+    readonly id: 3;
+    readonly fire: 4;
+};
+type UiVectorDataKind = (typeof UiVectorData)[keyof typeof UiVectorData];
+declare const UiTextOption: {
+    readonly dictionaries: 1;
+    readonly data: 2;
+};
+declare const UiExclusionShape: {
+    readonly rect: 0;
+    readonly ellipse: 1;
+    readonly polygon: 2;
+};
+declare const UI_EXCLUSION_HEADER_WORDS = 7;
+declare const UI_MAX_EXCLUSIONS = 8;
+interface ExclusionRecord {
+    shape: number;
+    sibling: number;
+    margin: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    points: ArrayLike<number> | null;
+}
+declare const UI_TOKENS_REPLACE = 1;
+declare const UI_SLOT_REFERENCE = 2147483648;
+declare const UI_STYLE_REFERENCED: number;
+declare const UI_STYLE_SAFE_EDGES: number;
+declare const UiKind: {
+    readonly box: 0;
+    readonly text: 1;
+    readonly image: 2;
+    readonly shape: 3;
+    readonly scroll: 4;
+    readonly input: 5;
+    readonly vector: 6;
+};
+type UiKindName = keyof typeof UiKind;
+declare const UiProp: {
+    readonly width: 0;
+    readonly height: 1;
+    readonly min_width: 2;
+    readonly min_height: 3;
+    readonly max_width: 4;
+    readonly max_height: 5;
+    readonly basis: 6;
+    readonly padding: 7;
+    readonly margin: 8;
+    readonly border_width: 9;
+    readonly inset_top: 10;
+    readonly inset_right: 11;
+    readonly inset_bottom: 12;
+    readonly inset_left: 13;
+    readonly gap: 14;
+    readonly grow: 15;
+    readonly shrink: 16;
+    readonly aspect: 17;
+    readonly direction: 18;
+    readonly justify: 19;
+    readonly align_items: 20;
+    readonly align_self: 21;
+    readonly align_content: 22;
+    readonly position: 23;
+    readonly wrap: 24;
+    readonly display_none: 25;
+    readonly fill: 32;
+    readonly border_color: 33;
+    readonly radii: 34;
+    readonly opacity: 35;
+    readonly translate: 36;
+    readonly scale: 37;
+    readonly rotate: 38;
+    readonly origin: 39;
+    readonly z_index: 40;
+    readonly hidden: 41;
+    readonly clip: 42;
+    readonly pointer_events_none: 43;
+    readonly flags: 44;
+    readonly shadow: 45;
+    readonly gradient: 46;
+    readonly disabled: 47;
+    readonly focusable: 48;
+    readonly font_family: 64;
+    readonly font_weight: 65;
+    readonly font_size: 66;
+    readonly line_height: 67;
+    readonly letter_spacing: 68;
+    readonly text_align: 69;
+    readonly text_color: 70;
+    readonly text_wrap: 71;
+    readonly vertical_align: 72;
+    readonly placeholder_color: 73;
+    readonly text_wrap_style: 74;
+    readonly image_tint: 80;
+    readonly image_uv: 81;
+    readonly nine_slice: 82;
+    readonly nine_slice_uv: 83;
+    readonly shape_kind: 96;
+    readonly stroke_color: 97;
+    readonly stroke_width: 98;
+    readonly scroll_axes: 112;
+    readonly role: 128;
+    readonly traits: 129;
+    readonly actions: 130;
+};
+declare const UiUnit: {
+    readonly auto: 0;
+    readonly points: 1;
+    readonly percent: 2;
+};
+declare const UiFlag: {
+    readonly tap: number;
+    readonly press: number;
+    readonly drag: number;
+    readonly long_press: number;
+    readonly layer: number;
+    readonly secure: number;
+};
+declare const UiNumberFormat: {
+    readonly integer: 0;
+    readonly fixed: 1;
+    readonly timer: 2;
+    readonly timer_hours: 3;
+    readonly compact: 4;
+    readonly percent: 5;
+};
+type UiNumberFormatName = keyof typeof UiNumberFormat;
+declare const UiEasing: {
+    readonly linear: 0;
+    readonly ease: 1;
+    readonly ease_in: 2;
+    readonly ease_out: 3;
+    readonly ease_in_out: 4;
+    readonly back_out: 5;
+    readonly bezier: 6;
+    readonly spring: 7;
+};
+type UiEasingName = keyof typeof UiEasing;
+declare const UiTransition: {
+    readonly opacity: number;
+    readonly translate_x: number;
+    readonly translate_y: number;
+    readonly scale_x: number;
+    readonly scale_y: number;
+    readonly rotate: number;
+    readonly fill: number;
+    readonly text_color: number;
+};
+type UiTransitionName = keyof typeof UiTransition;
+declare const UiAnchor: {
+    readonly top_left: 0;
+    readonly top: 1;
+    readonly top_right: 2;
+    readonly left: 3;
+    readonly center: 4;
+    readonly right: 5;
+    readonly bottom_left: 6;
+    readonly bottom: 7;
+    readonly bottom_right: 8;
+    readonly fill: 9;
+};
+type UiAnchorName = keyof typeof UiAnchor;
+declare const UiRole: {
+    readonly none: 0;
+    readonly group: 1;
+    readonly text: 2;
+    readonly button: 3;
+    readonly image: 4;
+    readonly header: 5;
+    readonly link: 6;
+    readonly adjustable: 7;
+    readonly tab: 8;
+    readonly tab_list: 9;
+    readonly progress: 10;
+    readonly text_field: 11;
+    readonly scroll_view: 12;
+    readonly alert: 13;
+};
+type UiRoleName = keyof typeof UiRole;
+declare const UiTrait: {
+    readonly selected: 1;
+    readonly disabled: number;
+    readonly hidden: number;
+    readonly live: number;
+    readonly modal: number;
+};
+declare const UiAction: {
+    readonly activate: 1;
+    readonly increment: number;
+    readonly decrement: number;
+    readonly dismiss: number;
+    readonly scroll: number;
+};
+declare const UiEventKind: {
+    readonly press: 1;
+    readonly release: 2;
+    readonly tap: 3;
+    readonly long_press: 4;
+    readonly drag_start: 5;
+    readonly drag_move: 6;
+    readonly drag_end: 7;
+    readonly scroll: 8;
+    readonly focus: 9;
+    readonly action: 10;
+    readonly passthrough: 11;
+    readonly change: 12;
+    readonly blur: 13;
+    readonly vector: 14;
+};
+type UiEventName = keyof typeof UiEventKind;
+declare const UiFocusFlag: {
+    readonly secure: 1;
+    readonly numeric: 2;
+};
+declare const UI_EVENT_KIND_OFFSET = 0;
+declare const UI_EVENT_PHASE_OFFSET = 1;
+declare const UI_EVENT_POINTER_OFFSET = 2;
+declare const UI_EVENT_NODE_OFFSET = 4;
+declare const UI_EVENT_X_OFFSET = 8;
+declare const UI_EVENT_Y_OFFSET = 12;
+declare const UI_EVENT_DX_OFFSET = 16;
+declare const UI_EVENT_DY_OFFSET = 20;
+declare const UI_EVENT_VALUE_OFFSET = 24;
+declare const UI_EVENT_TIME_OFFSET = 28;
+interface WorldRootRecord {
+    readonly position: readonly [number, number, number];
+    readonly pivot: readonly [number, number];
+    readonly offset: readonly [number, number];
+    readonly reference_distance: number;
+    readonly min_scale: number;
+    readonly max_scale: number;
+    readonly hide_when_occluded: boolean;
+    readonly occluded_opacity: number;
+    readonly z: number;
+}
+declare class PatchWriter {
+    private buffer;
+    private view;
+    private words;
+    private floats;
+    private cursor;
+    private count;
+    private readonly reserve;
+    constructor(capacity?: number, reserve?: number);
+    get bytes(): Uint8Array;
+    get length(): number;
+    get records(): number;
+    get empty(): boolean;
+    reset(): void;
+    finish(): number;
+    private ensure;
+    private record;
+    private u32;
+    private f32;
+    private simple;
+    create(node: number, kind: number): void;
+    destroy(node: number): void;
+    insert(node: number, parent: number, before?: number): void;
+    remove(node: number): void;
+    root(node: number, anchor: number, safe_area: boolean, x: number, y: number, z: number): void;
+    worldRoot(node: number, root: WorldRootRecord): void;
+    unroot(node: number): void;
+    propWord(node: number, prop: number, word: number, unit?: number): void;
+    propFloat(node: number, prop: number, value: number, unit?: number): void;
+    propWordAt(node: number, prop: number, values: ArrayLike<number>, index: number, unit?: number): void;
+    propFloatAt(node: number, prop: number, values: ArrayLike<number>, index: number, unit?: number): void;
+    propFloats(node: number, prop: number, values: ArrayLike<number>): void;
+    propF32(node: number, prop: number, values: Float32Array): void;
+    propWords(node: number, prop: number, values: ArrayLike<number>): void;
+    propMixed(node: number, prop: number, words: ArrayLike<number>, floats: ArrayLike<number>): void;
+    private textual;
+    text(node: number, text: string): void;
+    textPrefix(node: number, text: string, length: number): void;
+    string(id: number, text: string): void;
+    label(node: number, text: string): void;
+    value(node: number, text: string): void;
+    placeholder(node: number, text: string): void;
+    textRef(node: number, id: number): void;
+    number(node: number, value: number, format: number, decimals: number, separator: number): void;
+    image(node: number, asset: number, width: number, height: number): void;
+    path(node: number, points: ArrayLike<number>): void;
+    transition(node: number, mask: number, duration: number, easing: number, params: ArrayLike<number> | null): void;
+    scrollTo(node: number, x: number, y: number): void;
+    focus(node: number): void;
+    blur(node: number): void;
+    font(family: number, weight: number, font: number): void;
+    textOptions(flags: number): void;
+    textDictionaries(bytes: Uint8Array): void;
+    vectorLoad(asset: number, bytes: Uint8Array): void;
+    vectorUnload(asset: number): void;
+    vector(node: number, asset: number, artboard: number): void;
+    vectorDetach(node: number): void;
+    vectorPlay(node: number, kind: number, index: number): void;
+    vectorSeek(node: number, kind: UiVectorSeekKind, index: number, seconds: number): void;
+    vectorInput(node: number, input: number, value: number): void;
+    vectorInputName(node: number, name: Uint8Array, value: number): void;
+    vectorData(node: number, kind: UiVectorDataKind, path: Uint8Array, value: number, bits: number): void;
+    private sizedBytes;
+    anchor(node: number, x: number, y: number, z: number): void;
+    anchorFrom(node: number, values: ArrayLike<number>, offset: number): void;
+    occluded(node: number, occluded: boolean): void;
+    private open;
+    style(node: number, mask: number, words: ArrayLike<number>, slotBase?: number): void;
+    styleClear(node: number): void;
+    exclusions(node: number, entries: readonly ExclusionRecord[], count?: number): void;
+    tokens(replace: boolean, count: number): void;
+    pair(first: number, second: number): void;
+    slot(index: number, bits: number): void;
+    slotAt(index: number, values: Uint32Array, at: number): void;
+}
+interface GameUiEventView {
+    kind: number;
+    phase: number;
+    pointer: number;
+    node: number;
+    x: number;
+    y: number;
+    dx: number;
+    dy: number;
+    value: number;
+    time_ms: number;
+    text?: string;
+}
+declare function readEvent(view: DataView, offset: number, out: GameUiEventView): void;
+declare function textEventPadding(textBytes: number): number;
+declare function textEventCapacity(text: string): number;
+interface TextComposition {
+    readonly start: number;
+    readonly end: number;
+}
+declare function writeTextEvent(target: Uint8Array, offset: number, kind: number, node: number, text: string, time_ms: number, composition?: TextComposition | null): number;
+declare function textComposition(event: GameUiEventView): TextComposition | null;
+declare function codePointOffset(text: string, utf16: number): number;
+declare function eventStride(kind: number, view: DataView, offset: number): number;
+
+type UiLength = number | `${number}%` | "auto";
+type UiColor = number | string;
+type UiEdges = number | readonly [number, number, number, number];
+type UiAlign = "auto" | "start" | "end" | "center" | "stretch";
+interface UiShadow {
+    color: UiColor;
+    x?: number;
+    y?: number;
+    blur?: number;
+    spread?: number;
+}
+interface UiGradient {
+    kind?: "linear" | "radial";
+    stops: readonly (readonly [UiColor, number])[];
+    from?: readonly [number, number];
+    to?: readonly [number, number];
+}
+interface UiStyle {
+    width?: UiLength;
+    height?: UiLength;
+    minWidth?: UiLength;
+    minHeight?: UiLength;
+    maxWidth?: UiLength;
+    maxHeight?: UiLength;
+    basis?: UiLength;
+    top?: UiLength;
+    right?: UiLength;
+    bottom?: UiLength;
+    left?: UiLength;
+    padding?: UiEdges;
+    margin?: UiEdges;
+    borderWidth?: UiEdges;
+    gap?: number | readonly [number, number];
+    grow?: number;
+    shrink?: number;
+    aspect?: number;
+    direction?: "row" | "column" | "row-reverse" | "column-reverse";
+    justify?: "start" | "end" | "center" | "space-between" | "space-around" | "space-evenly";
+    alignItems?: UiAlign;
+    alignSelf?: UiAlign;
+    alignContent?: UiAlign;
+    position?: "relative" | "absolute";
+    wrap?: boolean;
+    display?: "flex" | "none";
+    fill?: UiColor;
+    borderColor?: UiColor | readonly [UiColor, UiColor, UiColor, UiColor];
+    radius?: UiEdges;
+    opacity?: number;
+    translate?: readonly [number, number];
+    scale?: number | readonly [number, number];
+    rotate?: number;
+    origin?: readonly [number, number];
+    zIndex?: number;
+    hidden?: boolean;
+    clip?: boolean;
+    pointerEvents?: "auto" | "none";
+    layer?: boolean;
+    shadow?: UiShadow | null;
+    gradient?: UiGradient | null;
+    fontFamily?: number;
+    fontWeight?: number;
+    fontSize?: number;
+    lineHeight?: number;
+    letterSpacing?: number;
+    textAlign?: "start" | "end" | "left" | "center" | "right";
+    textColor?: UiColor;
+    textWrap?: boolean;
+    textWrapStyle?: "greedy" | "balance" | "pretty";
+    verticalAlign?: "top" | "center" | "bottom";
+    placeholderColor?: UiColor;
+    tint?: UiColor;
+    uv?: readonly [number, number, number, number];
+    nineSlice?: UiEdges;
+    nineSliceUv?: UiEdges;
+    shape?: "rect" | "ellipse" | "path";
+    stroke?: UiColor;
+    strokeWidth?: number;
+    scrollAxes?: "none" | "x" | "y" | "both";
+}
+declare class UiStyleError extends Error {
+    constructor(message: string);
+}
+declare function parseColor(color: UiColor): number;
+declare class StyleCache {
+    private readonly sent;
+    changed(prop: number, values: Float64Array, count: number): boolean;
+    forget(prop: number): void;
+}
+declare function writeStyle(writer: PatchWriter, cache: StyleCache, node: number, style: Readonly<UiStyle>): void;
+
+type UiVarValue = number | string;
+declare function varId(namespace: string, key: string): number;
+declare class UiVar<T extends UiVarValue = UiVarValue> {
+    readonly id: number;
+    readonly name: string;
+    readonly fallback: T;
+    readonly __value?: T;
+    constructor(id: number, name: string, fallback: T);
+}
+declare class UiSlot {
+    readonly index: number;
+    readonly percent: boolean;
+    constructor(index: number, percent?: boolean);
+}
+type UiVarGroup<T extends Record<string, UiVarValue>> = {
+    readonly [K in keyof T]: UiVar<T[K]>;
+};
+declare function defineVars<const T extends Record<string, UiVarValue>>(namespace: string, values: T): UiVarGroup<T>;
+declare class UiTheme {
+    readonly values: ReadonlyMap<number, UiVarValue>;
+    constructor(values: ReadonlyMap<number, UiVarValue>);
+}
+declare function createTheme<T extends Record<string, UiVarValue>>(group: UiVarGroup<T>, overrides: {
+    readonly [K in keyof T]?: UiVarValue;
+}): UiTheme;
+
+export { type UiGradient as $, UI_EVENT_X_OFFSET as A, UI_EVENT_Y_OFFSET as B, UI_EXCLUSION_HEADER_WORDS as C, UI_HEADER_BYTES as D, type ExclusionRecord as E, UI_MAGIC as F, type GameUiEventView as G, UI_MAX_EXCLUSIONS as H, UI_RECORD_HEADER_WORDS as I, UI_SLOT_REFERENCE as J, UI_STYLE_REFERENCED as K, UI_STYLE_SAFE_EDGES as L, UI_TOKENS_REPLACE as M, NO_NODE as N, UI_VERSION as O, PatchWriter as P, UiAction as Q, UiAnchor as R, StyleCache as S, type TextComposition as T, UiTheme as U, UiEasing as V, type UiEdges as W, UiEventKind as X, UiExclusionShape as Y, UiFlag as Z, UiFocusFlag as _, type UiVarGroup as a, UiKind as a0, UiNumberFormat as a1, UiOp as a2, UiProp as a3, UiRole as a4, type UiShadow as a5, UiSlot as a6, UiTextOption as a7, UiTrait as a8, UiTransition as a9, UiUnit as aa, UiVectorData as ab, type UiVectorDataKind as ac, UiVectorPlay as ad, type WorldRootRecord as ae, codePointOffset as af, createTheme as ag, defineVars as ah, eventStride as ai, parseColor as aj, readEvent as ak, textComposition as al, textEventCapacity as am, textEventPadding as an, varId as ao, writeStyle as ap, writeTextEvent as aq, type UiColor as b, type UiNumberFormatName as c, type UiLength as d, UiVar as e, type UiAlign as f, type UiVarValue as g, type UiStyle as h, type UiKindName as i, type UiVectorPlayKind as j, type UiVectorSeekKind as k, type UiTransitionName as l, type UiEasingName as m, type UiRoleName as n, type UiEventName as o, type UiAnchorName as p, UiStyleError as q, UI_EVENT_BYTES as r, UI_EVENT_DX_OFFSET as s, UI_EVENT_DY_OFFSET as t, UI_EVENT_KIND_OFFSET as u, UI_EVENT_NODE_OFFSET as v, UI_EVENT_PHASE_OFFSET as w, UI_EVENT_POINTER_OFFSET as x, UI_EVENT_TIME_OFFSET as y, UI_EVENT_VALUE_OFFSET as z };

package/dist/vm-IUARFFAI.mjs

@@ -0,0 +1,63 @@
+import { LuauScriptError, BUDGET_MESSAGE } from './chunk-MN3YETVN.mjs';
+import { WASI_IMPORTS, wasiStubs } from './chunk-GDCV4IWO.mjs';
+import './chunk-25T4JHEA.mjs';
+
+// src/interactives/scripting/luau-web/vm.ts
+var STATUS_OK = 0, STATUS_BUDGET = 2, FIRST_MODULE = 0, F64_BYTES = 8, MAX_ARGS = 16, DEFAULT_SEED = 0, DEFAULT_MEMORY_LIMIT = 256 * 1024 * 1024, encoder = new TextEncoder(), decoder = new TextDecoder();
+async function createLuauVm(module, options = {}) {
+  let exports = null, memory = () => exports.memory, x = (await WebAssembly.instantiate(module, {
+    [WASI_IMPORTS]: wasiStubs(memory)
+  })).exports;
+  exports = x, x._initialize();
+  let status = x.luau_init(
+    options.seed ?? (0),
+    options.memoryLimit ?? DEFAULT_MEMORY_LIMIT
+  );
+  if (status !== (0))
+    throw new LuauScriptError(`the script runtime could not start (${status})`);
+  let names = /* @__PURE__ */ new Map(), argsPtr = x.luau_alloc((8) * (16)), lastError = () => decoder.decode(new Uint8Array(memory().buffer, x.luau_error_ptr(), x.luau_error_len())), nameOf = (name) => {
+    let entry = names.get(name);
+    if (entry === void 0) {
+      let bytes = encoder.encode(name), ptr = x.luau_alloc(bytes.length);
+      new Uint8Array(memory().buffer, ptr, bytes.length).set(bytes), entry = { ptr, length: bytes.length }, names.set(name, entry);
+    }
+    return entry;
+  }, failure = () => {
+    let s = x.luau_status();
+    return new LuauScriptError(
+      s === (2) ? BUDGET_MESSAGE : lastError(),
+      s === (2)
+    );
+  };
+  return {
+    path: "vm",
+    async load(bytecode) {
+      let ptr = x.luau_alloc(bytecode.length);
+      new Uint8Array(memory().buffer, ptr, bytecode.length).set(bytecode);
+      let handle = x.luau_load(ptr, bytecode.length);
+      if (x.luau_free(ptr, bytecode.length), handle < (0)) throw failure();
+      return handle;
+    },
+    call(handle, name, ...args) {
+      if (args.length > (16))
+        throw new LuauScriptError(`a script call takes at most ${(16)} arguments`);
+      let n = nameOf(name);
+      new Float64Array(memory().buffer, argsPtr, args.length).set(args);
+      let value = x.luau_call(handle, n.ptr, n.length, argsPtr, args.length);
+      if (x.luau_status() !== (0)) throw failure();
+      return value;
+    },
+    frames(handle, name, dt, count) {
+      let n = nameOf(name), digest = BigInt.asUintN(64, x.luau_frames(handle, n.ptr, n.length, dt, count));
+      if (x.luau_status() !== (0)) throw failure();
+      return digest;
+    },
+    setBudget: (budget) => x.luau_set_budget(budget),
+    budget: () => x.luau_budget(),
+    setClock: (seconds, epoch) => x.luau_set_clock(seconds, epoch),
+    digest: () => BigInt.asUintN(64, x.luau_digest()),
+    resetDigest: () => x.luau_digest_reset()
+  };
+}
+
+export { createLuauVm };

package/dist/vm-N7L6MGGH.js

@@ -0,0 +1,65 @@
+'use strict';
+
+var chunkLKV4LACG_js = require('./chunk-LKV4LACG.js');
+var chunkFXVJ2HFU_js = require('./chunk-FXVJ2HFU.js');
+require('./chunk-JGBCIKJV.js');
+
+// src/interactives/scripting/luau-web/vm.ts
+var STATUS_OK = 0, STATUS_BUDGET = 2, FIRST_MODULE = 0, F64_BYTES = 8, MAX_ARGS = 16, DEFAULT_SEED = 0, DEFAULT_MEMORY_LIMIT = 256 * 1024 * 1024, encoder = new TextEncoder(), decoder = new TextDecoder();
+async function createLuauVm(module, options = {}) {
+  let exports = null, memory = () => exports.memory, x = (await WebAssembly.instantiate(module, {
+    [chunkFXVJ2HFU_js.WASI_IMPORTS]: chunkFXVJ2HFU_js.wasiStubs(memory)
+  })).exports;
+  exports = x, x._initialize();
+  let status = x.luau_init(
+    options.seed ?? (0),
+    options.memoryLimit ?? DEFAULT_MEMORY_LIMIT
+  );
+  if (status !== (0))
+    throw new chunkLKV4LACG_js.LuauScriptError(`the script runtime could not start (${status})`);
+  let names = /* @__PURE__ */ new Map(), argsPtr = x.luau_alloc((8) * (16)), lastError = () => decoder.decode(new Uint8Array(memory().buffer, x.luau_error_ptr(), x.luau_error_len())), nameOf = (name) => {
+    let entry = names.get(name);
+    if (entry === void 0) {
+      let bytes = encoder.encode(name), ptr = x.luau_alloc(bytes.length);
+      new Uint8Array(memory().buffer, ptr, bytes.length).set(bytes), entry = { ptr, length: bytes.length }, names.set(name, entry);
+    }
+    return entry;
+  }, failure = () => {
+    let s = x.luau_status();
+    return new chunkLKV4LACG_js.LuauScriptError(
+      s === (2) ? chunkLKV4LACG_js.BUDGET_MESSAGE : lastError(),
+      s === (2)
+    );
+  };
+  return {
+    path: "vm",
+    async load(bytecode) {
+      let ptr = x.luau_alloc(bytecode.length);
+      new Uint8Array(memory().buffer, ptr, bytecode.length).set(bytecode);
+      let handle = x.luau_load(ptr, bytecode.length);
+      if (x.luau_free(ptr, bytecode.length), handle < (0)) throw failure();
+      return handle;
+    },
+    call(handle, name, ...args) {
+      if (args.length > (16))
+        throw new chunkLKV4LACG_js.LuauScriptError(`a script call takes at most ${(16)} arguments`);
+      let n = nameOf(name);
+      new Float64Array(memory().buffer, argsPtr, args.length).set(args);
+      let value = x.luau_call(handle, n.ptr, n.length, argsPtr, args.length);
+      if (x.luau_status() !== (0)) throw failure();
+      return value;
+    },
+    frames(handle, name, dt, count) {
+      let n = nameOf(name), digest = BigInt.asUintN(64, x.luau_frames(handle, n.ptr, n.length, dt, count));
+      if (x.luau_status() !== (0)) throw failure();
+      return digest;
+    },
+    setBudget: (budget) => x.luau_set_budget(budget),
+    budget: () => x.luau_budget(),
+    setClock: (seconds, epoch) => x.luau_set_clock(seconds, epoch),
+    digest: () => BigInt.asUintN(64, x.luau_digest()),
+    resetDigest: () => x.luau_digest_reset()
+  };
+}
+
+exports.createLuauVm = createLuauVm;