@cimplify/sdk 0.108.0 → 0.110.2

package/dist/interactives.mjs

@@ -0,0 +1,4333 @@
+export { UI_CLOCK_SECONDS, currencyCounter, dialogueBox, iconButton, itemCard, panel, progressBar, tabs, toast, uiClock, worldLabel } from './chunk-3ZYSAW2T.mjs';
+import { yawRotation, withinWorld, snappedToGrid, snapHeightToGrid, overlapsFootprint, movedAbout, identityTransform, encodeTransformSelection, encodeSettings, encodeSetTransform, encodeSelect, encodePlace, encodeModerate, encodeJoinCopy, encodeDuplicate, encodeClock, encodeBare, copyTransform, connectWorld, canonical, bounds, WorldRoleCode, WorldMirror, WorldBuilder, Visibility, TRANSFORM_WORDS, Status, Sky, SelectMode, Sanction, SNAP_SURFACE, SNAP_GRID, SCALE, ROTATION, POSITION, Notice, NOT_SENT, MessageKind, LocalWorld, Likeness, Lighting, Ground, CommandWriter, COMMAND_OP_ID_BYTES, BOUNDS_WORDS, BOUNDS_MIN, BOUNDS_MAX, Action } from './chunk-NPSYB6DC.mjs';
+export { LOCKSTEP_AXIS_LIMIT, LOCKSTEP_AXIS_X, LOCKSTEP_AXIS_Z, LOCKSTEP_BATCH_BYTES, LOCKSTEP_BUTTONS, LOCKSTEP_CONFIG_HEADER_BYTES, LOCKSTEP_CONFIG_MAX_WORDS, LOCKSTEP_CONFIG_TAG, LOCKSTEP_INPUT_ACTION, LOCKSTEP_INPUT_STRIDE, LOCKSTEP_MAX_SEATS, LOCKSTEP_PRESENT, LOCKSTEP_REFEREE_BYTES, LOCKSTEP_WINDOW, LockstepLoopback, LockstepPhase, LockstepRecord, LockstepSession, createTickRoomSimulation, decodeLockstepRecord, defineLockstep, defineLockstepRoom, encodeLockstepConfig, lockstepChecksum, lockstepConfigHash, lockstepRefereeState, lockstepRefereeTick, quantiseLockstepAxis, seededWords as tickSeededWords, unwrapTick16 } from './chunk-RQXN5A34.mjs';
+import { woven, weaveParts, weaveNodeValid, weaveNodeLevel, weaveNodeCount, weaveHeadMessage, walkWeave, verifyRoot, verifyChild, validWeaveRoot, unweaveIndex, storeWeaveSource, planWeave, openWeaveSession, openWeaveHead, nodeMatches, leafZone, leafLength, leafFlags, leafDigestAt, leafDigest, leafAt, deliverSchedule, chunkWeaveSource, childDigestAt, buildWeave, WeaveVerifyError, WeaveRefusal, WEAVE_VERSION, WEAVE_NODE_ZONE, WEAVE_NODE_MAGIC, WEAVE_NODE_HEADER_BYTES, WEAVE_MIN_NODE_ENTRIES, WEAVE_MAX_NODE_ENTRIES, WEAVE_MAX_NODE_BYTES, WEAVE_MAX_HEIGHT, WEAVE_LEAF_TWINNED, WEAVE_LEAF_ENTRY_BYTES, WEAVE_LEAF_DECORATED, WEAVE_HEAD_DOMAIN, WEAVE_CHILD_ENTRY_BYTES, WEAVE_BOUNDARY_MASK } from './chunk-ZR5ULMN2.mjs';
+export { AUDIO_RELAY_EXPORT, AUDIO_WORKLET_FILE, AUDIO_WORKLET_GROUP, AUDIO_WORKLET_PATH, ENGINE_AUDIO_UNIT } from './chunk-ZR5ULMN2.mjs';
+export { SurfacePointer } from './chunk-3GXH2NFD.mjs';
+export { DEFAULT_DISK_RESERVE_BYTES, DEFAULT_KEPT_BUDGET_BYTES, DEFAULT_PART_STORE_BUDGET_BYTES, DEFAULT_PART_ZONE, ENGINE_ARENA_BASELINE_BYTES, ENGINE_ARENA_CHUNK_BYTES, ENGINE_ARENA_FEATURE, ENGINE_ARENA_MAX_CEILING_BYTES, ENGINE_COMPATIBILITY_EXPORT_NAMES, ENGINE_CORE_SCRIPTS_UNIT, ENGINE_FEATURES, ENGINE_FEATURE_NAMES, ENGINE_LUAU_UNIT, ENGINE_OPTIONAL_EXPORTS, KEEP_REASONS, LUAU_SCRIPTS_GROUP, LUAU_VM_EXCEPTIONS, LUAU_VM_FILE, LUAU_VM_PATH, LuauVmModules, MemoryPartBackend, PartSession, PartVerifyError, SCRIPTS_CORE_GROUP, SCRIPTS_CORE_PATH, SharedPartStore, engineExportsUsed, engineFeatureExports, engineFeatureMember, exceptionSupport, luauVmModules, luauVmRunsHere, openLuauScripts, unmetEngineExport, unmetEngineFeature } from './chunk-BU6OK542.mjs';
+import './chunk-PRSR4FAV.mjs';
+import './chunk-TM63CYGN.mjs';
+import './chunk-X6CN6KQF.mjs';
+export { LuauScriptError } from './chunk-MN3YETVN.mjs';
+export { UI_CHECKS, UI_EXEMPT_REASONS, UI_INSPECT_HOOK, exemptUi, inspectScene, inspectSceneEntered, inspectSceneSwitch, uiSite } from './chunk-73SGZLAQ.mjs';
+export { Connecting, Connector, GAME_CHANNEL_RELIABLE_BASE, GAME_CHANNEL_SLOTS, InMemoryNetworkMemory, JoinStatus, Locomotion, LocomotionMotion, MAX_STATE_FRAGMENTS, ROOM_STATE_SLOT, RoomClient, RoomPhase, STATE_CHUNK_BYTES, STATE_FRAME_VERSION, STATE_HEADER_BYTES, StorageNetworkMemory, TickStateReplica, Transport, WebSocketDialer, WebTransportDialer, blankReply, currentNetwork, decodeJoinReply, isqrt, locomotionMotion, perAxisUnit, previousSend, resumeRequest, sendsOn, spawn, steer, ticketRequest } from './chunk-M5EXQZYY.mjs';
+export { Lane, Pace } from './chunk-TU5RYTYU.mjs';
+import './chunk-3OY3VYNF.mjs';
+import './chunk-EIB4OWVQ.mjs';
+export { LOCKSTEP_STORAGE_U64_HI, LOCKSTEP_STORAGE_U64_LO, LOCKSTEP_TABLE_ALIGN, LockstepKernel, LockstepTable, COMMAND_AREA_BYTES as TICK_COMMAND_AREA_BYTES, TICK_DEADLINE_MS, GUEST_HEAP_BYTES as TICK_GUEST_HEAP_BYTES, MAX_COMMAND_PAYLOAD_BYTES as TICK_MAX_COMMAND_PAYLOAD_BYTES, MAX_STATE_BYTES as TICK_MAX_STATE_BYTES, TickRoomError, defineTickRoom, defineTickState, lockstepKernel, lockstepKernelHost, lockstepTable, setLockstepKernelHost, tickLayout } from './chunk-PBL6YL5L.mjs';
+import './chunk-GXKI64OT.mjs';
+import './chunk-NHJUGZUR.mjs';
+import './chunk-E65WCTIG.mjs';
+import './chunk-5YFBGGCK.mjs';
+import './chunk-K4UDGE3Z.mjs';
+import './chunk-MOBSBXVE.mjs';
+import './chunk-SMK6JU2F.mjs';
+import { soleSpan, segmentOutput, partKindName, manifestBytes, isManifest, encodePart, encodeManifest, encodeDelta, decodePart, decodeManifest, assembleInto, assemble, applyDelta, SegmentOp, SEGMENT_BYTES, PartKind, PartFormatError, PART_VERSION, PART_MAGIC, PART_HEADER_BYTES, MAX_MANIFEST_PARTS, MAX_ASSET_BYTES, MANIFEST_VERSION, MANIFEST_PART_BYTES, MANIFEST_MAGIC, MANIFEST_HEADER_BYTES, DeltaOp, ProgressiveKind, containerBounds, writePatch, readLayout, progressiveKindName, liftForward, isProgressive, isCoarseKey, headBytes, encodeContainer, decodeProgressive, coarseKeys, checkLayout, UNLIFT_PARAM_BYTES, UNIT_BYTES, TableWriter, SEGMENT_STAGED, SEGMENT_BYTES2, SAMPLE_BYTES, ProgressiveLayout, ProgressiveFormatError, ProgressiveFeed, ProgressiveDecoder, ProgressiveCancelled, PatchOp, PROGRESSIVE_VERSION, PROGRESSIVE_MAGIC, PPM, PATCH_BYTES, MERGE_PARAM_BYTES, MAX_PROGRESSIVE_DECODE_BYTES, MAX_PROGRESSIVE_BYTES, LEVEL_BYTES, Header, HEADER_BYTES, FILL_BYTE_MAX } from './chunk-U6UVWEAK.mjs';
+export { ENGINE_ABI_DIGEST, ENGINE_ABI_VERSION, ENGINE_EXPORT_PROTOTYPES } from './chunk-A33OORT7.mjs';
+import { validateValue, t, select, runContent, rule, dialogueSchema, createGenerate, contentRequest, applyRules, acceptContent, MIN_TIMEOUT_MS, MAX_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, DEFAULT_RETRIES } from './chunk-OKC2B4O3.mjs';
+import { styles, compileStyle, Condition } from './chunk-PPF2BYFL.mjs';
+export { BREAKPOINT_LG, BREAKPOINT_SM, CompiledStyle, Condition, GameUi, GameUiError, SLOT_REFERENCE, STYLE_BLOCK_MAGIC, STYLE_BLOCK_VERSION, KEY_NAMES as STYLE_KEYS, STYLE_PROPERTY_NAMES, STYLE_RECORD_REFERENCED, STYLE_RECORD_SAFE_EDGES, TextMeasurer, UiElement, UiProps, UiStyleCompileError, VariantKind, collectingSink, compileClasses, compileStyle, conditionPriority, encodeStyleRecords, props, readBlock, styles, tailwindStyle, tailwindVocabulary } from './chunk-PPF2BYFL.mjs';
+import { defineVars, tokens, createTheme, mergeThemes, UiSlot } from './chunk-WLMINRC4.mjs';
+export { TOKEN_NAMESPACE, UiSlot, UiTheme, UiVar, createTheme, defineVars, themeTokens, tokens, varId } from './chunk-WLMINRC4.mjs';
+import { DEFAULT_THEME, theme, UiAction } from './chunk-RFVRPYR2.mjs';
+export { DEFAULT_THEME, NO_NODE, PatchWriter, StyleCache, UI_EVENT_BYTES, UI_EVENT_DX_OFFSET, UI_EVENT_DY_OFFSET, UI_EVENT_KIND_OFFSET, UI_EVENT_NODE_OFFSET, UI_EVENT_PHASE_OFFSET, UI_EVENT_POINTER_OFFSET, UI_EVENT_TIME_OFFSET, UI_EVENT_VALUE_OFFSET, UI_EVENT_X_OFFSET, UI_EVENT_Y_OFFSET, UI_EXCLUSION_HEADER_WORDS, UI_HEADER_BYTES, UI_MAGIC, UI_MAX_EXCLUSIONS, UI_RECORD_HEADER_WORDS, UI_SLOT_REFERENCE, UI_STYLE_REFERENCED, UI_STYLE_SAFE_EDGES, UI_TOKENS_REPLACE, UI_VERSION, UiAction, UiAnchor, UiEasing, UiEventKind, UiExclusionShape, UiFlag, UiFocusFlag, UiKind, UiNumberFormat, UiOp, UiProp, UiRole, UiStyleError, UiTextOption, UiTrait, UiTransition, UiUnit, UiVectorData, UiVectorPlay, codePointOffset, eventStride, parseColor, readEvent, textComposition, textEventCapacity, textEventPadding, theme, writeStyle, writeTextEvent } from './chunk-RFVRPYR2.mjs';
+export { BASE_ENGINE_VARIANT, CONTENT_ENGINE_VARIANT, ENGINE_CORE_GL_UNIT, ENGINE_FEATURE_CARGO, ENGINE_VARIANTS, FULL_ENGINE_VARIANT, GATED_ENGINE_FEATURES, GL_CORE_GROUP, GL_CORE_PATH, GL_ENGINE_VARIANTS, PHYSICS_ENGINE_VARIANT, SCRIPTS_ENGINE_VARIANT, SCRIPTS_ENGINE_VARIANTS, SCRIPTS_SHADERS_ENGINE_VARIANT, SCRIPTS_SHADERS_ENGINE_VARIANTS, TEXT_DICTIONARIES_ASSET, TEXT_DICTIONARIES_FILE, THREADED_ENGINE_VARIANT, THREADED_ENGINE_VARIANTS, engineVariantFor, glVariantOf, isGlVariant, isScriptsVariant, isShadersVariant, isThreadedVariant, scriptsShadersVariantOf, scriptsVariantOf, threadedVariantOf, webGpuVariantOf } from './chunk-DS2VU4WW.mjs';
+import './chunk-5YWN6H5Q.mjs';
+export { suggest } from './chunk-F6XRYEM3.mjs';
+export { FrameBufferPool, FrameCode, FrameFault, acknowledges, compareStamps, decodeAck, decodeChannelFrame, decodeCounterAdd, decodeCounterValue, decodeFastRead, decodeFastValue, decodeMoveInput, decodePresenceDelta, decodePresenceTick, decodeRoomInputFrame, dequantiseAxis, dequantiseCellOffset, dequantiseHeight, dequantiseYaw, encodeAck, encodeCounterAdd, encodeCounterValue, encodeMoveInput, finishPresenceTick, frameLength, frameTag, peekFrameCode, quantiseAxis, quantiseCellOffset, quantiseHeight, quantiseYaw, readPresenceDeltaEntry, readPresenceEntry, stampChannelSender, writeChannelHeader, writeFastReadHeader, writeFastValueHeader, writePresenceEntry, writeRoomInputHeader } from './chunk-OQRVEM56.mjs';
+import { FRAME_LIMITS, CTX_LIMITS } from './chunk-SPCRQ6NO.mjs';
+export { CTX_CAPABILITIES, CTX_COMPATIBLE_FINGERPRINTS, CTX_CONTRACT_FINGERPRINT, CTX_CONTRACT_VERSION, CTX_LIMITS, CTX_MIN_SUPPORTED_CONTRACT_VERSION, FRAME_CODES, FRAME_FLAGS, FRAME_LAYOUT, FRAME_LIMITS, FRAME_VERSION, MAX_DATAGRAM_BYTES, QUANTISATION } from './chunk-SPCRQ6NO.mjs';
+import './chunk-V7ZRH3PY.mjs';
+export { BreakDictionaries, breakDictionaries, registerBreakDictionaries } from './chunk-GYLP6UG4.mjs';
+export { FontTable, fontTable, registerFontTable } from './chunk-XJA2NGTI.mjs';
+import './chunk-2IC4H6OV.mjs';
+import './chunk-MOMOZEUM.mjs';
+import './chunk-N4RGGDEL.mjs';
+import './chunk-XJIHN3BY.mjs';
+import { __export } from './chunk-25T4JHEA.mjs';
+
+// src/interactives/simulator.ts
+var SimulatorUnsupportedError = class extends Error {
+  constructor(member) {
+    super(`ctx.${member} is not available in the local simulator yet`), this.name = "SimulatorUnsupportedError", this.member = member;
+  }
+}, SIMULATOR_FIXED_STEP_MS = 1e3 / 60, MAX_FRAME_MS = 250, PREPARED_ENGINE = { kind: "prepared" }, UINT32 = 4294967296, DEFAULT_SEED = 2654435769, STATUS_TEXT_FIELD = "text", DEFAULT_PERSONA = {
+  age_range: "adult",
+  avatar: null,
+  display_name: "Local Player",
+  handle: "local",
+  participant_id: "participant_local"
+}, DEFAULT_LOCALE = {
+  currency: "GHS",
+  decimal_separator: ".",
+  direction: "ltr",
+  first_day_of_week: "monday",
+  grouping_separator: ",",
+  hour_cycle: "h23",
+  language: "en-GH",
+  measurement: "metric",
+  region: "GH",
+  time_zone: "Africa/Accra"
+}, Xoshiro128 = class {
+  constructor(words) {
+    this.a = words[0] >>> 0, this.b = words[1] >>> 0, this.c = words[2] >>> 0, this.d = words[3] >>> 0 || 1;
+  }
+  next_u32() {
+    let result = Math.imul(rotl(Math.imul(this.b, 5), 7), 9) >>> 0, t2 = this.b << 9;
+    return this.c ^= this.a, this.d ^= this.b, this.b ^= this.c, this.a ^= this.d, this.c ^= t2, this.d = rotl(this.d, 11), result;
+  }
+  next_float() {
+    return this.next_u32() / (4294967296);
+  }
+};
+function rotl(x, k) {
+  return (x << k | x >>> 32 - k) >>> 0;
+}
+function splitmix(state) {
+  let z = state + 2654435769 | 0;
+  return z = Math.imul(z ^ z >>> 16, 2246822507), z = Math.imul(z ^ z >>> 13, 3266489909), (z ^ z >>> 16) >>> 0;
+}
+function copyEntries(entries) {
+  let out = /* @__PURE__ */ new Map();
+  for (let [k, v] of entries) out.set(k, { value: structuredClone(v.value), revision: v.revision });
+  return out;
+}
+function createSimulatorCtx(options) {
+  let host = options.host, now = options.now ?? (() => Date.now()), persona = options.persona ?? DEFAULT_PERSONA, locale = options.locale ?? DEFAULT_LOCALE, unsupported = /* @__PURE__ */ new Set(), disposers = [], lifecycle = /* @__PURE__ */ new Map(), stores = /* @__PURE__ */ new Map(), uiListeners = /* @__PURE__ */ new Set(), cosmeticState = (options.seed ?? (2654435769)) >>> 0, checkpointCounter = 0, lifecycleState = "visible", status = { text: null, your_turn: false }, completions = [], info = {
+    capabilities: [],
+    contract_version: 1,
+    data_lineage: null,
+    features: [],
+    instance: "simulator",
+    interactive_id: options.interactiveId ?? "itv_simulator",
+    kit_version: null,
+    launch: { source: "direct", reference: null, selected: null },
+    location: "client",
+    profile: options.profile,
+    revision: "rev_local"
+  }, program = {
+    ready() {
+    },
+    ...info,
+    async set_status(request) {
+      if ([...request.text].length > CTX_LIMITS.max_status_line_chars)
+        throw { code: "invalid_arguments", field: STATUS_TEXT_FIELD, problem: "too_long" };
+      return status = { text: request.text.length === 0 ? null : request.text, your_turn: request.your_turn }, status;
+    }
+  }, storeById = (id) => {
+    let store = stores.get(id);
+    if (!store) throw new Error(`unknown store ${id}`);
+    return store;
+  }, emitStore = (store, event) => {
+    for (let l of store.listeners) l(event);
+  }, openStore = async (request) => {
+    let key = `${request.scope}:${request.name}`, store = stores.get(key);
+    store || (store = {
+      handle: {
+        access: "read_write",
+        classification: request.classification,
+        migrate_from: null,
+        revision: 0,
+        schema: request.schema,
+        scope: request.scope,
+        store_id: key
+      },
+      entries: /* @__PURE__ */ new Map(),
+      checkpoints: /* @__PURE__ */ new Map(),
+      listeners: /* @__PURE__ */ new Set()
+    }, stores.set(key, store));
+    let s9 = store, id = s9.handle.store_id;
+    return {
+      get handle() {
+        return s9.handle;
+      },
+      async get(req) {
+        let hit = storeById(id).entries.get(req.key);
+        return { key: req.key, revision: hit ? hit.revision : 0, value: hit ? structuredClone(hit.value) : null };
+      },
+      async list(req) {
+        let prefix = req.prefix ?? "", entries = [];
+        for (let [k, v] of s9.entries) k.startsWith(prefix) && entries.push({ key: k, revision: v.revision, value: structuredClone(v.value) });
+        entries.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+        let limit = req.page.limit ?? entries.length;
+        return { entries: entries.slice(0, limit), next: null, revision: s9.handle.revision };
+      },
+      async commit(req) {
+        if (req.expected !== void 0 && req.expected !== null && req.expected !== s9.handle.revision)
+          throw new Error(`store ${id} is at revision ${s9.handle.revision}, expected ${req.expected}`);
+        let revision = s9.handle.revision + 1, keys = [];
+        for (let w of req.writes)
+          keys.push(w.key), w.op === "put" ? s9.entries.set(w.key, { value: structuredClone(w.value), revision }) : s9.entries.delete(w.key);
+        return s9.handle = { ...s9.handle, revision }, emitStore(s9, { kind: "changed", keys, revision, store_id: id }), { revision, store_id: id };
+      },
+      async checkpoint() {
+        checkpointCounter++;
+        let checkpoint_id = `checkpoint_${checkpointCounter}`;
+        return s9.checkpoints.set(checkpoint_id, { revision: s9.handle.revision, entries: copyEntries(s9.entries) }), { checkpoint_id, created_at: now(), revision: s9.handle.revision, store_id: id };
+      },
+      async restore(req) {
+        let cp = s9.checkpoints.get(req.checkpoint_id);
+        if (!cp) throw new Error(`unknown checkpoint ${req.checkpoint_id}`);
+        s9.entries = copyEntries(cp.entries);
+        let revision = s9.handle.revision + 1;
+        return s9.handle = { ...s9.handle, revision }, emitStore(s9, { kind: "restored", checkpoint_id: req.checkpoint_id, revision, store_id: id }), s9.handle;
+      },
+      async migrate(req) {
+        let revision = s9.handle.revision + 1;
+        return s9.handle = { ...s9.handle, revision, schema: req.to, migrate_from: s9.handle.schema.version }, emitStore(s9, { kind: "migrated", revision, schema: req.to, store_id: id }), s9.handle;
+      },
+      on_event(listener) {
+        return s9.listeners.add(listener), () => s9.listeners.delete(listener);
+      }
+    };
+  }, loop = createLoop(host, () => record("game.loop")), record = (member) => {
+    throw unsupported.add(member), new SimulatorUnsupportedError(member);
+  }, fire = (event) => {
+    let listeners = lifecycle.get(event);
+    if (listeners) for (let l of listeners) l();
+  }, base = {
+    program,
+    session: {
+      async complete(request) {
+        return completions.push(request), { recorded: false };
+      }
+    },
+    clock: {
+      now,
+      async sync() {
+        return { display_offset_ms: 0, now: now(), room_tick: null, source: "app_clock" };
+      }
+    },
+    random: {
+      cosmetic() {
+        return cosmeticState = splitmix(cosmeticState), cosmeticState / (4294967296);
+      },
+      async seed(request) {
+        let s9 = cosmeticState, words = [0, 0, 0, 0];
+        for (let i = 0; i < 4; i++)
+          s9 = splitmix(s9 + i), words[i] = s9;
+        return { label: request.label, recorded: false, scope: request.scope, words };
+      },
+      stream(grant) {
+        return new Xoshiro128(grant.words);
+      }
+    },
+    locale: {
+      ...locale,
+      format_number(value, fraction_digits) {
+        return new Intl.NumberFormat(locale.language, {
+          minimumFractionDigits: fraction_digits,
+          maximumFractionDigits: fraction_digits
+        }).format(value);
+      },
+      format_money(amount, currency) {
+        return new Intl.NumberFormat(locale.language, { style: "currency", currency: currency ?? locale.currency }).format(Number(amount));
+      },
+      format_time(unix_ms) {
+        return new Intl.DateTimeFormat(locale.language, { timeStyle: "short", timeZone: locale.time_zone }).format(unix_ms);
+      }
+    },
+    identity: {
+      async current() {
+        return persona;
+      },
+      async personas(request) {
+        return { personas: request.participants.indexOf(persona.participant_id) >= 0 ? [persona] : [] };
+      },
+      async profile() {
+        return {
+          participant_id: persona.participant_id,
+          display_name: persona.display_name,
+          handle: persona.handle ?? null,
+          avatar: persona.avatar ?? null
+        };
+      }
+    },
+    open_store: openStore,
+    async share() {
+      return host.toast("Share sheet opened"), { decision: "confirmed", link: null };
+    },
+    ui: {
+      render(tree) {
+        host.render(tree);
+      },
+      async present() {
+      },
+      open_sheet(request) {
+        return host.openSheet ? host.openSheet(request) : record("ui.open_sheet");
+      },
+      async open_handoff() {
+        return { status: "cancelled" };
+      },
+      toast(text) {
+        host.toast(text);
+      },
+      haptic() {
+      },
+      announce(text) {
+        host.toast(text);
+      },
+      on_event(listener) {
+        return uiListeners.add(listener), () => uiListeners.delete(listener);
+      }
+    },
+    graphics: {
+      features: { apis: ["canvas2d"], max_texture_size: 4096, device_tier: "mid" },
+      engine() {
+        return host.engine ? host.engine() : Promise.resolve(PREPARED_ENGINE);
+      },
+      acquire_surface(surfaceOptions) {
+        return host.acquireSurface ? host.acquireSurface(surfaceOptions) : record("graphics.acquire_surface");
+      },
+      attach_engine() {
+        return record("graphics.attach_engine");
+      },
+      on_context_lost() {
+        return () => {
+        };
+      },
+      on_context_restored() {
+        return () => {
+        };
+      }
+    },
+    game: guard("game", { kit_version: "simulator", loop }, unsupported),
+    lifecycle: {
+      get state() {
+        return lifecycleState;
+      },
+      on(event, listener) {
+        let set = lifecycle.get(event);
+        return set || (set = /* @__PURE__ */ new Set(), lifecycle.set(event, set)), set.add(listener), () => set.delete(listener);
+      }
+    },
+    on_dispose(callback) {
+      disposers.push(callback);
+    }
+  };
+  return {
+    ctx: guard("", base, unsupported),
+    unsupported,
+    get status() {
+      return status;
+    },
+    completions,
+    emit(event) {
+      event === "hidden" ? lifecycleState = "hidden" : event === "visible" || event === "resume" ? lifecycleState = "visible" : event === "suspend" && (lifecycleState = "suspended"), fire(event);
+    },
+    dispatch(event) {
+      if (lifecycleState !== "disposed")
+        for (let listener of uiListeners) listener(event);
+    },
+    dispose() {
+      if (lifecycleState !== "disposed") {
+        loop.stop(), lifecycleState = "disposed", fire("dispose");
+        for (let i = disposers.length - 1; i >= 0; i--) disposers[i]();
+        disposers.length = 0, uiListeners.clear();
+      }
+    }
+  };
+}
+function guard(prefix, target, unsupported) {
+  return new Proxy(target, {
+    get(obj, prop, receiver) {
+      if (typeof prop == "symbol" || prop in obj) return Reflect.get(obj, prop, receiver);
+      if (prop === "then") return;
+      let member = prefix === "" ? prop : `${prefix}.${prop}`;
+      throw unsupported.add(member), new SimulatorUnsupportedError(member);
+    }
+  });
+}
+function createLoop(host, missing) {
+  let callbacks = null, handle = -1, last = -1, accumulator = 0, tick = 0, paused = false, step = SIMULATOR_FIXED_STEP_MS, frame = (time) => {
+    if (callbacks === null || !host.requestFrame) return;
+    if (handle = host.requestFrame(frame), paused) {
+      last = time;
+      return;
+    }
+    let elapsed = last < 0 ? step : time - last;
+    for (last = time, accumulator += elapsed > (250) ? (250) : elapsed; accumulator >= step; )
+      callbacks.update(step, tick), tick++, accumulator -= step;
+    callbacks.render(accumulator / step);
+  };
+  return {
+    fixed_step_ms: step,
+    get tick() {
+      return tick;
+    },
+    start(next) {
+      host.requestFrame || missing(), callbacks = next, paused = false, last = -1, handle = host.requestFrame(frame);
+    },
+    pause() {
+      paused = true;
+    },
+    resume() {
+      paused = false;
+    },
+    stop() {
+      callbacks = null, handle >= 0 && host.cancelFrame && host.cancelFrame(handle), handle = -1;
+    }
+  };
+}
+
+// src/interactives/game-ui/widgets/theme.ts
+var KIT_NAMESPACE = "kit", UI_FONT_SET = ["sans", "rounded", "condensed", "serif", "mono", "pixel"], UI_DEFAULT_FONT = 0, UI_FONT_ROLES = ["body", "display", "mono"], ROLE_FAMILIES = { body: "kit.body", display: "kit.display", mono: "kit.mono" }, ROLE_INDEX = { body: 0, display: 1, mono: 2 }, KIT_WEIGHTS = [400, 600, 700, 800], DEFAULT_WEIGHT = 400, DEFAULT_METRICS = {
+  radius: DEFAULT_THEME.radius,
+  radiusSmall: 8,
+  padding: DEFAULT_THEME.padding,
+  gap: DEFAULT_THEME.gap,
+  gapSmall: 4,
+  small: DEFAULT_THEME.small,
+  body: DEFAULT_THEME.body,
+  title: DEFAULT_THEME.title,
+  display: 30,
+  borderWidth: 1,
+  focusWidth: 2,
+  pressScale: DEFAULT_THEME.press_scale
+}, DEFAULT_EXTRAS = {
+  focus: "#ffffffff",
+  scrim: "#05070cb3",
+  highlight: "#ffffff1f",
+  shadow: "#0000008c",
+  onDanger: "#ffffffff",
+  silver: "#c7ccd6ff",
+  bronze: "#cd7f32ff"
+}, kitVars = defineVars(KIT_NAMESPACE, { ...DEFAULT_METRICS, ...DEFAULT_EXTRAS }), AI_MARK_NAMESPACE = "ai_mark", DEFAULT_AI_MARK = { fill: "#ffffff1f", text: "#a1a1aaff", fontSize: 10, radius: 4, paddingInline: 4 }, aiMarkVars = defineVars(AI_MARK_NAMESPACE, { ...DEFAULT_AI_MARK });
+function aiMarkTheme(overrides) {
+  return createTheme(aiMarkVars, overrides);
+}
+function themePack(definition) {
+  let metrics = { ...DEFAULT_METRICS, ...definition.metrics }, c = definition.colors, game = theme({
+    surface: c.surface,
+    raised: c.raised,
+    border: c.border,
+    accent: c.accent,
+    on_accent: c.onAccent,
+    text: c.text,
+    muted: c.muted,
+    track: c.track,
+    danger: c.danger,
+    success: c.success,
+    gold: c.gold,
+    radius: metrics.radius,
+    padding: metrics.padding,
+    gap: metrics.gap,
+    small: metrics.small,
+    body: metrics.body,
+    title: metrics.title,
+    press_scale: metrics.pressScale,
+    motion: definition.motion ?? DEFAULT_THEME.motion
+  }), palette = createTheme(tokens, {
+    surface: c.surface,
+    raised: c.raised,
+    border: c.border,
+    accent: c.accent,
+    onAccent: c.onAccent,
+    text: c.text,
+    muted: c.muted,
+    track: c.track,
+    danger: c.danger,
+    success: c.success,
+    gold: c.gold
+  }), kit = createTheme(kitVars, {
+    ...metrics,
+    focus: c.focus,
+    scrim: c.scrim,
+    highlight: c.highlight,
+    shadow: c.shadow,
+    onDanger: c.onDanger,
+    silver: c.silver,
+    bronze: c.bronze
+  }), mark = aiMarkTheme({ fill: c.track, text: c.muted, ...definition.aiMark });
+  return { name: definition.name, colors: c, metrics, fonts: definition.fonts, game, theme: mergeThemes([palette, kit, mark]) };
+}
+var NEON_ARCADE = themePack({
+  name: "Neon arcade",
+  colors: {
+    surface: "#0b0420eb",
+    raised: "#1d0b3dff",
+    border: "#ff2bd666",
+    accent: "#ff2bd6ff",
+    onAccent: "#12021fff",
+    text: "#f4f0ffff",
+    muted: "#a493d6ff",
+    track: "#ffffff1f",
+    danger: "#ff3860ff",
+    success: "#22f5a0ff",
+    gold: "#fff03aff",
+    focus: "#2bf3ffff",
+    scrim: "#05010fcc",
+    highlight: "#2bf3ff26",
+    shadow: "#ff2bd659",
+    onDanger: "#ffffffff",
+    silver: "#b8c4ffff",
+    bronze: "#ff9d5cff"
+  },
+  metrics: { radius: 4, radiusSmall: 2, borderWidth: 2, focusWidth: 3, pressScale: 0.92, display: 34 },
+  fonts: { body: "sans", display: "pixel", mono: "mono" },
+  motion: 0.1
+}), COZY_PASTEL = themePack({
+  name: "Cozy pastel",
+  colors: {
+    surface: "#fff7efef",
+    raised: "#ffe9dcff",
+    border: "#e8cbb866",
+    accent: "#f49cb8ff",
+    onAccent: "#3b1d2aff",
+    text: "#4a3a40ff",
+    muted: "#9a8590ff",
+    track: "#e9d8d2ff",
+    danger: "#ef7f7fff",
+    success: "#7fcfa6ff",
+    gold: "#f6c560ff",
+    focus: "#8fb8ffff",
+    scrim: "#5a4a5266",
+    highlight: "#8fb8ff2e",
+    shadow: "#9a6f8040",
+    onDanger: "#ffffffff",
+    silver: "#b9bfd0ff",
+    bronze: "#d9a07aff"
+  },
+  metrics: { radius: 20, radiusSmall: 14, padding: 16, gap: 10, pressScale: 0.96 },
+  fonts: { body: "rounded", display: "rounded", mono: "mono" },
+  motion: 0.22
+}), SPORTS_BROADCAST = themePack({
+  name: "Sports broadcast",
+  colors: {
+    surface: "#0d1b2af2",
+    raised: "#16324fff",
+    border: "#ffffff33",
+    accent: "#e4002bff",
+    onAccent: "#ffffffff",
+    text: "#ffffffff",
+    muted: "#9fb3c8ff",
+    track: "#ffffff26",
+    danger: "#ff5a36ff",
+    success: "#00c389ff",
+    gold: "#ffcd00ff",
+    focus: "#ffcd00ff",
+    scrim: "#020a12cc",
+    highlight: "#ffffff1a",
+    shadow: "#00000080",
+    onDanger: "#ffffffff",
+    silver: "#c0c8d2ff",
+    bronze: "#c9844aff"
+  },
+  metrics: { radius: 2, radiusSmall: 2, padding: 10, gap: 6, gapSmall: 3, body: 15, title: 20, display: 32, pressScale: 0.97 },
+  fonts: { body: "sans", display: "condensed", mono: "condensed" },
+  motion: 0.12
+}), FANTASY_PARCHMENT = themePack({
+  name: "Fantasy parchment",
+  colors: {
+    surface: "#f1e2c2f2",
+    raised: "#e5cf9fff",
+    border: "#7a5a2e99",
+    accent: "#8b2a1fff",
+    onAccent: "#fbf1dcff",
+    text: "#3a2614ff",
+    muted: "#7a6448ff",
+    track: "#c9b083ff",
+    danger: "#a3241bff",
+    success: "#4f7a2aff",
+    gold: "#b8860bff",
+    focus: "#2f5d8aff",
+    scrim: "#1a0f0599",
+    highlight: "#2f5d8a26",
+    shadow: "#3a261459",
+    onDanger: "#fbf1dcff",
+    silver: "#8d8f94ff",
+    bronze: "#8c5a2bff"
+  },
+  metrics: { radius: 6, radiusSmall: 4, padding: 14, borderWidth: 2, focusWidth: 2, title: 21, display: 32 },
+  fonts: { body: "serif", display: "serif", mono: "mono" },
+  motion: 0.2
+}), THEME_PACKS = [NEON_ARCADE, COZY_PASTEL, SPORTS_BROADCAST, FANTASY_PARCHMENT], books = /* @__PURE__ */ new WeakMap();
+function book(ui) {
+  let found = books.get(ui);
+  return found === void 0 && (found = { fonts: /* @__PURE__ */ new Map(), pack: null, roles: [] }, books.set(ui, found)), found;
+}
+function kitFamily(ui, role) {
+  return ui.family(ROLE_FAMILIES[role]);
+}
+function fontStyle(ui, role) {
+  let roles = book(ui).roles, index = ROLE_INDEX[role], style = roles[index];
+  if (style === void 0) {
+    let fonts = book(ui);
+    (fonts.pack === null || !fonts.fonts.has(fonts.pack.fonts[role])) && ui.registerFont(ROLE_FAMILIES[role], (0), (400)), style = styles({ font: { fontFamily: kitFamily(ui, role) } }).font, roles[index] = style;
+  }
+  return style;
+}
+function nearest(entry, weight) {
+  let best = -1, distance = 1 / 0;
+  for (let i = 0; i < entry.weights.length; i++) {
+    let gap = Math.abs(entry.weights[i] - weight);
+    gap < distance && (distance = gap, best = entry.fonts[i]);
+  }
+  return best;
+}
+function bind(ui, fonts, pack) {
+  for (let r = 0; r < UI_FONT_ROLES.length; r++) {
+    let role = UI_FONT_ROLES[r], entry = fonts.fonts.get(pack.fonts[role]);
+    if (entry !== void 0)
+      for (let w = 0; w < KIT_WEIGHTS.length; w++) ui.registerFont(ROLE_FAMILIES[role], nearest(entry, KIT_WEIGHTS[w]), KIT_WEIGHTS[w]);
+  }
+}
+function registerUiFont(ui, name, font, weight = (400)) {
+  let fonts = book(ui), entry = fonts.fonts.get(name);
+  entry === void 0 && (entry = { weights: [], fonts: [] }, fonts.fonts.set(name, entry));
+  let at = entry.weights.indexOf(weight);
+  at >= 0 ? entry.fonts[at] = font : (entry.weights.push(weight), entry.fonts.push(font)), ui.registerFont(name, font, weight), fonts.pack !== null && bind(ui, fonts, fonts.pack);
+}
+function applyThemePack(ui, pack) {
+  let fonts = book(ui);
+  ui.theme(pack.theme), fonts.pack !== pack && (fonts.pack = pack, bind(ui, fonts, pack));
+}
+function currentThemePack(ui) {
+  return books.get(ui)?.pack ?? null;
+}
+
+// src/interactives/game-ui/widgets/sheet.ts
+var TRANSPARENT = "#00000000", TAP_TARGET = 44, PRESS_SECONDS = 0.12, FADE_SECONDS = 0.18, HALF = 0.5, PERCENT = 100, BOLD = 700, HEAVY = 800, sheet = styles({
+  text: { fontSize: kitVars.body, textColor: tokens.text, pointerEvents: "none" },
+  small: { fontSize: kitVars.small, textColor: tokens.muted, pointerEvents: "none" },
+  title: { fontSize: kitVars.title, fontWeight: (700), textColor: tokens.text, pointerEvents: "none" },
+  display: { fontSize: kitVars.display, fontWeight: (800), textColor: tokens.text, pointerEvents: "none" },
+  strong: { fontWeight: (700) },
+  muted: { textColor: tokens.muted },
+  center: { textAlign: "center" },
+  wrap: { textWrap: true, alignSelf: "stretch" },
+  hidden: { hidden: true },
+  shown: { hidden: false },
+  layer: { width: "100%", height: "100%", pointerEvents: "none" },
+  panel: {
+    padding: kitVars.padding,
+    gap: kitVars.gap,
+    fill: tokens.surface,
+    radius: kitVars.radius,
+    borderWidth: kitVars.borderWidth,
+    borderColor: tokens.border
+  },
+  focusRing: {
+    borderWidth: kitVars.focusWidth,
+    borderColor: { default: TRANSPARENT, ":focus": kitVars.focus }
+  },
+  pressable: {
+    scale: { default: 1, ":pressed": kitVars.pressScale },
+    opacity: { default: 1, ":disabled": 0.5 }
+  }
+}), PERCENT_TEXT = Array.from({ length: (100) + 1 }, (_, i) => `${i}%`), INTEGER = { format: "integer", separator: "," }, PLAIN = { format: "integer", separator: "" }, TIMER = { format: "timer" };
+function label(ui, value, role, a, b, c) {
+  return ui.text(value, ui.props(fontStyle(ui, role), a, b, c));
+}
+function clamp(value, low, high) {
+  return value < low ? low : value > high ? high : value;
+}
+var SLOTS = new Float64Array(4);
+function slotWords(template) {
+  return compileStyle(template);
+}
+function slot(index, percent = false) {
+  return new UiSlot(index, percent);
+}
+var A11y = class {
+  constructor(options) {
+    this.first = true;
+    this.actions = options.actions, this.options = { ...options, actions: void 0 };
+  }
+  apply(element) {
+    if (this.first) {
+      this.first = false, this.options.actions = this.actions, element.accessibility(this.options), this.options.actions = void 0;
+      return;
+    }
+    element.accessibility(this.options);
+  }
+}, StableList = class {
+  constructor() {
+    this.items = [];
+    this.count = 0;
+  }
+  get size() {
+    return this.count;
+  }
+  at(index) {
+    return this.items[index];
+  }
+  push(item) {
+    this.count < this.items.length ? this.items[this.count] = item : this.items.push(item), this.count++;
+  }
+  indexOf(item) {
+    for (let i = 0; i < this.count; i++) if (this.items[i] === item) return i;
+    return -1;
+  }
+  removeAt(index) {
+    for (let i = index; i + 1 < this.count; i++) this.items[i] = this.items[i + 1];
+    this.count--;
+  }
+};
+function removeAt(list2, index) {
+  for (let i = index; i + 1 < list2.length; i++) list2[i] = list2[i + 1];
+  list2.length = list2.length - 1;
+}
+var Rng = class {
+  constructor(seed) {
+    this.state = new Int32Array(1);
+    this.state[0] = (seed | 0) === 0 ? 2654435769 : seed | 0;
+  }
+  next() {
+    let x = this.state[0];
+    return x ^= x << 13, x ^= x >>> 17, x ^= x << 5, this.state[0] = x, (x >>> 0) / 4294967296;
+  }
+  range(low, high) {
+    return low + (high - low) * this.next();
+  }
+};
+
+// src/interactives/game-ui/widgets/ai-mark.ts
+var AI_MARK_SOURCES = ["generated", "cached", "replicated"], AI_MARK_TEXT = "AI", AI_MARK_LABEL = "AI generated";
+function isAiGenerated(source) {
+  return source === "generated" || source === "cached" || source === "replicated";
+}
+var s = styles({
+  mark: { fill: aiMarkVars.fill, radius: aiMarkVars.radius, paddingInline: aiMarkVars.paddingInline, alignSelf: "center", shrink: 0, pointerEvents: "none" },
+  markText: { fontSize: aiMarkVars.fontSize, fontWeight: (800), textColor: aiMarkVars.text, pointerEvents: "none" },
+  row: { direction: "row", alignItems: "center", gap: kitVars.gapSmall },
+  text: { fontSize: kitVars.body, textColor: tokens.text, shrink: 1, pointerEvents: "none" }
+}), AiMark = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.on = false;
+    this.states = [ui.props(s.mark, options.style, sheet.hidden), ui.props(s.mark, options.style)], this.root = ui.box(this.states[0]), this.text = label(ui, options.text ?? AI_MARK_TEXT, "body", s.markText, options.textStyle), this.root.append(this.text), this.root.accessibility({ hidden: true });
+  }
+  get shown() {
+    return this.on;
+  }
+  show(source) {
+    let on = isAiGenerated(source);
+    return on === this.on || (this.on = on, this.root.style(this.states[on ? 1 : 0])), on;
+  }
+};
+function aiMark(ui, options = {}) {
+  return new AiMark(ui, options);
+}
+function aiLabel(text, marked) {
+  return marked ? `${text}, ${AI_MARK_LABEL}` : text;
+}
+var GeneratedText = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.current = "";
+    this.source = null;
+    this.shown = false;
+    this.a11y = new A11y({ role: "text", label: "" });
+    this.root = ui.box(ui.props(s.row, options.style)), this.text = label(ui, "", options.role ?? "body", s.text, options.wrap === true && sheet.wrap, options.textStyle), this.mark = new AiMark(ui, options.mark), this.root.append(this.text).append(this.mark.root), this.set(options.text ?? "", options.source ?? null);
+  }
+  get value() {
+    return this.current;
+  }
+  get marked() {
+    return this.mark.shown;
+  }
+  set(text, source = null) {
+    this.shown && text === this.current && isAiGenerated(source) === isAiGenerated(this.source) || (this.shown = true, this.current = text, this.source = source, this.text.text(text), this.a11y.options.label = aiLabel(text, this.mark.show(source)), this.a11y.apply(this.root));
+  }
+  show(result) {
+    this.set(result.value, result.source);
+  }
+};
+function generatedText(ui, options = {}) {
+  return new GeneratedText(ui, options);
+}
+
+// src/interactives/game-ui/widgets/collections.ts
+var CELL = 64, CELL_GAP = 8, GRID_PADDING = 8, ICON_RATIO = 0.7, GHOST_SCALE = 1.08, GHOST_Z = 20, EMPTY = -1, ROW_HEIGHT = 44, LIST_HEIGHT = 320, POOL_SLACK = 2, RANK_WIDTH = 44, SCORE_WIDTH = 96, NO_INDEX = -1, TRAVEL_SHIFT = 4, TRAVEL_SCALE = 1 << (4), MEDALS = 3, s2 = styles({
+  grid: { padding: (8), gap: (8), fill: tokens.surface, radius: kitVars.radius, position: "relative", borderWidth: kitVars.focusWidth, borderColor: { default: tokens.border, ":focus": kitVars.focus } },
+  gridRow: { direction: "row", gap: (8) },
+  cell: {
+    alignItems: "center",
+    justify: "center",
+    radius: kitVars.radiusSmall,
+    fill: tokens.raised,
+    borderWidth: 2,
+    borderColor: TRANSPARENT,
+    position: "relative",
+    scale: { default: 1, ":pressed": kitVars.pressScale }
+  },
+  cellCursor: { borderColor: kitVars.focus },
+  cellHover: { borderColor: tokens.accent, fill: kitVars.highlight },
+  cellSource: { opacity: 0.35 },
+  icon: { pointerEvents: "none" },
+  iconEmpty: { hidden: true },
+  count: { position: "absolute", right: 4, bottom: 2, fontSize: kitVars.small, fontWeight: 800, textColor: tokens.text, pointerEvents: "none" },
+  ghost: { position: "absolute", alignItems: "center", justify: "center", pointerEvents: "none", zIndex: (20), scale: (1.08), opacity: 0.92, radius: kitVars.radiusSmall, fill: kitVars.highlight, hidden: true },
+  ghostShown: { hidden: false },
+  ghostAt: { left: 0, top: 0 },
+  list: { scrollAxes: "y", clip: true, radius: kitVars.radius, fill: tokens.surface, borderWidth: kitVars.focusWidth, borderColor: { default: tokens.border, ":focus": kitVars.focus } },
+  extent: { height: 0 },
+  content: { position: "relative", width: "100%" },
+  slot: { position: "absolute", left: 0, right: 0, direction: "row", alignItems: "center" },
+  slotHidden: { hidden: true },
+  slotCursor: { fill: kitVars.highlight },
+  slotAt: { top: 0, height: 0 },
+  rowMe: { fill: tokens.accent },
+  leader: { direction: "row", alignItems: "center", gap: kitVars.gap, padding: [0, kitVars.padding, 0, kitVars.padding], width: "100%", height: "100%" },
+  rank: { width: (44), fontSize: kitVars.body, fontWeight: 800, textColor: tokens.muted, textAlign: "center", pointerEvents: "none" },
+  name: { grow: 1, shrink: 1, fontSize: kitVars.body, textColor: tokens.text, pointerEvents: "none" },
+  score: { width: (96), fontSize: kitVars.body, fontWeight: 700, textColor: tokens.gold, textAlign: "right", pointerEvents: "none" },
+  gold: { textColor: tokens.gold },
+  silver: { textColor: kitVars.silver },
+  bronze: { textColor: kitVars.bronze },
+  onAccent: { textColor: tokens.onAccent }
+}, {
+  ghostAt: slotWords({ left: slot(0), top: slot(1) }),
+  extent: slotWords({ height: slot(0) }),
+  slotAt: slotWords({ top: slot(0), height: slot(1) })
+}), InventoryGrid = class {
+  constructor(ui, options) {
+    this.ui = ui;
+    this.cellStates = [];
+    this.cellA11y = [];
+    this.cursorAt = 0;
+    this.focused = false;
+    this.source = (-1);
+    this.hover = (-1);
+    this.travel = new Int32Array(2);
+    this.held = false;
+    this.columns = options.columns, this.rows = options.rows, this.size = options.cell ?? (64);
+    let gap = options.gap ?? (8);
+    this.pitch = this.size + gap, this.natural = options.natural ?? [this.size, this.size], this.onMove = options.onMove ?? null, this.onSelect = options.onSelect ?? null;
+    let count2 = this.columns * this.rows;
+    this.assets = new Int32Array(count2).fill((-1)), this.amounts = new Int32Array(count2), this.cellColumn = new Int32Array(count2), this.cellRow = new Int32Array(count2);
+    for (let i = 0; i < count2; i++)
+      this.cellColumn[i] = i % this.columns, this.cellRow[i] = Math.floor(i / this.columns);
+    this.names = new Array(count2).fill("Empty");
+    let sized = { width: this.size, height: this.size }, iconSize = { width: this.size * (0.7), height: this.size * (0.7) };
+    for (let state = 0; state < 8; state++) this.cellStates.push(ui.props(s2.cell, sized, (state & 1) !== 0 && s2.cellCursor, (state & 2) !== 0 && s2.cellHover, (state & 4) !== 0 && s2.cellSource));
+    this.iconStates = [ui.props(s2.icon, iconSize), ui.props(s2.icon, iconSize, s2.iconEmpty)], this.ghostStates = [ui.props(s2.ghost, sized), ui.props(s2.ghost, sized, s2.ghostShown)];
+    let mono = fontStyle(ui, "mono");
+    this.countStates = [ui.props(mono, s2.count), ui.props(mono, s2.count, sheet.hidden)], this.root = ui.box(ui.props(s2.grid, { gap }, options.style));
+    let cells = [], icons = [], counts = [];
+    for (let r = 0; r < this.rows; r++) {
+      let row = ui.box(ui.props(s2.gridRow, { gap }));
+      for (let c = 0; c < this.columns; c++) {
+        let index = r * this.columns + c, cell = ui.box(this.cellStates[0]);
+        cell.transition(["scale_x", "scale_y", "opacity"], { duration: (0.12), easing: "back_out" });
+        let icon = ui.image(0, this.natural, this.iconStates[1]), amount = ui.text("", this.countStates[1]);
+        cell.append(icon).append(amount), cell.on("tap", () => this.select(index)), cell.on("drag_start", () => this.begin(index)), cell.on("drag_move", (event) => this.drag(event)), cell.on("drag_end", () => this.drop());
+        let a11y = new A11y({ role: "button", label: "Empty", actions: ["activate"] });
+        a11y.apply(cell), this.cellA11y.push(a11y), row.append(cell), cells.push(cell), icons.push(icon), counts.push(amount);
+      }
+      this.root.append(row);
+    }
+    this.cells = cells, this.icons = icons, this.counts = counts, this.ghost = ui.box(this.ghostStates[0]), this.ghostIcon = ui.image(0, this.natural, ui.props(s2.icon, iconSize)), this.ghost.append(this.ghostIcon), this.root.append(this.ghost), this.root.accessibility({ role: "group", label: options.label ?? "Inventory" }), options.scope?.add(this);
+  }
+  get cursor() {
+    return this.cursorAt;
+  }
+  get dragging() {
+    return this.source;
+  }
+  setSlot(index, asset, count2, name) {
+    this.assets[index] = asset, this.amounts[index] = asset === (-1) ? 0 : count2, this.names[index] = asset === (-1) ? "Empty" : name, this.render(index);
+  }
+  clearSlot(index) {
+    this.setSlot(index, (-1), 0, "Empty");
+  }
+  swap(a, b) {
+    if (a === b) return;
+    let asset = this.assets[a], amount = this.amounts[a], name = this.names[a];
+    this.assets[a] = this.assets[b], this.amounts[a] = this.amounts[b], this.names[a] = this.names[b], this.assets[b] = asset, this.amounts[b] = amount, this.names[b] = name, this.render(a), this.render(b);
+  }
+  select(index) {
+    let previous = this.cursorAt;
+    this.cursorAt = index, this.paint(previous), this.paint(index), this.onSelect?.(index);
+  }
+  focusChanged(focused) {
+    this.focused = focused, this.paint(this.cursorAt);
+  }
+  move(move) {
+    let c = this.cellColumn[this.cursorAt], r = this.cellRow[this.cursorAt], next = (-1);
+    if (move === "left" && c > 0 ? next = this.cursorAt - 1 : move === "right" && c + 1 < this.columns ? next = this.cursorAt + 1 : move === "up" && r > 0 ? next = this.cursorAt - this.columns : move === "down" && r + 1 < this.rows && (next = this.cursorAt + this.columns), next === (-1)) return false;
+    let previous = this.cursorAt;
+    return this.cursorAt = next, this.held && (this.hover = next, this.placeGhost(next)), this.paint(previous), this.paint(next), true;
+  }
+  activate() {
+    if (!this.held) {
+      if (this.assets[this.cursorAt] === (-1)) {
+        this.onSelect?.(this.cursorAt);
+        return;
+      }
+      this.begin(this.cursorAt), this.held = true, this.hover = this.cursorAt, this.placeGhost(this.cursorAt);
+      return;
+    }
+    this.held = false, this.drop();
+  }
+  cancel() {
+    return this.source === (-1) ? false : (this.held = false, this.hover = (-1), this.drop(), true);
+  }
+  begin(index) {
+    this.assets[index] !== (-1) && (this.source = index, this.hover = index, this.travel[0] = 0, this.travel[1] = 0, this.ghostIcon.image(this.assets[index], this.natural[0], this.natural[1]), this.placeGhost(index), this.paint(index));
+  }
+  drag(event) {
+    let source = this.source;
+    if (source === (-1) || this.held) return;
+    let travel = this.travel;
+    travel[0] += event.dx * TRAVEL_SCALE | 0, travel[1] += event.dy * TRAVEL_SCALE | 0, this.placeGhost(source);
+    let c = this.cellColumn[source] + this.pitchesIn(travel[0]), r = this.cellRow[source] + this.pitchesIn(travel[1]), next = c < 0 || r < 0 || c >= this.columns || r >= this.rows ? (-1) : r * this.columns + c;
+    if (next === this.hover) return;
+    let previous = this.hover;
+    this.hover = next, previous !== (-1) && this.paint(previous), next !== (-1) && this.paint(next);
+  }
+  drop() {
+    let source = this.source;
+    if (source === (-1)) return;
+    let target = this.hover;
+    this.source = (-1), this.hover = (-1), this.ghost.style(this.ghostStates[0]), this.paint(source), target !== (-1) && this.paint(target), !(target === (-1) || target === source) && (this.swap(source, target), this.onMove?.(source, target));
+  }
+  pitchesIn(travel) {
+    let pitch = this.pitch * TRAVEL_SCALE, half = pitch >> 1, rest = travel, count2 = 0;
+    for (; rest >= half; )
+      rest -= pitch, count2++;
+    for (; rest < -half; )
+      rest += pitch, count2--;
+    return count2;
+  }
+  placeGhost(index) {
+    SLOTS[0] = (8) + this.cellColumn[index] * this.pitch + (this.travel[0] >> (4)), SLOTS[1] = (8) + this.cellRow[index] * this.pitch + (this.travel[1] >> (4)), this.ghost.style(this.ui.props(this.source === (-1) ? this.ghostStates[0] : this.ghostStates[1], s2.ghostAt.setSlotsFrom(SLOTS)));
+  }
+  render(index) {
+    let asset = this.assets[index], icon = this.icons[index];
+    asset === (-1) ? icon.style(this.iconStates[1]) : (icon.image(asset, this.natural[0], this.natural[1]), icon.style(this.iconStates[0]));
+    let amount = this.amounts[index], text = this.counts[index];
+    amount > 1 ? (text.number(amount, PLAIN), text.style(this.countStates[0])) : text.style(this.countStates[1]);
+    let a11y = this.cellA11y[index];
+    a11y.options.label = this.names[index], a11y.apply(this.cells[index]);
+  }
+  paint(index) {
+    if (index < 0) return;
+    let cursor = this.focused && index === this.cursorAt ? 1 : 0, hover = index === this.hover && index !== this.source ? 2 : 0, source = index === this.source ? 4 : 0;
+    this.cells[index].style(this.cellStates[cursor | hover | source]);
+  }
+};
+function inventoryGrid(ui, options) {
+  return new InventoryGrid(ui, options);
+}
+var VirtualList = class {
+  constructor(ui, options) {
+    this.ui = ui;
+    this.options = options;
+    this.offsetY = 0;
+    this.cursorAt = 0;
+    this.focused = false;
+    this.total = Math.max(0, options.count), this.rowHeight = options.rowHeight ?? (44), this.height = options.height ?? (320), this.onSelect = options.onSelect ?? null, this.heightOf = options.heightOf ?? null, this.offsets = new Float64Array(this.heightOf === null ? 1 : this.total + 1), this.measureRows(0);
+    let pool = Math.ceil(this.height / this.rowHeight) + (2);
+    this.bound = new Int32Array(pool).fill((-1)), this.flags = new Uint8Array(pool).fill(255), this.states = [ui.props(s2.slot), ui.props(s2.slot, s2.slotCursor), ui.props(s2.slot, s2.slotHidden)], this.root = ui.scroll(ui.props(s2.list, { height: this.height, width: options.width ?? "100%" }, options.style)), this.content = ui.box();
+    let slots = [], rows = [];
+    for (let p = 0; p < pool; p++) {
+      let element = ui.box(this.states[2]), row = options.create(ui);
+      element.append(row.root), element.on("tap", () => {
+        let index = this.bound[p];
+        index !== (-1) && this.choose(index);
+      }), this.content.append(element), slots.push(element), rows.push(row);
+    }
+    this.slots = slots, this.rows = rows, this.root.append(this.content), this.root.on("scroll", (event) => this.scrolled(event.dy)), this.root.accessibility({ role: "scroll_view", label: options.label ?? "List", actions: ["scroll"] }), this.extend(), this.refresh(true), options.scope?.add(this);
+  }
+  get count() {
+    return this.total;
+  }
+  get offset() {
+    return this.offsetY;
+  }
+  get cursor() {
+    return this.cursorAt;
+  }
+  get pool() {
+    return this.slots.length;
+  }
+  get variable() {
+    return this.heightOf !== null;
+  }
+  rowTop(index) {
+    return this.heightOf === null ? index * this.rowHeight : this.offsets[index];
+  }
+  rowSize(index) {
+    return this.heightOf === null ? this.rowHeight : this.offsets[index + 1] - this.offsets[index];
+  }
+  get contentHeight() {
+    return this.heightOf === null ? this.total * this.rowHeight : this.offsets[this.total];
+  }
+  invalidateHeights(from = 0) {
+    this.heightOf !== null && (this.measureRows(clamp(from, 0, this.total)), this.extend(), this.offsetY = clamp(this.offsetY, 0, this.maxOffset()) | 0, this.refresh(true));
+  }
+  measureRows(from) {
+    let heightOf = this.heightOf;
+    if (heightOf === null) return;
+    if (this.offsets.length < this.total + 1) {
+      let grown = new Float64Array(Math.max(this.total + 1, this.offsets.length * 2));
+      grown.set(this.offsets.subarray(0, from + 1)), this.offsets = grown;
+    }
+    let offsets = this.offsets;
+    offsets[0] = 0;
+    for (let i = from; i < this.total; i++) offsets[i + 1] = offsets[i] + Math.max(0, heightOf(i));
+  }
+  firstVisible(offset) {
+    if (this.heightOf === null) return (offset - offset % this.rowHeight) / this.rowHeight;
+    let offsets = this.offsets, low = 0, high = this.total;
+    for (; low < high; ) {
+      let middle = low + high >>> 1;
+      offsets[middle + 1] <= offset ? low = middle + 1 : high = middle;
+    }
+    return low;
+  }
+  setCount(count2) {
+    let previous = this.total;
+    this.total = Math.max(0, count2), this.measureRows(Math.min(previous, this.total)), this.cursorAt = clamp(this.cursorAt, 0, Math.max(0, this.total - 1)), this.extend(), this.offsetY = clamp(this.offsetY, 0, this.maxOffset()) | 0, this.refresh(true);
+  }
+  rebind() {
+    this.refresh(true);
+  }
+  scrollTo(offset) {
+    let next = clamp(offset, 0, this.maxOffset());
+    this.root.scrollTo(0, next), this.scrolled(next);
+  }
+  scrollToIndex(index) {
+    let top = this.rowTop(index), size = this.rowSize(index);
+    top < this.offsetY ? this.scrollTo(top) : top + size > this.offsetY + this.height && this.scrollTo(top + size - this.height);
+  }
+  focusChanged(focused) {
+    this.focused = focused, this.refresh(false);
+  }
+  move(move) {
+    if (this.total === 0) return false;
+    let next = this.cursorAt;
+    if (move === "up") next--;
+    else if (move === "down") next++;
+    else return false;
+    return next < 0 || next >= this.total ? false : (this.cursorAt = next, this.scrollToIndex(next), this.refresh(false), true);
+  }
+  activate() {
+    this.total > 0 && this.choose(this.cursorAt);
+  }
+  choose(index) {
+    this.cursorAt = index, this.refresh(false), this.onSelect?.(index);
+  }
+  scrolled(offset) {
+    this.offsetY = offset | 0, this.refresh(false);
+  }
+  maxOffset() {
+    return Math.max(0, this.contentHeight - this.height);
+  }
+  extend() {
+    SLOTS[0] = this.contentHeight, this.content.style(this.ui.props(s2.content, s2.extent.setSlotsFrom(SLOTS)));
+  }
+  refresh(force) {
+    let pool = this.slots.length, offset = this.offsetY < 0 ? 0 : this.offsetY, first = this.firstVisible(offset);
+    for (let k = 0; k < pool; k++) {
+      let index = first + k, p = index % pool, slotElement = this.slots[p], visible = index < this.total, flag = visible ? this.focused && index === this.cursorAt ? 1 : 0 : 2, moved = this.bound[p] !== index;
+      if (visible && (moved || force) && this.options.bind(this.rows[p], index), !moved && this.flags[p] === flag && !force) continue;
+      this.bound[p] = visible ? index : (-1), this.flags[p] = flag;
+      let fixed = this.heightOf === null;
+      SLOTS[0] = fixed || visible ? this.rowTop(index) : this.contentHeight, SLOTS[1] = fixed || !visible ? this.rowHeight : this.rowSize(index), slotElement.style(this.ui.props(this.states[flag], s2.slotAt.setSlotsFrom(SLOTS)));
+    }
+  }
+};
+function virtualList(ui, options) {
+  return new VirtualList(ui, options);
+}
+var Leaderboard = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.names = [];
+    this.scores = [];
+    this.me = (-1);
+    this.rowStates = [ui.props(s2.leader), ui.props(s2.leader, s2.rowMe)];
+    let mono = fontStyle(ui, "mono"), body = fontStyle(ui, "body");
+    this.rankStates = [ui.props(mono, s2.rank), ui.props(mono, s2.rank, s2.gold), ui.props(mono, s2.rank, s2.silver), ui.props(mono, s2.rank, s2.bronze), ui.props(mono, s2.rank, s2.onAccent)], this.nameStates = [ui.props(body, s2.name), ui.props(body, s2.name, s2.onAccent)], this.scoreStyle = ui.props(mono, s2.score), this.list = new VirtualList(ui, {
+      count: 0,
+      rowHeight: options.rowHeight,
+      height: options.height,
+      width: options.width,
+      label: options.label ?? "Leaderboard",
+      style: options.style,
+      scope: options.scope,
+      onSelect: options.onSelect,
+      create: (owner) => {
+        let root = owner.box(this.rowStates[0]), rank = owner.text("", this.rankStates[0]), name = owner.text("", this.nameStates[0]), score = owner.text("", this.scoreStyle);
+        return root.append(rank).append(name).append(score), { root, rank, name, score };
+      },
+      bind: (row, index) => this.bind(row, index)
+    });
+  }
+  get root() {
+    return this.list.root;
+  }
+  setEntries(names, scores, me = (-1)) {
+    this.names = names, this.scores = scores, this.me = me, this.list.setCount(Math.min(names.length, scores.length));
+  }
+  showMe() {
+    this.me !== (-1) && this.list.scrollToIndex(this.me);
+  }
+  bind(row, index) {
+    let mine = index === this.me;
+    row.root.style(this.rowStates[mine ? 1 : 0]), row.rank.style(this.rankStates[mine ? 4 : index < (3) ? index + 1 : 0]), row.rank.number(index + 1, PLAIN), row.name.text(this.names[index]), row.name.style(this.nameStates[mine ? 1 : 0]), row.score.number(this.scores[index], INTEGER);
+  }
+};
+function leaderboard(ui, options = {}) {
+  return new Leaderboard(ui, options);
+}
+var CHAT_LOG_WIDTH = 300, CHAT_LOG_HEIGHT = 240, CHAT_LOG_FONT = 14, CHAT_LOG_PADDING = 6, CHAT_LOG_CAPACITY = 2e3, CHAT_LOG_MIN_ROW = 18, SCROLL_END = Number.MAX_SAFE_INTEGER, chatLogStyles = styles({
+  row: { width: "100%", height: "100%", padding: [0, (6), 0, (6)], justify: "center" },
+  line: { textWrap: true, textColor: tokens.text, pointerEvents: "none" }
+}), ChatLog = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.lines = [];
+    this.head = 0;
+    this.measured = { lines: 0, width: 0, height: 0 };
+    let width = options.width ?? (300), fontSize = options.fontSize ?? (14);
+    this.capacity = options.capacity ?? (2e3), this.lineWidth = width - (6) * 2, this.measureStyle = { fontFamily: kitFamily(ui, "body"), fontSize };
+    let lineStyle = ui.props(fontStyle(ui, "body"), chatLogStyles.line, { fontSize }), rowStyle = ui.props(chatLogStyles.row);
+    this.list = new VirtualList(ui, {
+      count: 0,
+      rowHeight: Math.min((18), fontSize),
+      height: options.height ?? (240),
+      width,
+      label: options.label ?? "Chat",
+      style: options.style,
+      scope: options.scope,
+      heightOf: (index) => this.heightOf(index),
+      create: (owner) => {
+        let root = owner.box(rowStyle), line = owner.text("", lineStyle);
+        return root.append(line), { root, line };
+      },
+      bind: (row, index) => {
+        row.line.text(this.line(index));
+      }
+    });
+  }
+  get root() {
+    return this.list.root;
+  }
+  get count() {
+    return this.lines.length;
+  }
+  line(index) {
+    return this.lines[(this.head + index) % this.lines.length];
+  }
+  push(sender, message) {
+    let text = sender.length > 0 ? `${sender}: ${message}` : message;
+    this.lines.length < this.capacity ? (this.lines.push(text), this.list.setCount(this.lines.length)) : (this.lines[this.head] = text, this.head = (this.head + 1) % this.capacity, this.list.invalidateHeights(0)), this.list.scrollTo(SCROLL_END);
+  }
+  heightOf(index) {
+    return this.ui.measureText(this.line(index), this.measureStyle, this.lineWidth, this.measured).height;
+  }
+};
+function chatLog(ui, options = {}) {
+  return new ChatLog(ui, options);
+}
+
+// src/interactives/game-ui/widgets/focus.ts
+var UiFocusScope = class {
+  constructor(columns = 1, onBack = null) {
+    this.columns = columns;
+    this.onBack = onBack;
+    this.targets = [];
+    this.current = -1;
+  }
+  add(target) {
+    return this.targets.indexOf(target) < 0 && this.targets.push(target), this;
+  }
+  remove(target) {
+    let at = this.targets.indexOf(target);
+    return at < 0 ? this : (removeAt(this.targets, at), this.current === at ? this.current = -1 : this.current > at && this.current--, this);
+  }
+  clear() {
+    this.targets.length = 0, this.current = -1;
+  }
+};
+function focusNodeOf(target) {
+  return target.focusNode ?? target.root;
+}
+function usable(target) {
+  let root = focusNodeOf(target);
+  return !root.destroyed && (root.active() & Condition.disabled) === 0;
+}
+function stepOf(move, columns) {
+  switch (move) {
+    case "next":
+    case "right":
+      return 1;
+    case "previous":
+    case "left":
+      return -1;
+    case "down":
+      return columns;
+    default:
+      return -columns;
+  }
+}
+var UiNavigator = class {
+  constructor(base = new UiFocusScope()) {
+    this.scopes = new StableList();
+    this.listeners = [];
+    this.shown = null;
+    this.base = base, this.scopes.push(base);
+  }
+  get scope() {
+    return this.scopes.at(this.scopes.size - 1);
+  }
+  get depth() {
+    return this.scopes.size;
+  }
+  get focused() {
+    return this.shown;
+  }
+  onChange(listener) {
+    return this.listeners.push(listener), () => {
+      let at = this.listeners.indexOf(listener);
+      at >= 0 && removeAt(this.listeners, at);
+    };
+  }
+  has(scope) {
+    return this.scopes.indexOf(scope) >= 0;
+  }
+  push(scope) {
+    this.has(scope) || (this.scopes.push(scope), this.restore(scope));
+  }
+  pop(scope = null) {
+    let target = scope ?? this.scope;
+    if (target === this.base) return;
+    let at = this.scopes.indexOf(target);
+    if (at < 0) return;
+    let wasTop = at === this.scopes.size - 1;
+    this.scopes.removeAt(at), wasTop && this.restore(this.scope);
+  }
+  focus(target) {
+    let scope = this.scope, at = scope.targets.indexOf(target);
+    return at < 0 || !usable(target) ? false : (this.show(scope, at), true);
+  }
+  move(move) {
+    let scope = this.scope, count2 = scope.targets.length;
+    if (count2 === 0) return false;
+    let at = scope.current;
+    if (at >= 0 && at < count2 && this.shown === scope.targets[at]) {
+      let current = scope.targets[at];
+      if (current.move !== void 0 && current.move(move)) return true;
+    } else
+      return this.first(scope);
+    let step = stepOf(move, scope.columns);
+    for (let i = 1; i <= count2; i++) {
+      let next = ((at + step * i) % count2 + count2) % count2;
+      if (next === at) break;
+      if (usable(scope.targets[next]))
+        return this.show(scope, next), true;
+    }
+    return false;
+  }
+  activate() {
+    let target = this.shown;
+    return target === null || target.activate === void 0 || !usable(target) ? false : (target.activate(), true);
+  }
+  back() {
+    let onBack = this.scope.onBack;
+    return onBack !== null && onBack();
+  }
+  blur() {
+    this.set(null);
+  }
+  first(scope) {
+    for (let i = 0; i < scope.targets.length; i++)
+      if (usable(scope.targets[i]))
+        return this.show(scope, i), true;
+    return this.set(null), false;
+  }
+  restore(scope) {
+    let at = scope.current;
+    at >= 0 && at < scope.targets.length && usable(scope.targets[at]) ? this.show(scope, at) : scope.targets.length > 0 ? this.first(scope) : this.set(null);
+  }
+  show(scope, at) {
+    scope.current = at, this.set(scope.targets[at]);
+  }
+  set(target) {
+    let previous = this.shown;
+    if (previous !== target) {
+      if (this.shown = target, previous !== null && !focusNodeOf(previous).destroyed) {
+        let node = focusNodeOf(previous);
+        node.setState("focus", false), previous.focusChanged?.(false), target === null && node.blur();
+      }
+      if (target !== null) {
+        let node = focusNodeOf(target);
+        node.setState("focus", true), node.focus(), target.focusChanged?.(true);
+      }
+      for (let i = 0; i < this.listeners.length; i++) this.listeners[i](target);
+    }
+  }
+};
+
+// src/interactives/game-ui/widgets/controls.ts
+var TRACK_WIDTH = 52, TRACK_HEIGHT = 30, KNOB = 24, KNOB_INSET = 3, RAIL = 6, THUMB = 24, SLIDER_HEIGHT = 32, SLIDER_WIDTH = 220, DROPDOWN_WIDTH = 200, OPTION_HEIGHT = 40, CHEVRON = 8, CHEVRON_TURN = Math.PI / 4, POPUP_Z = 50, MAX_LABELLED_STEPS = 1001, s3 = styles({
+  button: {
+    direction: "row",
+    alignItems: "center",
+    justify: "center",
+    gap: kitVars.gapSmall,
+    minHeight: (44),
+    padding: [kitVars.gap, kitVars.padding, kitVars.gap, kitVars.padding],
+    radius: kitVars.radius,
+    fill: { default: tokens.raised, ":disabled": tokens.track },
+    borderWidth: kitVars.focusWidth,
+    borderColor: { default: TRANSPARENT, ":focus": kitVars.focus },
+    scale: { default: 1, ":pressed": kitVars.pressScale },
+    opacity: { default: 1, ":disabled": 0.55 }
+  },
+  primary: { fill: { default: tokens.accent, ":disabled": tokens.track } },
+  danger: { fill: { default: tokens.danger, ":disabled": tokens.track } },
+  ghost: { fill: { default: TRANSPARENT, ":focus": kitVars.highlight, ":pressed": kitVars.highlight, ":disabled": TRANSPARENT } },
+  label: { fontSize: kitVars.body, fontWeight: 700, textColor: { default: tokens.text, ":disabled": tokens.muted }, pointerEvents: "none" },
+  onPrimary: { textColor: { default: tokens.onAccent, ":disabled": tokens.muted } },
+  onDanger: { textColor: { default: kitVars.onDanger, ":disabled": tokens.muted } },
+  icon: { width: 20, height: 20, pointerEvents: "none" },
+  row: {
+    direction: "row",
+    alignItems: "center",
+    justify: "space-between",
+    gap: kitVars.gap,
+    minHeight: (44),
+    padding: [kitVars.gapSmall, kitVars.gap, kitVars.gapSmall, kitVars.gap],
+    radius: kitVars.radius,
+    borderWidth: kitVars.focusWidth,
+    borderColor: { default: TRANSPARENT, ":focus": kitVars.focus },
+    fill: { default: TRANSPARENT, ":pressed": kitVars.highlight },
+    opacity: { default: 1, ":disabled": 0.5 }
+  },
+  track: { width: (52), height: (30), radius: (30) / 2, fill: tokens.track, padding: (3), justify: "center", pointerEvents: "none" },
+  trackOn: { fill: tokens.accent },
+  knob: {
+    width: (24),
+    height: (24),
+    radius: (24) / 2,
+    fill: tokens.text,
+    translateX: 0,
+    scale: { default: 1, ":pressed": 0.88 },
+    shadow: { color: kitVars.shadow, y: 1, blur: 3 }
+  },
+  knobOn: { translateX: (52) - (24) - (3) * 2, fill: tokens.onAccent },
+  slider: { gap: kitVars.gapSmall, padding: [kitVars.gapSmall, kitVars.gap, kitVars.gapSmall, kitVars.gap], radius: kitVars.radius, borderWidth: kitVars.focusWidth, borderColor: { default: TRANSPARENT, ":focus": kitVars.focus }, opacity: { default: 1, ":disabled": 0.5 } },
+  header: { direction: "row", justify: "space-between", alignItems: "center", pointerEvents: "none" },
+  rail: { height: (32), position: "relative" },
+  railLine: { position: "absolute", left: 0, right: 0, top: ((32) - (6)) / 2, height: (6), radius: (6) / 2, fill: tokens.track, pointerEvents: "none" },
+  railFill: { position: "absolute", left: 0, top: ((32) - (6)) / 2, height: (6), radius: (6) / 2, fill: tokens.accent, pointerEvents: "none" },
+  thumb: {
+    position: "absolute",
+    top: ((32) - (24)) / 2,
+    width: (24),
+    height: (24),
+    marginLeft: -(24) / 2,
+    radius: (24) / 2,
+    fill: tokens.text,
+    borderWidth: kitVars.focusWidth,
+    borderColor: { default: TRANSPARENT, ":focus": kitVars.focus },
+    scale: { default: 1, ":pressed": 1.15 },
+    shadow: { color: kitVars.shadow, y: 1, blur: 4 },
+    pointerEvents: "none"
+  },
+  fillTo: { width: "0%" },
+  thumbAt: { left: "0%" },
+  dropdown: { position: "relative", gap: kitVars.gapSmall },
+  field: { justify: "space-between" },
+  chevron: { width: (8), height: (8), borderColor: tokens.muted, borderWidth: [0, 2, 2, 0], rotate: CHEVRON_TURN, marginTop: -(8) / 2, pointerEvents: "none" },
+  chevronOpen: { rotate: -CHEVRON_TURN * 3, marginTop: (8) / 2 },
+  popup: {
+    position: "absolute",
+    top: "100%",
+    left: 0,
+    right: 0,
+    marginTop: kitVars.gapSmall,
+    padding: kitVars.gapSmall,
+    gap: 2,
+    fill: tokens.surface,
+    radius: kitVars.radius,
+    borderWidth: kitVars.borderWidth,
+    borderColor: tokens.border,
+    shadow: { color: kitVars.shadow, y: 8, blur: 24 },
+    zIndex: (50),
+    hidden: true
+  },
+  option: {
+    minHeight: (40),
+    justify: "center",
+    padding: [kitVars.gapSmall, kitVars.gap, kitVars.gapSmall, kitVars.gap],
+    radius: kitVars.radiusSmall,
+    fill: { default: TRANSPARENT, ":focus": kitVars.highlight, ":pressed": kitVars.highlight },
+    borderWidth: kitVars.focusWidth,
+    borderColor: { default: TRANSPARENT, ":focus": kitVars.focus }
+  },
+  optionOn: { fill: { default: tokens.accent, ":focus": tokens.accent } }
+}, {
+  fillTo: slotWords({ width: slot(0, true) }),
+  thumbAt: slotWords({ left: slot(0, true) })
+}), TextButton = class {
+  constructor(ui, options) {
+    this.ui = ui;
+    let variant = options.variant ?? "secondary";
+    this.onPress = options.onPress ?? null, this.root = ui.box(ui.props(s3.button, variant === "primary" && s3.primary, variant === "danger" && s3.danger, variant === "ghost" && s3.ghost, options.style)), this.root.transition(["scale_x", "scale_y", "fill"], { duration: (0.12), easing: "back_out" }), options.icon !== void 0 && this.root.append(ui.image(options.icon, options.natural ?? [32, 32], s3.icon)), this.text = label(ui, options.label, "body", s3.label, variant === "primary" ? s3.onPrimary : variant === "danger" ? s3.onDanger : null, options.labelStyle), this.root.append(this.text), this.root.on("tap", () => this.activate()), this.a11y = new A11y({ role: "button", label: options.label, disabled: options.disabled === true, actions: ["activate"] }), this.a11y.apply(this.root), options.scope?.add(this);
+  }
+  get disabled() {
+    return this.a11y.options.disabled === true;
+  }
+  setLabel(value) {
+    this.text.text(value), this.a11y.options.label = value, this.a11y.apply(this.root);
+  }
+  setDisabled(disabled) {
+    disabled !== this.disabled && (this.a11y.options.disabled = disabled, this.a11y.apply(this.root));
+  }
+  activate() {
+    this.disabled || this.onPress?.();
+  }
+};
+function textButton(ui, options) {
+  return new TextButton(ui, options);
+}
+var Toggle = class {
+  constructor(ui, options) {
+    this.on = options.value ?? false, this.onChange = options.onChange ?? null, this.root = ui.box(ui.props(s3.row, options.style)), this.root.append(label(ui, options.label, "body", sheet.text)), this.tracks = [ui.props(s3.track), ui.props(s3.track, s3.trackOn)], this.knobs = [ui.props(s3.knob), ui.props(s3.knob, s3.knobOn)], this.track = ui.box(this.tracks[this.on ? 1 : 0]), this.knob = ui.box(this.knobs[this.on ? 1 : 0]), this.track.transition(["fill"], { duration: (0.18) }), this.knob.transition(["translate_x", "scale_x", "scale_y"], { duration: (0.18), easing: "back_out" }), this.track.append(this.knob), this.root.append(this.track), this.root.on("tap", () => this.activate()), this.a11y = new A11y({ role: "button", label: options.label, value: this.on ? "On" : "Off", selected: this.on, disabled: options.disabled === true, actions: ["activate"] }), this.a11y.apply(this.root), options.scope?.add(this);
+  }
+  get value() {
+    return this.on;
+  }
+  set(value, notify = false) {
+    if (value === this.on) return;
+    this.on = value;
+    let index = value ? 1 : 0;
+    this.track.style(this.tracks[index]), this.knob.style(this.knobs[index]), this.a11y.options.value = value ? "On" : "Off", this.a11y.options.selected = value, this.a11y.apply(this.root), notify && this.onChange?.(value);
+  }
+  setDisabled(disabled) {
+    this.a11y.options.disabled !== disabled && (this.a11y.options.disabled = disabled, this.a11y.apply(this.root));
+  }
+  activate() {
+    this.a11y.options.disabled !== true && this.set(!this.on, true);
+  }
+};
+function toggle(ui, options) {
+  return new Toggle(ui, options);
+}
+var Slider = class {
+  constructor(ui, options) {
+    this.ui = ui;
+    this.index = -1;
+    this.dragFrom = 0;
+    this.travel = new Float64Array(1);
+    this.min = options.min ?? 0, this.max = options.max ?? 1, this.step = options.step ?? (this.max - this.min) / (100), this.width = options.width ?? (220), this.onChange = options.onChange ?? null, this.steps = Math.max(1, Math.round((this.max - this.min) / this.step));
+    let format = options.format ?? ((value) => percentLabel(value, this.min, this.max));
+    this.texts = this.steps < (1001) ? Array.from({ length: this.steps + 1 }, (_, i) => format(this.min + i * this.step)) : null, this.root = ui.box(ui.props(s3.slider, { width: this.width }, options.style));
+    let header = ui.box(s3.header);
+    header.append(label(ui, options.label, "body", sheet.text)), this.readout = label(ui, "", "mono", sheet.small, sheet.strong), header.append(this.readout), this.rail = ui.box(s3.rail), this.rail.append(ui.box(s3.railLine)), this.fill = ui.box(), this.thumb = ui.box(), this.rail.append(this.fill).append(this.thumb), this.root.append(header).append(this.rail), this.rail.on("drag_start", () => {
+      this.dragFrom = this.index, this.travel[0] = 0;
+    }), this.rail.on("drag_move", (event) => {
+      let travel = this.travel;
+      travel[0] += event.dx, this.select(this.dragFrom + Math.round(travel[0] / this.width * this.steps), true);
+    }), this.root.on("action", (event) => {
+      event.value === UiAction.increment ? this.nudge(1) : event.value === UiAction.decrement && this.nudge(-1);
+    }), this.a11y = new A11y({ role: "adjustable", label: options.label, disabled: options.disabled === true, actions: ["increment", "decrement"] }), this.set(options.value ?? this.min), options.scope?.add(this);
+  }
+  get value() {
+    return clamp(this.min + this.index * this.step, this.min, this.max);
+  }
+  set(value, notify = false) {
+    this.select(Math.round((clamp(value, this.min, this.max) - this.min) / this.step), notify);
+  }
+  select(step, notify = false) {
+    let next = step < 0 ? 0 : step > this.steps ? this.steps : step;
+    if (next === this.index) return;
+    this.index = next;
+    let ui = this.ui;
+    SLOTS[0] = next * (100) / this.steps, this.fill.style(ui.props(s3.railFill, s3.fillTo.setSlotsFrom(SLOTS))), this.thumb.style(ui.props(s3.thumb, s3.thumbAt.setSlotsFrom(SLOTS)));
+    let text = this.texts === null ? PERCENT_TEXT[Math.round(next * (100) / this.steps)] : this.texts[next];
+    this.readout.text(text), this.a11y.options.value = text, this.a11y.apply(this.root), notify && this.onChange?.(this.value);
+  }
+  nudge(direction) {
+    this.a11y.options.disabled !== true && this.select(this.index + direction, true);
+  }
+  setDisabled(disabled) {
+    this.a11y.options.disabled !== disabled && (this.a11y.options.disabled = disabled, this.a11y.apply(this.root));
+  }
+  move(move) {
+    if (move === "left") this.nudge(-1);
+    else if (move === "right") this.nudge(1);
+    else return false;
+    return true;
+  }
+};
+function percentLabel(value, min, max) {
+  let percent = max > min ? Math.round((value - min) / (max - min) * (100)) : 0;
+  return PERCENT_TEXT[clamp(percent, 0, (100))];
+}
+function slider(ui, options) {
+  return new Slider(ui, options);
+}
+var DropdownOption = class {
+  constructor(ui, owner, index, value) {
+    this.owner = owner;
+    this.index = index;
+    this.root = ui.box(owner.optionProps[0]), this.text = label(ui, value, "body", sheet.text), this.root.append(this.text), this.root.on("tap", () => this.activate()), this.a11y = new A11y({ role: "button", label: value, selected: false, actions: ["activate"] }), this.a11y.apply(this.root);
+  }
+  mark(selected) {
+    this.root.style(this.owner.optionProps[selected ? 1 : 0]), this.text.style(this.owner.optionText[selected ? 1 : 0]), this.a11y.options.selected = selected, this.a11y.apply(this.root);
+  }
+  activate() {
+    this.owner.choose(this.index, true);
+  }
+}, Dropdown = class {
+  constructor(ui, options) {
+    this.options = options;
+    this.chosen = -1;
+    this.shown = false;
+    this.onChange = options.onChange ?? null, this.navigator = options.navigator ?? null, this.optionProps = [ui.props(s3.option), ui.props(s3.option, s3.optionOn)];
+    let body = fontStyle(ui, "body");
+    this.optionText = [ui.props(body, sheet.text), ui.props(body, sheet.text, s3.onPrimary)], this.popups = [ui.props(s3.popup), ui.props(s3.popup, sheet.shown)], this.chevrons = [ui.props(s3.chevron), ui.props(s3.chevron, s3.chevronOpen)], this.root = ui.box(ui.props(s3.dropdown, { width: options.width ?? (200) }, options.style)), this.root.append(label(ui, options.label, "body", sheet.small)), this.field = ui.box(ui.props(s3.button, s3.field)), this.field.transition(["scale_x", "scale_y"], { duration: (0.12), easing: "back_out" }), this.current = label(ui, "", "body", s3.label), this.chevron = ui.box(this.chevrons[0]), this.chevron.transition(["rotate"], { duration: (0.18) }), this.field.append(this.current).append(this.chevron), this.popup = ui.box(this.popups[0]), this.scope = new UiFocusScope(1, () => (this.close(), true));
+    let items = [];
+    for (let i = 0; i < options.options.length; i++) {
+      let item = new DropdownOption(ui, this, i, options.options[i]);
+      this.popup.append(item.root), this.scope.add(item), items.push(item);
+    }
+    this.items = items, this.root.append(this.field).append(this.popup), this.field.on("tap", () => this.activate()), this.a11y = new A11y({ role: "button", label: options.label, value: "", disabled: options.disabled === true, actions: ["activate"] }), this.choose(options.selected ?? 0, false), this.popupA11y = new A11y({ role: "group", label: options.label, hidden: true, modal: false }), this.popupA11y.apply(this.popup), options.scope?.add(this);
+  }
+  get focusNode() {
+    return this.field;
+  }
+  get selected() {
+    return this.chosen;
+  }
+  get open() {
+    return this.shown;
+  }
+  choose(index, notify) {
+    let next = clamp(index, 0, this.items.length - 1);
+    if (next !== this.chosen) {
+      this.chosen >= 0 && this.items[this.chosen].mark(false), this.chosen = next, this.items[next].mark(true);
+      let value = this.options.options[next];
+      this.current.text(value), this.a11y.options.value = value, this.a11y.apply(this.field), notify && this.onChange?.(next);
+    }
+    notify && this.close();
+  }
+  activate() {
+    this.a11y.options.disabled !== true && (this.shown ? this.close() : this.show());
+  }
+  show() {
+    this.shown || (this.shown = true, this.popup.style(this.popups[1]), this.chevron.style(this.chevrons[1]), this.popupA11y.options.hidden = false, this.popupA11y.options.modal = true, this.popupA11y.apply(this.popup), this.scope.current = this.chosen, this.navigator?.push(this.scope));
+  }
+  close() {
+    this.shown && (this.shown = false, this.popup.style(this.popups[0]), this.chevron.style(this.chevrons[0]), this.popupA11y.options.hidden = true, this.popupA11y.options.modal = false, this.popupA11y.apply(this.popup), this.navigator?.pop(this.scope));
+  }
+  setDisabled(disabled) {
+    this.a11y.options.disabled !== disabled && (disabled && this.close(), this.a11y.options.disabled = disabled, this.a11y.apply(this.field));
+  }
+  move(move) {
+    return this.shown || move !== "left" && move !== "right" ? false : (this.choose(this.chosen + (move === "left" ? -1 : 1), true), true);
+  }
+};
+function dropdown(ui, options) {
+  return new Dropdown(ui, options);
+}
+
+// src/interactives/game-ui/widgets/hud.ts
+var PULSE_SECONDS = 0.16, REMAIN = 0, PULSE = 1, TAU = Math.PI * 2, MINIMAP = 160, MARKER = 8, MARKER_KINDS = 4, NEEDLE_WIDTH = 4, NEEDLE_HEIGHT = 14, PLAYER = 10, RADIAL_RADIUS = 96, RADIAL_ITEM = 56, RADIAL_CENTER = 76, RADIAL_DEAD_ZONE = 18, RADIAL_ICON = 28, DIRECTION_SCALE = 1024, TRAVEL_SHIFT2 = 4, TRAVEL_SCALE2 = 1 << (4), DAMAGE_WIDTH = 120, HALF_DAMAGE_WIDTH = (120) / 2, DAMAGE_SECONDS = 0.9, DAMAGE_RISE = 56, DAMAGE_POP = 1.35, DAMAGE_Z = 700, DAMAGE_KINDS = 4, POP_SPEED = 4, CONFIG_SECONDS = 0, CONFIG_RISE = 1, BADGE = 20, BADGE_DOT = 10, BADGE_MAX = 99, BADGE_OFFSET = -6, s4 = styles({
+  timer: {
+    direction: "row",
+    alignItems: "center",
+    gap: kitVars.gapSmall,
+    padding: [kitVars.gapSmall, kitVars.gap, kitVars.gapSmall, kitVars.gap],
+    radius: kitVars.radius,
+    fill: tokens.surface,
+    borderWidth: kitVars.borderWidth,
+    borderColor: tokens.border,
+    scale: 1
+  },
+  timerWarn: { fill: tokens.danger, borderColor: tokens.danger },
+  timerPulse: { scale: 1.12 },
+  timerText: { fontSize: kitVars.title, fontWeight: 800, textColor: tokens.text, pointerEvents: "none" },
+  timerTextWarn: { textColor: kitVars.onDanger },
+  map: { position: "relative", clip: true, fill: tokens.surface, borderWidth: 3, borderColor: tokens.border, shadow: { color: kitVars.shadow, y: 4, blur: 12 } },
+  mapImage: { position: "absolute", left: 0, top: 0, pointerEvents: "none" },
+  pan: { translate: [0, 0] },
+  marker: { position: "absolute", left: "50%", top: "50%", width: (8), height: (8), marginLeft: -(8) / 2, marginTop: -(8) / 2, radius: (8) / 2, borderWidth: 1, borderColor: tokens.surface, pointerEvents: "none", hidden: true },
+  markerShown: { hidden: false },
+  markerAt: { translate: [0, 0] },
+  markerAccent: { fill: tokens.accent },
+  markerDanger: { fill: tokens.danger },
+  markerSuccess: { fill: tokens.success },
+  markerGold: { fill: tokens.gold },
+  player: { position: "absolute", left: "50%", top: "50%", width: (10), height: (10), marginLeft: -(10) / 2, marginTop: -(10) / 2, radius: (10) / 2, fill: tokens.text, borderWidth: 2, borderColor: tokens.accent, pointerEvents: "none" },
+  needle: { position: "absolute", left: "50%", top: "50%", width: (4), height: (14), marginLeft: -(4) / 2, marginTop: -(14), radius: (4) / 2, fill: tokens.accent, origin: [0.5, 1], pointerEvents: "none" },
+  heading: { rotate: 0 },
+  compass: { position: "absolute", top: 4, left: 0, right: 0, textAlign: "center", fontSize: kitVars.small, fontWeight: 800, textColor: tokens.text, pointerEvents: "none" },
+  radial: { position: "relative", alignItems: "center", justify: "center", scale: 0.6, opacity: 0, hidden: true },
+  radialOpen: { scale: 1, opacity: 1, hidden: false },
+  radialItem: {
+    position: "absolute",
+    left: "50%",
+    top: "50%",
+    width: (56),
+    height: (56),
+    marginLeft: -(56) / 2,
+    marginTop: -(56) / 2,
+    radius: (56) / 2,
+    alignItems: "center",
+    justify: "center",
+    fill: tokens.raised,
+    borderWidth: kitVars.focusWidth,
+    borderColor: tokens.border,
+    scale: 1
+  },
+  radialItemOn: { fill: tokens.accent, borderColor: kitVars.focus, scale: 1.15 },
+  radialIcon: { width: (28), height: (28), pointerEvents: "none" },
+  radialCenter: { width: (76), height: (76), radius: (76) / 2, alignItems: "center", justify: "center", padding: kitVars.gapSmall, fill: tokens.surface, borderWidth: kitVars.borderWidth, borderColor: tokens.border, pointerEvents: "none" },
+  damage: { position: "absolute", left: 0, top: 0, width: (120), textAlign: "center", fontSize: kitVars.title, fontWeight: 800, textColor: tokens.text, pointerEvents: "none", hidden: true },
+  damageShown: { hidden: false },
+  damageCrit: { textColor: tokens.gold, fontSize: kitVars.display },
+  damageHeal: { textColor: tokens.success },
+  damageMiss: { textColor: tokens.muted },
+  float: { translate: [0, 0], opacity: 1, scale: 1 },
+  badge: {
+    position: "absolute",
+    top: (-6),
+    right: (-6),
+    minWidth: (20),
+    height: (20),
+    padding: [0, 5, 0, 5],
+    radius: (20) / 2,
+    alignItems: "center",
+    justify: "center",
+    fill: tokens.danger,
+    borderWidth: 2,
+    borderColor: tokens.surface,
+    pointerEvents: "none",
+    scale: 1
+  },
+  badgeDot: { minWidth: (10), width: (10), height: (10), padding: 0, top: -2, right: -2 },
+  badgeBump: { scale: 1.3 },
+  badgeText: { fontSize: 11, fontWeight: 800, textColor: kitVars.onDanger, pointerEvents: "none" }
+}, {
+  pan: slotWords({ translate: [slot(0), slot(1)] }),
+  markerAt: slotWords({ translate: [slot(0), slot(1)] }),
+  heading: slotWords({ rotate: slot(0) }),
+  float: slotWords({ translate: [slot(0), slot(1)], opacity: slot(2), scale: slot(3) })
+}), Countdown = class {
+  constructor(ui, options) {
+    this.ui = ui;
+    this.clock = new Float64Array(2);
+    this.shown = -1;
+    this.warned = false;
+    this.mode = options.mode ?? "down", this.warnAt = options.warnAt ?? 0, this.onExpire = options.onExpire ?? null, this.clock[(0)] = this.mode === "down" ? options.seconds : 0, this.active = options.autostart ?? true, this.roots = [ui.props(s4.timer, options.style), ui.props(s4.timer, options.style, s4.timerWarn), ui.props(s4.timer, options.style, s4.timerWarn, s4.timerPulse)];
+    let mono = fontStyle(ui, "mono");
+    this.texts = [ui.props(mono, s4.timerText), ui.props(mono, s4.timerText, s4.timerTextWarn)], this.root = ui.box(this.roots[0]), this.root.transition(["scale_x", "scale_y", "fill"], { duration: (0.16), easing: "back_out" }), this.text = ui.text("", this.texts[0]), this.root.append(this.text), this.root.accessibility({ role: "text", label: options.label ?? "Timer" }), this.render();
+  }
+  get remaining() {
+    return this.clock[(0)];
+  }
+  get running() {
+    return this.active;
+  }
+  get warning() {
+    return this.warned;
+  }
+  start(seconds) {
+    this.clock[(0)] = this.mode === "down" ? seconds : 0, this.active = true, this.render();
+  }
+  pause() {
+    this.active = false;
+  }
+  resume() {
+    this.active = true;
+  }
+  add(seconds) {
+    let c = this.clock;
+    c[(0)] = Math.max(0, c[(0)] + seconds), this.render();
+  }
+  update(frame) {
+    let dt = frame[1], c = this.clock;
+    if (c[(1)] > 0 && (c[(1)] -= dt, c[(1)] <= 0 && this.root.style(this.roots[this.warned ? 1 : 0])), !!this.active) {
+      if (this.mode === "up") c[(0)] += dt;
+      else if (c[(0)] -= dt, c[(0)] <= 0) {
+        c[(0)] = 0, this.active = false, this.render(), this.onExpire?.();
+        return;
+      }
+      this.render();
+    }
+  }
+  render() {
+    let c = this.clock, truncated = c[(0)] | 0, whole = this.mode === "down" && truncated < c[(0)] ? truncated + 1 : truncated;
+    if (whole === this.shown) return;
+    this.shown = whole, this.text.number(whole, TIMER);
+    let warn = this.mode === "down" && this.warnAt > 0 && c[(0)] <= this.warnAt && c[(0)] > 0;
+    warn !== this.warned && (this.warned = warn, this.text.style(this.texts[warn ? 1 : 0])), warn ? (this.root.style(this.roots[2]), c[(1)] = (0.16)) : this.root.style(this.roots[0]);
+  }
+};
+function countdown(ui, options) {
+  return new Countdown(ui, options);
+}
+var MAP_PAN_X = 0, MAP_PAN_Y = 1, MAP_HEADING = 2, MARKER_INDEX = { accent: 0, danger: 1, success: 2, gold: 3 }, Minimap = class {
+  constructor(ui, options) {
+    this.ui = ui;
+    this.view = new Float64Array(3);
+    this.size = options.size ?? (160);
+    let map = options.mapSize ?? [this.size, this.size], radius = (options.shape ?? "circle") === "circle" ? this.size / 2 : 12;
+    this.root = ui.box(ui.props(s4.map, { width: this.size, height: this.size, radius }, options.style)), this.imageBase = ui.props(s4.mapImage, { width: map[0], height: map[1] }), SLOTS[0] = 0, SLOTS[1] = 0, this.image = ui.image(options.asset, options.natural, ui.props(this.imageBase, s4.pan.setSlotsFrom(SLOTS))), this.root.append(this.image);
+    let kindStates = [s4.markerAccent, s4.markerDanger, s4.markerSuccess, s4.markerGold], states = [];
+    for (let i = 0; i < (4); i++) states.push(ui.props(s4.marker, kindStates[i], s4.markerShown));
+    this.markerStates = states, this.hiddenMarker = ui.props(s4.marker);
+    let count2 = options.markers ?? 8;
+    this.kinds = new Int8Array(count2).fill(-1), this.shown = new Uint8Array(count2), this.points = new Float64Array(count2 * 2);
+    let markers = [];
+    for (let i = 0; i < count2; i++) {
+      let marker = ui.box(this.hiddenMarker);
+      this.root.append(marker), markers.push(marker);
+    }
+    this.markers = markers, this.needle = ui.box(ui.props(s4.needle, s4.heading.setSlotsFrom(SLOTS))), this.root.append(this.needle).append(ui.box(s4.player)), (options.compass ?? true) && this.root.append(label(ui, "N", "display", s4.compass)), this.root.accessibility({ role: "image", label: options.label ?? "Minimap" });
+  }
+  setImage(asset, width, height) {
+    this.image.image(asset, width, height);
+  }
+  pan(x, y) {
+    this.view[(0)] = x, this.view[(1)] = y, this.writePan();
+  }
+  heading(radians) {
+    this.view[(2)] = radians, this.writeHeading();
+  }
+  marker(index, x, y, kind = "accent") {
+    this.points[index * 2] = x, this.points[index * 2 + 1] = y, this.kinds[index] = MARKER_INDEX[kind], this.place(index);
+  }
+  setMarkerKind(index, kind) {
+    this.kinds[index] = MARKER_INDEX[kind];
+  }
+  hideMarker(index) {
+    this.kinds[index] = -1, this.place(index);
+  }
+  apply() {
+    this.writePan(), this.writeHeading();
+    for (let i = 0; i < this.markers.length; i++) this.place(i);
+  }
+  writePan() {
+    SLOTS[0] = this.view[(0)], SLOTS[1] = this.view[(1)], this.image.style(this.ui.props(this.imageBase, s4.pan.setSlotsFrom(SLOTS)));
+  }
+  writeHeading() {
+    SLOTS[0] = this.view[(2)], this.needle.style(this.ui.props(s4.needle, s4.heading.setSlotsFrom(SLOTS)));
+  }
+  place(index) {
+    let half = this.size * (0.5), x = this.points[index * 2], y = this.points[index * 2 + 1], k = this.kinds[index];
+    if (k < 0 || x < -half || x > half || y < -half || y > half) {
+      if (this.shown[index] === 0) return;
+      this.shown[index] = 0, this.markers[index].style(this.hiddenMarker);
+      return;
+    }
+    this.shown[index] = 1, SLOTS[0] = x, SLOTS[1] = y, this.markers[index].style(this.ui.props(this.markerStates[k], s4.markerAt.setSlotsFrom(SLOTS)));
+  }
+};
+function minimap(ui, options) {
+  return new Minimap(ui, options);
+}
+var RadialMenu = class {
+  constructor(ui, options) {
+    this.ui = ui;
+    this.chosen = -1;
+    this.shown = false;
+    this.travel = new Int32Array(2);
+    this.onSelect = options.onSelect ?? null, this.deadZone = options.deadZone ?? (18), this.directions = new Int32Array(options.items.length * 2);
+    let radius = options.radius ?? (96), span = radius * 2 + (56), sized = { width: span, height: span };
+    this.states = [ui.props(s4.radial, sized), ui.props(s4.radial, sized, s4.radialOpen)], this.root = ui.box(this.states[0]), this.root.transition(["scale_x", "scale_y", "opacity"], { duration: (0.18), easing: "back_out" });
+    let count2 = options.items.length, items = [], itemStates = [], labels = [];
+    for (let i = 0; i < count2; i++) {
+      let angle = -Math.PI / 2 + i / count2 * TAU;
+      this.directions[i * 2] = Math.round(Math.cos(angle) * (1024)), this.directions[i * 2 + 1] = Math.round(Math.sin(angle) * (1024));
+      let at = { translate: [Math.cos(angle) * radius, Math.sin(angle) * radius] }, pair = [ui.props(s4.radialItem, at), ui.props(s4.radialItem, at, s4.radialItemOn)], item = ui.box(pair[0]);
+      item.transition(["scale_x", "scale_y", "fill"], { duration: (0.12), easing: "back_out" });
+      let entry = options.items[i];
+      entry.icon !== void 0 ? item.append(ui.image(entry.icon, entry.natural ?? [(28), (28)], s4.radialIcon)) : item.append(label(ui, entry.label.slice(0, 2), "display", sheet.text, sheet.strong)), item.on("tap", () => {
+        this.select(i), this.confirm();
+      }), item.accessibility({ role: "button", label: entry.label, actions: ["activate"] }), this.root.append(item), items.push(item), itemStates.push(pair), labels.push(entry.label);
+    }
+    this.items = items, this.itemStates = itemStates, this.labels = labels;
+    let hub = ui.box(s4.radialCenter);
+    this.center = label(ui, "", "body", sheet.small, sheet.center, sheet.wrap), hub.append(this.center), this.root.append(hub), this.root.on("drag_start", () => {
+      this.travel[0] = 0, this.travel[1] = 0;
+    }), this.root.on("drag_move", (event) => {
+      this.travel[0] += event.dx * TRAVEL_SCALE2 | 0, this.travel[1] += event.dy * TRAVEL_SCALE2 | 0, this.aim();
+    }), this.root.on("drag_end", () => this.confirm()), this.a11y = new A11y({ role: "group", label: options.label ?? "Radial menu", hidden: true }), this.a11y.apply(this.root), options.scope?.add(this);
+  }
+  get open() {
+    return this.shown;
+  }
+  get selected() {
+    return this.chosen;
+  }
+  show() {
+    this.shown || (this.shown = true, this.root.style(this.states[1]), this.a11y.options.hidden = false, this.a11y.apply(this.root));
+  }
+  hide() {
+    this.shown && (this.shown = false, this.select(-1), this.root.style(this.states[0]), this.a11y.options.hidden = true, this.a11y.apply(this.root));
+  }
+  point(dx, dy) {
+    this.travel[0] = dx * TRAVEL_SCALE2 | 0, this.travel[1] = dy * TRAVEL_SCALE2 | 0, this.aim();
+  }
+  aim() {
+    let x = this.travel[0] >> (4), y = this.travel[1] >> (4);
+    if (x * x + y * y < this.deadZone * this.deadZone) {
+      this.select(-1);
+      return;
+    }
+    let directions = this.directions, best = 0, score = x * directions[0] + y * directions[1];
+    for (let i = 1; i < this.items.length; i++) {
+      let next = x * directions[i * 2] + y * directions[i * 2 + 1];
+      next > score && (score = next, best = i);
+    }
+    this.select(best);
+  }
+  select(index) {
+    index !== this.chosen && (this.chosen >= 0 && this.items[this.chosen].style(this.itemStates[this.chosen][0]), this.chosen = index, index >= 0 ? (this.items[index].style(this.itemStates[index][1]), this.center.text(this.labels[index])) : this.center.text(""));
+  }
+  confirm() {
+    let index = this.chosen;
+    return this.hide(), index >= 0 && this.onSelect?.(index), index;
+  }
+  activate() {
+    this.shown ? this.confirm() : this.show();
+  }
+  move(move) {
+    if (!this.shown) return false;
+    let count2 = this.items.length;
+    if (move === "left" || move === "previous") this.select(((this.chosen < 0 ? 0 : this.chosen) - 1 + count2) % count2);
+    else if (move === "right" || move === "next") this.select(((this.chosen < 0 ? -1 : this.chosen) + 1) % count2);
+    else return false;
+    return true;
+  }
+};
+function radialMenu(ui, options) {
+  return new RadialMenu(ui, options);
+}
+var DAMAGE_INDEX = { hit: 0, crit: 1, heal: 2, miss: 3 }, DamageNumbers = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.config = new Float64Array(2);
+    this.cursor = 0;
+    this.live = 0;
+    let capacity = options.capacity ?? 24;
+    this.config[(0)] = options.seconds ?? (0.9), this.config[(1)] = options.rise ?? (56), this.x = new Float32Array(capacity), this.y = new Float32Array(capacity), this.age = new Float32Array(capacity), this.kind = new Int8Array(capacity).fill(-1);
+    let display = fontStyle(ui, "display"), kinds = [null, s4.damageCrit, s4.damageHeal, s4.damageMiss], states = [];
+    for (let i = 0; i < (4); i++) states.push(ui.props(display, s4.damage, kinds[i], s4.damageShown));
+    this.states = states, this.hidden = ui.props(display, s4.damage), this.root = ui.box(sheet.layer);
+    let entries = [];
+    for (let i = 0; i < capacity; i++) {
+      let entry = ui.text("", this.hidden);
+      this.root.append(entry), entries.push(entry);
+    }
+    this.entries = entries;
+    let rooting = { anchor: "fill", safe_area: false, z: options.z ?? (700) };
+    ui.root(this.root, rooting), this.root.accessibility({ role: "none", hidden: true });
+  }
+  get active() {
+    return this.live;
+  }
+  spawn(value, x, y, kind = "hit") {
+    let i = this.cursor;
+    this.cursor = (i + 1) % this.entries.length, this.kind[i] < 0 && this.live++;
+    let k = DAMAGE_INDEX[kind];
+    this.kind[i] = k, this.x[i] = x - HALF_DAMAGE_WIDTH, this.y[i] = y, this.age[i] = 0;
+    let entry = this.entries[i];
+    entry.number(value, PLAIN), SLOTS[0] = x - HALF_DAMAGE_WIDTH, SLOTS[1] = y, SLOTS[2] = 1, SLOTS[3] = k === 1 ? (1.35) : 1, entry.style(this.ui.props(this.states[k], s4.float.setSlotsFrom(SLOTS)));
+  }
+  update(frame) {
+    if (this.live === 0) return;
+    let dt = frame[1], ui = this.ui, config = this.config;
+    for (let i = 0; i < this.entries.length; i++) {
+      let k = this.kind[i];
+      if (k < 0) continue;
+      let age = this.age[i] + dt;
+      if (age >= config[(0)]) {
+        this.kind[i] = -1, this.live--, this.entries[i].style(this.hidden);
+        continue;
+      }
+      this.age[i] = age;
+      let p = age / config[(0)], rest = 1 - p, pop = 1 - p * (4);
+      SLOTS[0] = this.x[i], SLOTS[1] = this.y[i] - config[(1)] * (1 - rest * rest), SLOTS[2] = 1 - p * p * p, SLOTS[3] = k === 1 && pop > 0 ? 1 + ((1.35) - 1) * pop : 1, this.entries[i].style(ui.props(this.states[k], s4.float.setSlotsFrom(SLOTS)));
+    }
+  }
+  clear() {
+    for (let i = 0; i < this.entries.length; i++)
+      this.kind[i] < 0 || (this.kind[i] = -1, this.entries[i].style(this.hidden));
+    this.live = 0;
+  }
+};
+function damageNumbers(ui, options = {}) {
+  return new DamageNumbers(ui, options);
+}
+var Badge = class {
+  constructor(ui, options) {
+    this.ui = ui;
+    this.current = -1;
+    this.clock = new Float64Array(1);
+    this.a11y = new A11y({ role: "text", label: "", hidden: true });
+    this.max = options.max ?? (99), this.dot = options.dot ?? false, this.overflow = `${this.max}+`;
+    let noun = options.label ?? "new";
+    this.labels = Array.from({ length: this.max + 2 }, (_, i) => i > this.max ? `${this.max}+ ${noun}` : `${i} ${noun}`);
+    let shape = this.dot ? s4.badgeDot : null;
+    this.states = [ui.props(s4.badge, shape, sheet.hidden), ui.props(s4.badge, shape), ui.props(s4.badge, shape, s4.badgeBump)], this.root = ui.box(this.states[0]), this.root.transition(["scale_x", "scale_y"], { duration: (0.16), easing: "back_out" }), this.text = label(ui, "", "mono", s4.badgeText, this.dot ? sheet.hidden : null), this.root.append(this.text), options.host.append(this.root), this.set(options.count ?? 0);
+  }
+  get count() {
+    return this.current;
+  }
+  set(count2) {
+    let next = Math.max(0, Math.floor(count2));
+    if (next === this.current) return;
+    let grew = next > this.current && this.current >= 0;
+    this.current = next, this.dot || (next > this.max ? this.text.text(this.overflow) : this.text.number(next, PLAIN)), this.a11y.options.label = this.labels[Math.min(next, this.max + 1)], this.a11y.options.hidden = next === 0, this.a11y.apply(this.root), next === 0 ? (this.clock[0] = 0, this.root.style(this.states[0])) : grew ? (this.clock[0] = (0.16), this.root.style(this.states[2])) : this.root.style(this.states[1]);
+  }
+  update(frame) {
+    let clock = this.clock;
+    clock[0] <= 0 || (clock[0] -= frame[1], clock[0] <= 0 && this.current > 0 && this.root.style(this.states[1]));
+  }
+};
+function badge(ui, options) {
+  return new Badge(ui, options);
+}
+
+// src/interactives/game-ui/widgets/overlay.ts
+var MODAL_Z = 800, MODAL_WIDTH = 340, ENTER_SCALE = 0.94, TOOLTIP_SECONDS = 2.5, TOOLTIP_Z = 60, ARROW = 10, TOOLTIP_MAX = 240, s5 = styles({
+  layer: { width: "100%", height: "100%", alignItems: "center", justify: "center", fill: kitVars.scrim, opacity: 0, hidden: true },
+  layerShown: { opacity: 1, hidden: false },
+  card: {
+    width: (340),
+    maxWidth: "92%",
+    padding: kitVars.padding,
+    gap: kitVars.gap,
+    fill: tokens.surface,
+    radius: kitVars.radius,
+    borderWidth: kitVars.borderWidth,
+    borderColor: tokens.border,
+    shadow: { color: kitVars.shadow, y: 12, blur: 32 },
+    scale: (0.94)
+  },
+  cardShown: { scale: 1 },
+  content: { gap: kitVars.gap, alignItems: "stretch" },
+  tipAnchor: { position: "absolute", left: 0, right: 0, alignItems: "center", pointerEvents: "none", zIndex: (60), opacity: 0, hidden: true },
+  above: { bottom: "100%", marginBottom: kitVars.gapSmall },
+  below: { top: "100%", marginTop: kitVars.gapSmall },
+  tipShown: { opacity: 1, hidden: false },
+  bubble: { maxWidth: (240), padding: [kitVars.gapSmall, kitVars.gap, kitVars.gapSmall, kitVars.gap], fill: tokens.raised, radius: kitVars.radiusSmall, borderWidth: kitVars.borderWidth, borderColor: tokens.border, shadow: { color: kitVars.shadow, y: 4, blur: 12 } },
+  arrow: { width: (10), height: (10), fill: tokens.raised, rotate: Math.PI / 4, marginTop: -(10) / 2, marginBottom: -(10) / 2 }
+}), Modal = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.onClose = null;
+    this.stack = null;
+    this.dismissible = options.dismissible ?? true, this.layers = [ui.props(s5.layer), ui.props(s5.layer, s5.layerShown)], this.cards = [ui.props(s5.card, options.style), ui.props(s5.card, options.style, s5.cardShown)], this.layer = ui.box(this.layers[0]), this.layer.transition(["opacity"], { duration: (0.18), easing: "ease_out" }), this.root = ui.box(this.cards[0]), this.root.transition(["scale_x", "scale_y"], { duration: (0.18), easing: "back_out" }), this.title = options.title === void 0 ? null : label(ui, options.title, "display", sheet.title, sheet.center), this.title !== null && this.root.append(this.title), this.content = ui.box(s5.content), this.root.append(this.content), this.layer.append(this.root), this.scope = new UiFocusScope(options.columns ?? 1, () => this.stack?.back() ?? false), this.a11y = new A11y({ role: "group", label: options.title ?? "", hidden: true, modal: false }), this.a11y.apply(this.root);
+  }
+  add(target) {
+    return this.scope.add(target), this;
+  }
+  append(element) {
+    return this.content.append(element), this;
+  }
+  get open() {
+    return this.stack !== null;
+  }
+  shown(on, top) {
+    this.layer.style(this.layers[on ? 1 : 0]), this.root.style(this.cards[on ? 1 : 0]), this.a11y.options.hidden = !on || !top, this.a11y.options.modal = on && top, this.a11y.options.disabled = on && !top, this.a11y.apply(this.root);
+  }
+};
+function modal(ui, options = {}) {
+  return new Modal(ui, options);
+}
+var ModalStack = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.modals = new StableList();
+    this.rooting = { anchor: "fill", safe_area: false, z: 0 };
+    this.navigator = options.navigator ?? null, this.inert = options.inert ?? [], this.z = options.z ?? (800);
+  }
+  get depth() {
+    return this.modals.size;
+  }
+  get top() {
+    return this.modals.size === 0 ? null : this.modals.at(this.modals.size - 1);
+  }
+  contains(modal2) {
+    return this.modals.indexOf(modal2) >= 0;
+  }
+  push(modal2) {
+    if (modal2.stack !== null) return;
+    let below = this.top;
+    if (below !== null) below.shown(true, false);
+    else for (let i = 0; i < this.inert.length; i++) this.inert[i].setState("disabled", true);
+    this.modals.push(modal2), modal2.stack = this, this.rooting.z = this.z + this.modals.size, this.ui.root(modal2.layer, this.rooting), modal2.shown(true, true), modal2.scope.current = -1, this.navigator?.push(modal2.scope);
+  }
+  pop() {
+    let top = this.top;
+    return top === null ? null : (this.remove(top), top);
+  }
+  remove(modal2) {
+    let at = this.modals.indexOf(modal2);
+    if (at < 0) return;
+    this.modals.removeAt(at), modal2.stack = null, modal2.shown(false, false), this.ui.unroot(modal2.layer);
+    let top = this.top;
+    if (top !== null) top.shown(true, true);
+    else for (let i = 0; i < this.inert.length; i++) this.inert[i].setState("disabled", false);
+    this.navigator?.pop(modal2.scope), modal2.onClose?.();
+  }
+  clear() {
+    for (; this.modals.size > 0; ) this.pop();
+  }
+  back() {
+    let top = this.top;
+    return top === null || !top.dismissible ? false : (this.remove(top), true);
+  }
+};
+function modalStack(ui, options = {}) {
+  return new ModalStack(ui, options);
+}
+var Tooltip = class {
+  constructor(ui, options) {
+    this.ui = ui;
+    this.options = options;
+    this.remaining = new Float64Array(2);
+    this.pinned = false;
+    this.visible = false;
+    let above = (options.placement ?? "above") === "above", side = above ? s5.above : s5.below;
+    this.states = [ui.props(s5.tipAnchor, side), ui.props(s5.tipAnchor, side, s5.tipShown)], this.remaining[1] = options.seconds ?? (2.5), this.root = ui.box(this.states[0]), this.root.transition(["opacity"], { duration: (0.18) }), this.bubble = ui.box(s5.bubble), this.text = label(ui, options.text, "body", sheet.small, sheet.wrap), this.bubble.append(this.text);
+    let arrow = ui.box(s5.arrow);
+    above ? this.root.append(this.bubble).append(arrow) : this.root.append(arrow).append(this.bubble), options.target.append(this.root), this.root.accessibility({ role: "text", label: options.text, hidden: true }), options.target.on("long_press", () => this.show()), options.navigator?.onChange((focused) => {
+      focused !== null && focusNodeOf(focused) === options.target ? this.pin() : this.visible && this.pinned && this.hide();
+    });
+  }
+  get shown() {
+    return this.visible;
+  }
+  setText(value) {
+    this.text.text(value);
+  }
+  show() {
+    this.reveal(false);
+  }
+  pin() {
+    this.reveal(true);
+  }
+  hide() {
+    this.pinned = false, this.remaining[0] = 0, this.visible && (this.visible = false, this.root.style(this.states[0]));
+  }
+  update(frame) {
+    if (!this.visible || this.pinned) return;
+    let remaining = this.remaining;
+    remaining[0] -= frame[1], remaining[0] <= 0 && this.hide();
+  }
+  reveal(pinned) {
+    this.pinned = pinned, this.remaining.copyWithin(0, 1, 2), !this.visible && (this.visible = true, this.root.style(this.states[1]));
+  }
+};
+function tooltip(ui, options) {
+  return new Tooltip(ui, options);
+}
+
+// src/interactives/game-ui/widgets/particles.ts
+var CAPACITY = 64, PARTICLE_Z = 950, CONFETTI_W = 7, CONFETTI_H = 11, SPARKLE = 10, GRAVITY = 900, DRAG = 1.6, CONFETTI_SPEED = 520, SPARKLE_SPEED = 180, CONFETTI_LIFE = 1.6, SPARKLE_LIFE = 0.8, SPIN = 12, TWINKLE = 18, PALETTE = 6, KINDS = 2, CONFETTI = 0, SPARKLE_KIND = 1, DEAD = -1, SPREAD = Math.PI * 0.7, UP = -Math.PI / 2, TAU2 = Math.PI * 2, FADE_FROM = 0.7, SEED = 20973, TABLE_ROWS = 97, F_VX = 0, F_VY = 1, F_ANGLE = 2, F_SPIN = 3, F_LIFE = 4, F_X = 5, F_Y = 6, F_AGE = 7, STRIDE = 8, s6 = styles({
+  confetti: { position: "absolute", left: 0, top: 0, width: (7), height: (11), marginLeft: -(7) / 2, marginTop: -(11) / 2, radius: 1, pointerEvents: "none", hidden: false },
+  sparkle: { position: "absolute", left: 0, top: 0, width: (10), height: (10), marginLeft: -(10) / 2, marginTop: -(10) / 2, radius: (10) / 2, pointerEvents: "none", hidden: false, shadow: { color: tokens.gold, blur: 6 } },
+  dead: { position: "absolute", hidden: true, pointerEvents: "none" },
+  c0: { fill: tokens.accent },
+  c1: { fill: tokens.gold },
+  c2: { fill: tokens.success },
+  c3: { fill: tokens.danger },
+  c4: { fill: kitVars.focus },
+  c5: { fill: tokens.text },
+  piece: { translate: [0, 0], rotate: 0, opacity: 1 },
+  glint: { translate: [0, 0], scale: 1, opacity: 1 }
+}, {
+  piece: slotWords({ translate: [slot(0), slot(1)], rotate: slot(2), opacity: slot(3) }),
+  glint: slotWords({ translate: [slot(0), slot(1)], scale: slot(2), opacity: slot(3) })
+});
+function fillLaunchTable(rng, data, colors) {
+  for (let kind = 0; kind < (2); kind++) {
+    let confetti = kind === (0);
+    for (let r = 0; r < (97); r++) {
+      let row = kind * (97) + r, o = row * (8), heading = confetti ? UP + rng.range(-SPREAD, SPREAD) : rng.range(0, TAU2), speed = (confetti ? (520) : (180)) * rng.range(0.45, 1);
+      data[o + (0)] = Math.cos(heading) * speed, data[o + (1)] = Math.sin(heading) * speed, data[o + (2)] = rng.range(0, TAU2), data[o + (3)] = rng.range(-(12), (12)), data[o + (4)] = (confetti ? (1.6) : (0.8)) * rng.range(0.7, 1), colors[row] = rng.next() * (6) | 0;
+    }
+  }
+}
+var UiParticles = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.launchColors = new Uint8Array((97) * (2));
+    this.cursor = 0;
+    this.row = 0;
+    this.live = 0;
+    let capacity = options.capacity ?? (64);
+    this.data = new Float32Array(((97) * (2) + capacity) * (8)), this.kind = new Int8Array(capacity).fill((-1)), this.color = new Uint8Array(capacity), fillLaunchTable(new Rng(options.seed ?? (20973)), this.data, this.launchColors);
+    let palette = [s6.c0, s6.c1, s6.c2, s6.c3, s6.c4, s6.c5], states = [];
+    for (let kind = 0; kind < (2); kind++) for (let c = 0; c < (6); c++) states.push(ui.props(kind === (0) ? s6.confetti : s6.sparkle, palette[kind === (0) ? c : 1 + (c & 1) * 4]));
+    this.states = states, this.dead = ui.props(s6.dead), this.root = ui.box(sheet.layer);
+    let pieces = [];
+    for (let i = 0; i < capacity; i++) {
+      let piece = ui.box(this.dead);
+      this.root.append(piece), pieces.push(piece);
+    }
+    this.pieces = pieces;
+    let rooting = { anchor: "fill", safe_area: false, z: options.z ?? (950) };
+    ui.root(this.root, rooting), this.root.accessibility({ role: "none", hidden: true });
+  }
+  get active() {
+    return this.live;
+  }
+  burst(kind, x, y, count2) {
+    let confetti = kind === "confetti", data = this.data, base = confetti ? 0 : (97);
+    for (let n = 0; n < count2; n++) {
+      let i = this.cursor;
+      this.cursor = (i + 1) % this.pieces.length, this.kind[i] === (-1) && this.live++, this.kind[i] = confetti ? (0) : (1);
+      let row = base + this.row;
+      this.row = (this.row + 1) % (97);
+      let o = ((97) * (2) + i) * (8);
+      data.copyWithin(o, row * (8), row * (8) + (8)), data[o + (5)] = x, data[o + (6)] = y, data[o + (7)] = 0, this.color[i] = this.launchColors[row], this.draw(i);
+    }
+  }
+  update(frame) {
+    if (this.live === 0) return;
+    let dt = frame[1], damping = (1.6) * dt < 1 ? 1 - (1.6) * dt : 0, data = this.data;
+    for (let i = 0; i < this.pieces.length; i++) {
+      let kind = this.kind[i];
+      if (kind === (-1)) continue;
+      let o = ((97) * (2) + i) * (8), age = data[o + (7)] + dt;
+      if (age >= data[o + (4)]) {
+        this.kind[i] = (-1), this.live--, this.pieces[i].style(this.dead);
+        continue;
+      }
+      data[o + (7)] = age, kind === (0) && (data[o + (1)] += (900) * dt), data[o + (0)] *= damping, data[o + (1)] *= damping, data[o + (5)] += data[o + (0)] * dt, data[o + (6)] += data[o + (1)] * dt, data[o + (2)] += data[o + (3)] * dt, this.draw(i);
+    }
+  }
+  clear() {
+    for (let i = 0; i < this.pieces.length; i++)
+      this.kind[i] !== (-1) && (this.kind[i] = (-1), this.pieces[i].style(this.dead));
+    this.live = 0;
+  }
+  draw(i) {
+    let kind = this.kind[i], data = this.data, o = ((97) * (2) + i) * (8), p = data[o + (7)] / data[o + (4)], state = this.states[kind * (6) + this.color[i]];
+    if (SLOTS[0] = data[o + (5)], SLOTS[1] = data[o + (6)], SLOTS[3] = p < (0.7) ? 1 : 1 - (p - (0.7)) / (1 - (0.7)), kind === (0))
+      SLOTS[2] = data[o + (2)], this.pieces[i].style(this.ui.props(state, s6.piece.setSlotsFrom(SLOTS)));
+    else {
+      let phase = data[o + (7)] * (18) + i, wave = phase - (phase | 0);
+      SLOTS[2] = (0.6 + 0.8 * (wave < 0.5 ? wave : 1 - wave)) * (1 - p * 0.5), this.pieces[i].style(this.ui.props(state, s6.glint.setSlotsFrom(SLOTS)));
+    }
+  }
+};
+function uiParticles(ui, options = {}) {
+  return new UiParticles(ui, options);
+}
+
+// src/interactives/game-ui/widgets/screens.ts
+var STAR = 30, STARS = 3, STAR_SECONDS = 0.35, SCORE_SECONDS = 1.1, REWARD_ICON = 28, REWARDS = 3, SPINNER = 44, SPINNER_SPEED = Math.PI * 2, LOADING_BAR = 260, BAR_HEIGHT = 8, TIP_SECONDS = 4, LOADING_Z = 1200, HINT_Z = 900, HINT_WIDTH = 260, HINT_DOTS = 8, DOT = 7, ARROW2 = 16, BOB = 6, BOB_SPEED = 1, SPARKLES = 10, TURN = Math.PI * 2, SPIN2 = 0, TIP = 1, TIP_SECONDS_AT = 2, HINT_X = 0, HINT_Y = 1, HINT_CLOCK = 2, CONFETTI2 = 36, s7 = styles({
+  actions: { direction: "row", gap: kitVars.gap, justify: "center" },
+  grow: { grow: 1, basis: 0 },
+  section: { fontSize: kitVars.small, fontWeight: 800, textColor: tokens.muted, letterSpacing: 1, pointerEvents: "none" },
+  score: { textAlign: "center", fontSize: kitVars.display, fontWeight: 800, textColor: tokens.gold, pointerEvents: "none" },
+  stars: { direction: "row", gap: kitVars.gap, justify: "center", padding: kitVars.gapSmall },
+  star: { width: (30), height: (30), radius: 4, rotate: Math.PI / 4, fill: tokens.track, scale: 0.8 },
+  starOn: { fill: tokens.gold, scale: 1, shadow: { color: tokens.gold, blur: 10 } },
+  rewards: { direction: "row", gap: kitVars.gap, justify: "center", wrap: true },
+  reward: { direction: "row", alignItems: "center", gap: kitVars.gapSmall, padding: [kitVars.gapSmall, kitVars.gap, kitVars.gapSmall, kitVars.gapSmall], radius: kitVars.radius, fill: tokens.raised, hidden: true },
+  rewardShown: { hidden: false },
+  rewardIcon: { width: (28), height: (28), pointerEvents: "none" },
+  loading: { width: "100%", height: "100%", alignItems: "center", justify: "center", gap: kitVars.padding, padding: kitVars.padding, fill: tokens.surface, hidden: true, opacity: 0 },
+  loadingShown: { hidden: false, opacity: 1 },
+  spinner: { width: (44), height: (44), radius: (44) / 2, borderWidth: 4, borderColor: [tokens.accent, tokens.track, tokens.track, tokens.track] },
+  spin: { rotate: 0 },
+  bar: { width: (260), height: (8), radius: (8) / 2, fill: tokens.track, clip: true },
+  barFill: { height: "100%", radius: (8) / 2, fill: tokens.accent },
+  barTo: { width: "0%" },
+  tip: { maxWidth: (260) + 80, textAlign: "center" },
+  hint: { width: "100%", height: "100%", hidden: true },
+  hintShown: { hidden: false },
+  bubble: { position: "absolute", width: (260), gap: kitVars.gap, padding: kitVars.padding, fill: tokens.raised, radius: kitVars.radius, borderWidth: kitVars.borderWidth, borderColor: tokens.accent, shadow: { color: kitVars.shadow, y: 6, blur: 18 } },
+  bubbleAt: { left: 0, top: 0 },
+  dots: { direction: "row", gap: 4, alignItems: "center" },
+  dot: { width: (7), height: (7), radius: (7) / 2, fill: tokens.track },
+  dotOn: { fill: tokens.accent },
+  dotHidden: { hidden: true },
+  footer: { direction: "row", justify: "space-between", alignItems: "center" },
+  arrow: { position: "absolute", width: (16), height: (16), rotate: Math.PI / 4, fill: tokens.accent, pointerEvents: "none" },
+  arrowAt: { left: 0, top: 0 }
+}, {
+  spin: slotWords({ rotate: slot(0) }),
+  barTo: slotWords({ width: slot(0, true) }),
+  bubbleAt: slotWords({ left: slot(0), top: slot(1) }),
+  arrowAt: slotWords({ left: slot(0), top: slot(1) })
+}), PauseScreen = class {
+  constructor(ui, options) {
+    this.options = options;
+    this.modal = new Modal(ui, { title: options.title ?? "Paused" }), this.resume = new TextButton(ui, { label: "Resume", variant: "primary", scope: this.modal.scope, onPress: () => this.close() }), this.settings = new TextButton(ui, { label: "Settings", scope: this.modal.scope, onPress: () => options.onSettings?.() }), this.quit = new TextButton(ui, { label: "Quit", variant: "ghost", scope: this.modal.scope, onPress: () => options.onQuit?.() }), this.modal.append(this.resume.root).append(this.settings.root).append(this.quit.root), this.modal.onClose = () => options.onResume?.();
+  }
+  get open() {
+    return this.modal.open;
+  }
+  show() {
+    this.options.stack.push(this.modal);
+  }
+  close() {
+    this.options.stack.remove(this.modal);
+  }
+};
+function pauseScreen(ui, options) {
+  return new PauseScreen(ui, options);
+}
+var DEFAULT_QUALITIES = ["Low", "Medium", "High"], DEFAULT_LANGUAGES = ["English", "Fran\xE7ais", "Espa\xF1ol", "Kiswahili", "Yor\xF9b\xE1", "Portugu\xEAs"], SettingsScreen = class {
+  constructor(ui, options) {
+    this.options = options;
+    this.values = { music: 0.8, effects: 1, haptics: true, quality: 1, language: 0, ...options.values };
+    let values = this.values, changed = (key) => options.onChange?.(values, key);
+    this.modal = new Modal(ui, { title: "Settings" });
+    let scope = this.modal.scope, nav = options.navigator;
+    this.music = new Slider(ui, { label: "Music", value: values.music, step: 0.05, scope, onChange: (v) => {
+      values.music = v, changed("music");
+    } }), this.effects = new Slider(ui, { label: "Effects", value: values.effects, step: 0.05, scope, onChange: (v) => {
+      values.effects = v, changed("effects");
+    } }), this.haptics = new Toggle(ui, { label: "Haptics", value: values.haptics, scope, onChange: (v) => {
+      values.haptics = v, changed("haptics");
+    } }), this.quality = new Dropdown(ui, { label: "Quality", options: options.qualities ?? DEFAULT_QUALITIES, selected: values.quality, width: 280, navigator: nav, scope, onChange: (i) => {
+      values.quality = i, changed("quality");
+    } }), this.language = new Dropdown(ui, { label: "Language", options: options.languages ?? DEFAULT_LANGUAGES, selected: values.language, width: 280, navigator: nav, scope, onChange: (i) => {
+      values.language = i, changed("language");
+    } }), this.done = new TextButton(ui, { label: "Done", variant: "primary", scope, onPress: () => this.close() }), this.modal.append(label(ui, "AUDIO", "body", s7.section)).append(this.music.root).append(this.effects.root), this.modal.append(label(ui, "GAME", "body", s7.section)).append(this.haptics.root).append(this.quality.root).append(this.language.root), this.modal.append(this.done.root), this.modal.onClose = () => {
+      this.quality.close(), this.language.close(), options.onDone?.(values);
+    };
+  }
+  get open() {
+    return this.modal.open;
+  }
+  show() {
+    this.options.stack.push(this.modal);
+  }
+  close() {
+    this.options.stack.remove(this.modal);
+  }
+};
+function settingsScreen(ui, options) {
+  return new SettingsScreen(ui, options);
+}
+var ResultsScreen = class {
+  constructor(ui, options) {
+    this.ui = ui;
+    this.options = options;
+    this.target = 0;
+    this.shownScore = -1;
+    this.earned = 0;
+    this.revealed = 0;
+    this.clock = new Float64Array(2);
+    this.natural = options.natural ?? [(28), (28)], this.modal = new Modal(ui, { columns: 2, dismissible: false }), this.title = label(ui, "", "display", sheet.display, sheet.center), this.score = label(ui, "", "mono", s7.score), this.starStates = [ui.props(s7.star), ui.props(s7.star, s7.starOn)], this.rewardStates = [ui.props(s7.reward), ui.props(s7.reward, s7.rewardShown)];
+    let stars = ui.box(s7.stars), starList = [];
+    for (let i = 0; i < (3); i++) {
+      let star = ui.box(this.starStates[0]);
+      star.transition(["scale_x", "scale_y", "fill"], { duration: (0.18), easing: "back_out" }), stars.append(star), starList.push(star);
+    }
+    this.stars = starList;
+    let rewards = ui.box(s7.rewards), rewardList = [], icons = [], amounts = [];
+    for (let i = 0; i < (options.rewards ?? (3)); i++) {
+      let chip = ui.box(this.rewardStates[0]), icon = ui.image(0, this.natural, s7.rewardIcon), amount = label(ui, "", "mono", sheet.text, sheet.strong);
+      chip.append(icon).append(amount), rewards.append(chip), rewardList.push(chip), icons.push(icon), amounts.push(amount);
+    }
+    this.rewards = rewardList, this.rewardIcons = icons, this.rewardAmounts = amounts;
+    let actions = ui.box(s7.actions);
+    this.retry = new TextButton(ui, { label: "Retry", variant: "primary", style: s7.grow, scope: this.modal.scope, onPress: () => options.onRetry?.() }), this.share = new TextButton(ui, { label: "Share", style: s7.grow, scope: this.modal.scope, onPress: () => options.onShare?.() }), actions.append(this.retry.root).append(this.share.root), this.modal.append(this.title).append(stars).append(this.score).append(rewards).append(actions), this.a11y = new A11y({ role: "text", label: "", live: true });
+  }
+  get open() {
+    return this.modal.open;
+  }
+  get starsShown() {
+    return this.revealed;
+  }
+  get scoreShown() {
+    return this.shownScore;
+  }
+  show(result) {
+    this.title.text(result.victory ? "Victory!" : "Defeat"), this.a11y.options.label = result.victory ? "Victory" : "Defeat", this.a11y.apply(this.title), this.target = result.score, this.earned = clamp(Math.round(result.stars), 0, (3)), this.revealed = 0, this.clock[0] = 0, this.shownScore = -1, this.score.number(0, INTEGER);
+    for (let i = 0; i < (3); i++) this.stars[i].style(this.starStates[0]);
+    this.modal.open || this.options.stack.push(this.modal), result.victory && this.options.particles?.burst("confetti", this.at(0), this.at(1), (36));
+  }
+  setReward(index, icon, amount) {
+    this.rewardIcons[index].image(icon, this.natural[0], this.natural[1]), this.rewardAmounts[index].number(amount, PLAIN), this.rewards[index].style(this.rewardStates[1]);
+  }
+  hideReward(index) {
+    this.rewards[index].style(this.rewardStates[0]);
+  }
+  close() {
+    this.options.stack.remove(this.modal);
+  }
+  update(frame) {
+    if (!this.modal.open) return;
+    let clock = this.clock;
+    clock[0] += frame[1], clock[1] = clock[0] < (1.1) ? 1 - clock[0] / (1.1) : 0;
+    let value = this.target * (1 - clock[1] * clock[1] * clock[1]) + 0.5 | 0;
+    value !== this.shownScore && (this.shownScore = value, this.score.number(value, INTEGER));
+    let stars = clock[0] / (0.35) | 0, due = stars < this.earned ? stars : this.earned;
+    for (; this.revealed < due; )
+      this.stars[this.revealed].style(this.starStates[1]), this.revealed++, this.options.particles?.burst("sparkle", this.at(0), this.at(1), (10));
+  }
+  at(axis) {
+    return this.options.celebrateAt?.[axis] ?? 0;
+  }
+};
+function resultsScreen(ui, options) {
+  return new ResultsScreen(ui, options);
+}
+var LoadingScreen = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.clock = new Float64Array(3);
+    this.tipIndex = 0;
+    this.shownPercent = -1;
+    this.visible = false;
+    this.tips = options.tips ?? [], this.clock[(2)] = options.tipSeconds ?? (4), this.states = [ui.props(s7.loading), ui.props(s7.loading, s7.loadingShown)], this.root = ui.box(this.states[0]), this.root.transition(["opacity"], { duration: (0.18) }), SLOTS[0] = 0, this.spinner = ui.box(ui.props(s7.spinner, s7.spin.setSlotsFrom(SLOTS)));
+    let bar = ui.box(s7.bar);
+    this.fill = ui.box(ui.props(s7.barFill, s7.barTo.setSlotsFrom(SLOTS))), bar.append(this.fill), this.percent = label(ui, "", "mono", sheet.small, sheet.strong), this.tip = label(ui, this.tips.length > 0 ? this.tips[0] : "", "body", sheet.text, sheet.muted, s7.tip), this.root.append(label(ui, options.title ?? "Loading", "display", sheet.title)), this.root.append(this.spinner).append(bar).append(this.percent).append(this.tip);
+    let rooting = { anchor: "fill", safe_area: false, z: options.z ?? (1200) };
+    ui.root(this.root, rooting), this.a11y = new A11y({ role: "progress", label: options.title ?? "Loading", value: "0%", hidden: true }), this.a11y.apply(this.root), this.setProgress(0);
+  }
+  get shown() {
+    return this.visible;
+  }
+  show() {
+    this.visible || (this.visible = true, this.root.style(this.states[1]), this.a11y.options.hidden = false, this.a11y.apply(this.root));
+  }
+  hide() {
+    this.visible && (this.visible = false, this.root.style(this.states[0]), this.a11y.options.hidden = true, this.a11y.apply(this.root));
+  }
+  setProgress(ratio) {
+    this.setPercent(Math.round(clamp(ratio, 0, 1) * (100)));
+  }
+  setPercent(value) {
+    let percent = value < 0 ? 0 : value > (100) ? (100) : value | 0;
+    percent !== this.shownPercent && (this.shownPercent = percent, SLOTS[0] = percent, this.fill.style(this.ui.props(s7.barFill, s7.barTo.setSlotsFrom(SLOTS))), this.percent.text(PERCENT_TEXT[percent]), this.a11y.options.value = PERCENT_TEXT[percent], this.a11y.apply(this.root));
+  }
+  update(frame) {
+    if (!this.visible) return;
+    let dt = frame[1], clock = this.clock;
+    clock[(0)] += SPINNER_SPEED * dt, clock[(0)] >= TURN && (clock[(0)] -= TURN), SLOTS[0] = clock[(0)], this.spinner.style(this.ui.props(s7.spinner, s7.spin.setSlotsFrom(SLOTS))), !(this.tips.length < 2) && (clock[(1)] += dt, !(clock[(1)] < clock[(2)]) && (clock[(1)] = 0, this.tipIndex = (this.tipIndex + 1) % this.tips.length, this.tip.text(this.tips[this.tipIndex])));
+  }
+};
+function loadingScreen(ui, options = {}) {
+  return new LoadingScreen(ui, options);
+}
+var TutorialHint = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.steps = [];
+    this.step = 0;
+    this.at = new Float64Array(3);
+    this.visible = false;
+    this.navigator = options.navigator ?? null, this.onDone = options.onDone ?? null, this.states = [ui.props(s7.hint), ui.props(s7.hint, s7.hintShown)], this.dotStates = [ui.props(s7.dot), ui.props(s7.dot, s7.dotOn), ui.props(s7.dot, s7.dotHidden)], this.root = ui.box(this.states[0]), SLOTS[0] = 0, SLOTS[1] = 0, this.bubble = ui.box(ui.props(s7.bubble, s7.bubbleAt.setSlotsFrom(SLOTS))), this.text = label(ui, "", "body", sheet.text, sheet.wrap);
+    let footer = ui.box(s7.footer), dots = ui.box(s7.dots), dotList = [];
+    for (let i = 0; i < (8); i++) {
+      let dot = ui.box(this.dotStates[2]);
+      dots.append(dot), dotList.push(dot);
+    }
+    this.dots = dotList, this.scope = new UiFocusScope(1, () => (this.hide(), true)), this.next = new TextButton(ui, { label: "Next", variant: "primary", scope: this.scope, onPress: () => this.advance() }), this.skip = new TextButton(ui, { label: "Skip", variant: "ghost", scope: this.scope, onPress: () => this.finish() });
+    let buttons = ui.box(s7.actions);
+    buttons.append(this.skip.root).append(this.next.root), footer.append(dots).append(buttons), this.bubble.append(this.text).append(footer), this.arrow = ui.box(ui.props(s7.arrow, s7.arrowAt.setSlotsFrom(SLOTS))), this.root.append(this.arrow).append(this.bubble);
+    let rooting = { anchor: "fill", safe_area: true, z: options.z ?? (900) };
+    ui.root(this.root, rooting), this.a11y = new A11y({ role: "alert", label: "", live: true, hidden: true }), this.a11y.apply(this.bubble);
+  }
+  get shown() {
+    return this.visible;
+  }
+  get index() {
+    return this.step;
+  }
+  show(steps, x, y) {
+    this.steps = steps, this.at[(0)] = x, this.at[(1)] = y, this.visible = true, this.root.style(this.states[1]), SLOTS[0] = x, SLOTS[1] = y + (16), this.bubble.style(this.ui.props(s7.bubble, s7.bubbleAt.setSlotsFrom(SLOTS))), this.go(0), this.scope.current = -1, this.navigator?.push(this.scope);
+  }
+  advance() {
+    this.step + 1 >= this.steps.length ? this.finish() : this.go(this.step + 1);
+  }
+  hide() {
+    this.visible && (this.visible = false, this.root.style(this.states[0]), this.a11y.options.hidden = true, this.a11y.apply(this.bubble), this.navigator?.pop(this.scope));
+  }
+  update(frame) {
+    if (!this.visible) return;
+    let at = this.at;
+    at[(2)] += frame[1], SLOTS[0] = at[(0)] + (16);
+    let phase = at[(2)] * (1), wave = phase - (phase | 0);
+    SLOTS[1] = at[(1)] + (wave < 0.5 ? wave * 4 - 1 : 3 - wave * 4) * (6), this.arrow.style(this.ui.props(s7.arrow, s7.arrowAt.setSlotsFrom(SLOTS)));
+  }
+  finish() {
+    this.hide(), this.onDone?.();
+  }
+  go(step) {
+    this.step = step, this.text.text(this.steps[step]);
+    let last = step + 1 >= this.steps.length;
+    this.next.setLabel(last ? "Got it" : "Next");
+    for (let i = 0; i < (8); i++) this.dots[i].style(this.dotStates[i >= this.steps.length || this.steps.length < 2 ? 2 : i === step ? 1 : 0]);
+    this.a11y.options.label = this.steps[step], this.a11y.options.hidden = false, this.a11y.apply(this.bubble);
+  }
+};
+function tutorialHint(ui, options = {}) {
+  return new TutorialHint(ui, options);
+}
+
+// src/interactives/game-ui/widgets/text.ts
+var CHAT_WIDTH = 300, CHAT_LINES = 6, SENDER_COLORS = 6, FADED_LINES = 2, RICH_SPANS = 24, ICON_SIZE = 18, PARSE_CACHE = 64, s8 = styles({
+  chat: { gap: 2, padding: [kitVars.gapSmall, kitVars.gap, kitVars.gapSmall, kitVars.gap], fill: tokens.surface, radius: kitVars.radius, pointerEvents: "none" },
+  line: { direction: "row", wrap: true, gap: kitVars.gapSmall, alignItems: "start", hidden: false, opacity: 1 },
+  lineFaded: { opacity: 0.55 },
+  lineHidden: { hidden: true },
+  name: { fontSize: kitVars.small, fontWeight: 800, pointerEvents: "none" },
+  body: { fontSize: kitVars.small, textColor: tokens.text, textWrap: true, shrink: 1, grow: 1, basis: 0, pointerEvents: "none" },
+  system: { textColor: tokens.muted },
+  sender0: { textColor: tokens.accent },
+  sender1: { textColor: tokens.success },
+  sender2: { textColor: tokens.gold },
+  sender3: { textColor: tokens.danger },
+  sender4: { textColor: kitVars.silver },
+  sender5: { textColor: kitVars.bronze },
+  rich: { direction: "row", wrap: true, alignItems: "center" },
+  span: { fontSize: kitVars.body, textColor: tokens.text, pointerEvents: "none" },
+  spanBold: { fontWeight: 800 },
+  spanIcon: { width: (18), height: (18), marginInline: 2, pointerEvents: "none" },
+  cText: { textColor: tokens.text },
+  cMuted: { textColor: tokens.muted },
+  cAccent: { textColor: tokens.accent },
+  cGold: { textColor: tokens.gold },
+  cDanger: { textColor: tokens.danger },
+  cSuccess: { textColor: tokens.success }
+}), ChatPanel = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.head = 0;
+    this.size = 0;
+    let lines = options.lines ?? (6);
+    this.senders = new Array(lines).fill(""), this.messages = new Array(lines).fill(""), this.colors = new Int8Array(lines);
+    let body = fontStyle(ui, "body"), colors = [s8.sender0, s8.sender1, s8.sender2, s8.sender3, s8.sender4, s8.sender5];
+    this.lineStates = [ui.props(s8.line), ui.props(s8.line, s8.lineFaded), ui.props(s8.line, s8.lineHidden)];
+    let nameStates = [];
+    for (let i = 0; i < (6); i++) nameStates.push(ui.props(body, s8.name, colors[i]));
+    nameStates.push(ui.props(body, s8.name, sheet.hidden)), this.nameStates = nameStates, this.bodyStates = [ui.props(body, s8.body), ui.props(body, s8.body, s8.system)], this.root = ui.box(ui.props(s8.chat, { width: options.width ?? (300) }, options.style));
+    let rows = [], names = [], bodies = [];
+    for (let i = 0; i < lines; i++) {
+      let row = ui.box(this.lineStates[2]), name = ui.text("", this.nameStates[0]), text = ui.text("", this.bodyStates[0]);
+      row.append(name).append(text), this.root.append(row), rows.push(row), names.push(name), bodies.push(text);
+    }
+    this.rows = rows, this.names = names, this.bodies = bodies, this.root.accessibility({ role: "group", label: options.label ?? "Chat", live: true });
+  }
+  get count() {
+    return this.size;
+  }
+  push(sender, message, color = 0) {
+    let capacity = this.rows.length;
+    this.senders[this.head] = sender, this.messages[this.head] = message, this.colors[this.head] = color, this.head = (this.head + 1) % capacity, this.size < capacity && this.size++, this.render();
+  }
+  system(message) {
+    this.push("", message, -1);
+  }
+  clear() {
+    this.size = 0, this.render();
+  }
+  render() {
+    let capacity = this.rows.length, empty = capacity - this.size;
+    for (let line = 0; line < capacity; line++) {
+      let row = this.rows[line];
+      if (line < empty) {
+        row.style(this.lineStates[2]);
+        continue;
+      }
+      let at = (this.head - (capacity - line) + capacity * 2) % capacity, color = this.colors[at];
+      row.style(this.lineStates[line - empty < (2) && this.size > (2) ? 1 : 0]), this.names[line].style(this.nameStates[color < 0 ? (6) : color % (6)]), color >= 0 && this.names[line].text(this.senders[at]), this.bodies[line].style(this.bodyStates[color < 0 ? 1 : 0]), this.bodies[line].text(this.messages[at]);
+    }
+  }
+};
+function chatPanel(ui, options = {}) {
+  return new ChatPanel(ui, options);
+}
+var RICH_COLORS = ["text", "muted", "accent", "gold", "danger", "success"], SPAN_TEXT = 0, SPAN_ICON = 1, BOLD_BIT = 8, RichTextError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "RichTextError";
+  }
+};
+function parseRich(markup, icons, limit) {
+  let texts = [], kinds = [], styles2 = [], assets = [], bold = false, colors = [0], word = "", flush = () => {
+    if (word.length === 0) return;
+    let last = texts.length - 1;
+    if (word.trim().length === 0 && last >= 0 && kinds[last] === (0)) {
+      texts[last] += word, word = "";
+      return;
+    }
+    texts.push(word), kinds.push((0)), styles2.push(colors[colors.length - 1] | (bold ? (8) : 0)), assets.push(-1), word = "";
+  };
+  for (let i = 0; i < markup.length; i++) {
+    let c = markup[i];
+    if (c === "*" && markup[i + 1] === "*") {
+      flush(), bold = !bold, i++;
+      continue;
+    }
+    if (c === "[") {
+      let end = markup.indexOf("]", i);
+      if (end < 0) throw new RichTextError(`rich text: unclosed "[" at ${i}`);
+      let name = markup.slice(i + 1, end);
+      if (flush(), name === "/")
+        colors.length > 1 && colors.pop();
+      else {
+        let color = RICH_COLORS.indexOf(name);
+        if (color < 0) throw new RichTextError(`rich text: unknown colour "${name}"; use one of ${RICH_COLORS.join(", ")}`);
+        colors.push(color);
+      }
+      i = end;
+      continue;
+    }
+    if (c === "{") {
+      let end = markup.indexOf("}", i);
+      if (end < 0) throw new RichTextError(`rich text: unclosed "{" at ${i}`);
+      let name = markup.slice(i + 1, end), asset = icons[name];
+      if (asset === void 0) throw new RichTextError(`rich text: unknown icon "${name}"`);
+      flush(), texts.push(""), kinds.push((1)), styles2.push(0), assets.push(asset), i = end;
+      continue;
+    }
+    word += c, c === " " && word.trim().length > 0 && flush();
+  }
+  if (flush(), texts.length > limit) throw new RichTextError(`rich text: ${texts.length} spans exceed the widget's ${limit}; raise spans`);
+  return { texts, kinds: Uint8Array.from(kinds), styles: Uint8Array.from(styles2), icons: Int32Array.from(assets), count: texts.length, plain: texts.join("").replace(/\s+/g, " ").trim() };
+}
+var RichText = class {
+  constructor(ui, options = {}) {
+    this.ui = ui;
+    this.source = null;
+    this.cache = /* @__PURE__ */ new Map();
+    this.shown = null;
+    this.current = "";
+    this.a11y = new A11y({ role: "text", label: "" });
+    let spans = options.spans ?? (24);
+    this.icons = options.icons ?? {}, this.natural = options.natural ?? [(18), (18)];
+    let body = fontStyle(ui, "body"), colorStyles = [s8.cText, s8.cMuted, s8.cAccent, s8.cGold, s8.cDanger, s8.cSuccess], textStates = [];
+    for (let bold = 0; bold < 2; bold++) for (let c = 0; c < (8); c++) textStates.push(ui.props(body, s8.span, colorStyles[c % colorStyles.length], bold === 1 && s8.spanBold));
+    this.textStates = textStates, this.hiddenText = ui.props(body, s8.span, sheet.hidden), this.iconStates = [ui.props(s8.spanIcon), ui.props(s8.spanIcon, sheet.hidden)], this.root = ui.box(ui.props(s8.rich, options.style));
+    let texts = [], images = [];
+    for (let i = 0; i < spans; i++) {
+      let text = ui.text("", this.hiddenText), image = ui.image(0, this.natural, this.iconStates[1]);
+      this.root.append(text).append(image), texts.push(text), images.push(image);
+    }
+    this.texts = texts, this.images = images, this.mark = new AiMark(ui, options.mark), this.root.append(this.mark.root), options.flowAround !== void 0 && this.root.flowAround(options.flowAround), options.markup !== void 0 && this.set(options.markup, options.source ?? null);
+  }
+  flowAround(exclusions) {
+    return this.root.flowAround(exclusions), this;
+  }
+  get marked() {
+    return this.mark.shown;
+  }
+  get markup() {
+    return this.current;
+  }
+  get spans() {
+    return this.shown?.count ?? 0;
+  }
+  show(result) {
+    this.set(result.value, result.source);
+  }
+  set(markup, source = null) {
+    if (markup === this.current && this.shown !== null && isAiGenerated(source) === isAiGenerated(this.source)) return;
+    this.source = source;
+    let parsed = this.cache.get(markup);
+    parsed === void 0 && (parsed = parseRich(markup, this.icons, this.texts.length), this.cache.size >= (64) && this.cache.clear(), this.cache.set(markup, parsed));
+    let previous = this.shown?.count ?? 0;
+    this.current = markup, this.shown = parsed;
+    for (let i = 0; i < parsed.count; i++) {
+      if (parsed.kinds[i] === (1)) {
+        this.texts[i].style(this.hiddenText), this.images[i].image(parsed.icons[i], this.natural[0], this.natural[1]), this.images[i].style(this.iconStates[0]);
+        continue;
+      }
+      this.images[i].style(this.iconStates[1]), this.texts[i].text(parsed.texts[i]), this.texts[i].style(this.textStates[parsed.styles[i]]);
+    }
+    for (let i = parsed.count; i < previous; i++)
+      this.texts[i].style(this.hiddenText), this.images[i].style(this.iconStates[1]);
+    this.a11y.options.label = aiLabel(parsed.plain, this.mark.show(source)), this.a11y.apply(this.root);
+  }
+};
+function richText(ui, options = {}) {
+  return new RichText(ui, options);
+}
+
+// src/interactives/worlds/index.ts
+var worlds_exports = {};
+__export(worlds_exports, {
+  ACTION_BASE: () => ACTION_BASE,
+  Action: () => Action,
+  BOUNDS_MAX: () => BOUNDS_MAX,
+  BOUNDS_MIN: () => BOUNDS_MIN,
+  BOUNDS_WORDS: () => BOUNDS_WORDS,
+  CENTIDEGREES_PER_TURN: () => CENTIDEGREES_PER_TURN,
+  COMMAND_BYTES: () => COMMAND_BYTES,
+  COMMAND_OP_ID_BYTES: () => COMMAND_OP_ID_BYTES,
+  CommandWriter: () => CommandWriter,
+  DEFAULT_ANGLE_STEP_CENTIDEGREES: () => DEFAULT_ANGLE_STEP_CENTIDEGREES,
+  DEFAULT_GRID_MM: () => DEFAULT_GRID_MM,
+  Ground: () => Ground,
+  Lighting: () => Lighting,
+  Likeness: () => Likeness,
+  LocalWorld: () => LocalWorld,
+  MAX_SELECT_IDS: () => MAX_SELECT_IDS,
+  MILLIMETRES_PER_METRE: () => MILLIMETRES_PER_METRE,
+  MessageKind: () => MessageKind,
+  NOT_SENT: () => NOT_SENT,
+  NO_BUILDER: () => NO_BUILDER,
+  Notice: () => Notice,
+  OBJECT_RECORD_BYTES: () => OBJECT_RECORD_BYTES,
+  POSITION: () => POSITION,
+  QUATERNION_SCALE: () => QUATERNION_SCALE,
+  ROTATION: () => ROTATION,
+  SCALE: () => SCALE,
+  SCALE_UNIT_PERMILLE: () => SCALE_UNIT_PERMILLE,
+  SNAP_GRID: () => SNAP_GRID,
+  SNAP_SURFACE: () => SNAP_SURFACE,
+  Sanction: () => Sanction,
+  SelectMode: () => SelectMode,
+  Sky: () => Sky,
+  Status: () => Status,
+  TRANSFORM_BYTES: () => TRANSFORM_BYTES,
+  TRANSFORM_WORDS: () => TRANSFORM_WORDS,
+  Visibility: () => Visibility,
+  WORLD_CHANNEL_SLOT: () => WORLD_CHANNEL_SLOT,
+  WORLD_DEPTH_MM: () => WORLD_DEPTH_MM,
+  WORLD_EXTENT_MM: () => WORLD_EXTENT_MM,
+  WorldBuilder: () => WorldBuilder,
+  WorldMirror: () => WorldMirror,
+  WorldRoleCode: () => WorldRoleCode,
+  bounds: () => bounds,
+  canonical: () => canonical,
+  connectWorld: () => connectWorld,
+  copyTransform: () => copyTransform,
+  encodeBare: () => encodeBare,
+  encodeClock: () => encodeClock,
+  encodeDuplicate: () => encodeDuplicate,
+  encodeJoinCopy: () => encodeJoinCopy,
+  encodeModerate: () => encodeModerate,
+  encodePlace: () => encodePlace,
+  encodeSelect: () => encodeSelect,
+  encodeSetTransform: () => encodeSetTransform,
+  encodeSettings: () => encodeSettings,
+  encodeTransformSelection: () => encodeTransformSelection,
+  identityTransform: () => identityTransform,
+  movedAbout: () => movedAbout,
+  overlapsFootprint: () => overlapsFootprint,
+  snapHeightToGrid: () => snapHeightToGrid,
+  snappedToGrid: () => snappedToGrid,
+  withinWorld: () => withinWorld,
+  yawRotation: () => yawRotation
+});
+
+// src/interactives/generate/index.ts
+var generate_exports = {};
+__export(generate_exports, {
+  CONTENT_CHANNEL_SLOT: () => CONTENT_CHANNEL_SLOT,
+  DEFAULT_RETRIES: () => DEFAULT_RETRIES,
+  DEFAULT_TIMEOUT_MS: () => DEFAULT_TIMEOUT_MS,
+  MAX_TIMEOUT_MS: () => MAX_TIMEOUT_MS,
+  MIN_TIMEOUT_MS: () => MIN_TIMEOUT_MS,
+  REPLICATION_GRACE_MS: () => (2e3),
+  RoomGenerateError: () => RoomGenerateError,
+  acceptContent: () => acceptContent,
+  applyRules: () => applyRules,
+  contentRequest: () => contentRequest,
+  createGenerate: () => createGenerate,
+  createRoomGenerate: () => createRoomGenerate,
+  createTickContentLink: () => createTickContentLink,
+  dialogueSchema: () => dialogueSchema,
+  recipeToScene: () => recipeToScene,
+  requestTickContent: () => requestTickContent,
+  roomRecipeSchema: () => roomRecipeSchema,
+  rule: () => rule,
+  runContent: () => runContent,
+  select: () => select,
+  solveRoom: () => solveRoom,
+  t: () => t,
+  tickContentAsk: () => tickContentAsk,
+  validateValue: () => validateValue
+});
+
+// src/interactives/generate/room.ts
+var REPLICATION_VERSION = 1, REPLICATION_GRACE_MS = 2e3, MAX_REMEMBERED = 256, RoomGenerateError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "RoomGenerateError";
+  }
+}, encoder = new TextEncoder(), decoder = new TextDecoder();
+function decode(bytes) {
+  try {
+    let message = JSON.parse(decoder.decode(bytes));
+    return message.v === (1) && typeof message.key == "string" ? message : null;
+  } catch {
+    return null;
+  }
+}
+function fallbackValue(request) {
+  return typeof request.fallback == "function" ? request.fallback() : request.fallback;
+}
+function fromMessage(request, message) {
+  return message.source === "fallback" || message.value === void 0 ? {
+    value: fallbackValue(request),
+    source: "fallback",
+    reason: message.reason ?? "unavailable",
+    seed: message.seed,
+    runId: null,
+    digest: null
+  } : {
+    value: message.value,
+    source: message.source === "generated" || message.source === "cached" ? "replicated" : message.source,
+    reason: null,
+    seed: message.seed,
+    runId: message.runId,
+    digest: message.digest
+  };
+}
+function createRoomGenerate(ai, link) {
+  if (link.authority && ai === null)
+    throw new RoomGenerateError("the room authority needs ctx.ai to generate");
+  let seen = /* @__PURE__ */ new Map(), waiting = /* @__PURE__ */ new Map(), remember = (message) => {
+    if (seen.set(message.key, message), seen.size > (256)) {
+      let oldest = seen.keys().next().value;
+      oldest !== void 0 && seen.delete(oldest);
+    }
+    let waiters = waiting.get(message.key);
+    if (waiters !== void 0) {
+      waiting.delete(message.key);
+      for (let waiter of waiters) waiter(message);
+    }
+  }, unsubscribe = link.subscribe((bytes) => {
+    let message = decode(bytes);
+    message !== null && remember(message);
+  }), follow = (key, request) => {
+    let known = seen.get(key);
+    if (known !== void 0) return Promise.resolve(fromMessage(request, known));
+    let patience = (request.timeoutMs ?? 0) + (2e3);
+    return new Promise((resolve) => {
+      let timer = setTimeout(() => {
+        let list3 = waiting.get(key);
+        if (list3 !== void 0) {
+          let index = list3.indexOf(waiter);
+          index >= 0 && list3.splice(index, 1);
+        }
+        resolve({
+          value: fallbackValue(request),
+          source: "fallback",
+          reason: "offline",
+          seed: request.seed ?? 0,
+          runId: null,
+          digest: null
+        });
+      }, patience), waiter = (message) => {
+        clearTimeout(timer), resolve(fromMessage(request, message));
+      }, list2 = waiting.get(key) ?? [];
+      list2.push(waiter), waiting.set(key, list2);
+    });
+  }, lead = async (kind, key, request) => {
+    let known = seen.get(key);
+    if (known !== void 0) return fromMessage(request, known);
+    let result = await runContent(
+      ai,
+      kind,
+      request,
+      { room_id: link.roomId, key },
+      key
+    ), message = {
+      v: (1),
+      key,
+      source: result.source,
+      reason: result.reason,
+      seed: result.seed,
+      runId: result.runId,
+      digest: result.digest,
+      ...result.source === "fallback" ? {} : { value: result.value }
+    };
+    return seen.set(key, message), link.publish(encoder.encode(JSON.stringify(message))), result;
+  }, generate = (kind, key, request) => link.authority ? lead(kind, key, request) : follow(key, request);
+  return {
+    generate,
+    dialogue: (key, request) => generate("dialogue", key, request),
+    text: (key, request) => generate("text", key, request),
+    item: (key, request) => generate("item", key, request),
+    quest: (key, request) => generate("quest", key, request),
+    room: (key, request) => generate("room", key, request),
+    dispose: () => {
+      unsubscribe(), waiting.clear(), seen.clear();
+    }
+  };
+}
+
+// src/interactives/generate/scene.ts
+var MAX_ROOM_SIZE_M = 200, MIN_ROOM_SIZE_M = 2, MAX_ROOM_GROUPS = 16, MAX_GROUP_COUNT = 64, MAX_WITHIN_M = 50;
+function roomRecipeSchema(kinds, grounds = ["grass"]) {
+  let name = t.string({ min: 1, max: 32, note: "a short snake_case name for the group" });
+  return t.object({
+    name: t.string({ min: 1, max: 60 }),
+    size: t.array(t.number({ min: (2), max: (200) }), {
+      min: 2,
+      max: 2,
+      note: "width and depth in metres"
+    }),
+    ground: t.enum(grounds),
+    style: t.optional(t.string({ max: 40 })),
+    points: t.optional(
+      t.array(
+        t.object({
+          name,
+          at: t.array(t.number({ min: 0, max: (200) }), { min: 2, max: 2 })
+        }),
+        { max: 8 }
+      )
+    ),
+    objects: t.array(
+      t.object({
+        name,
+        kind: t.enum(kinds),
+        count: t.integer({ min: 1, max: (64) }),
+        near: t.optional(t.string({ max: 32 })),
+        within: t.optional(t.number({ min: 0, max: (50) })),
+        facing: t.optional(t.string({ max: 32 })),
+        along: t.optional(t.string({ max: 40 })),
+        on: t.optional(t.string({ max: 32 })),
+        clear: t.optional(t.number({ min: 0, max: 10 })),
+        reachable_from: t.optional(t.string({ max: 32 }))
+      }),
+      { min: 1, max: (16) }
+    )
+  });
+}
+function recipeToScene(recipe, seed) {
+  let points = {};
+  for (let point of recipe.points ?? [])
+    points[point.name] = [point.at[0] ?? 0, point.at[1] ?? 0];
+  let objects = {};
+  for (let group of recipe.objects) {
+    let spec = { kind: group.kind, count: group.count };
+    for (let field of [
+      "near",
+      "within",
+      "facing",
+      "along",
+      "on",
+      "clear",
+      "reachable_from"
+    ])
+      group[field] !== void 0 && (spec[field] = group[field]);
+    objects[group.name] = spec;
+  }
+  return {
+    area: {
+      size: [recipe.size[0] ?? (2), recipe.size[1] ?? (2)],
+      ground: recipe.ground,
+      points
+    },
+    objects,
+    ...recipe.style === void 0 ? {} : { style: recipe.style },
+    seed
+  };
+}
+function solveRoom(recipe, seed, compile, solver) {
+  let compiled = compile(recipe.name, recipeToScene(recipe, seed));
+  return compiled.wire === null ? { status: "rejected", diagnostics: compiled.diagnostics } : { status: "solved", result: solver.solve(compiled.wire, seed), seed };
+}
+
+// src/interactives/generate/tick.ts
+var CONTENT_CHANNEL_SLOT = FRAME_LIMITS.game_channel_slots - 4, CONTENT_FRAGMENT_HEADER_BYTES = 8, MAX_PENDING_RECORDS = 32;
+function utf8(text) {
+  let out = [];
+  for (let char of text) {
+    let code = char.codePointAt(0) ?? 0;
+    code < 128 ? out.push(code) : code < 2048 ? out.push(192 | code >> 6, 128 | code & 63) : code < 65536 ? out.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63) : out.push(
+      240 | code >> 18,
+      128 | code >> 12 & 63,
+      128 | code >> 6 & 63,
+      128 | code & 63
+    );
+  }
+  return Uint8Array.from(out);
+}
+function tickContentAsk(key, kind, request) {
+  let timeout = Math.min(
+    Math.max(Math.round(request.timeoutMs ?? DEFAULT_TIMEOUT_MS), MIN_TIMEOUT_MS),
+    MAX_TIMEOUT_MS
+  );
+  return utf8(
+    JSON.stringify({
+      key,
+      kind,
+      prompt: request.prompt,
+      schema: kind === "dialogue" && request.schema === void 0 ? null : request.schema?.json ?? null,
+      rules: request.rules ?? [],
+      slots: request.slots ?? [],
+      context: request.context ?? null,
+      language: request.language ?? null,
+      variant: request.variant ?? 0,
+      seed: request.seed ?? null,
+      retries: request.retries ?? DEFAULT_RETRIES,
+      timeout_ms: timeout
+    })
+  );
+}
+function requestTickContent(ctx, key, kind, request) {
+  return ctx.outbox(1, tickContentAsk(key, kind, request));
+}
+function createTickContentLink(roomId, subscribe) {
+  let listeners = /* @__PURE__ */ new Set(), pending = /* @__PURE__ */ new Map(), unsubscribe = subscribe((payload) => {
+    if (payload.length < (8)) return;
+    let view2 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength), record = view2.getUint32(0, true), index = view2.getUint16(4, true), count2 = view2.getUint16(6, true);
+    if (count2 === 0 || index >= count2) return;
+    let parts = pending.get(record);
+    if ((parts === void 0 || parts.length !== count2) && (parts = new Array(count2).fill(null), pending.set(record, parts), pending.size > (32))) {
+      let oldest = pending.keys().next().value;
+      oldest !== void 0 && oldest !== record && pending.delete(oldest);
+    }
+    if (parts[index] = payload.slice((8)), parts.some((part) => part === null)) return;
+    pending.delete(record);
+    let total = parts.reduce((sum, part) => sum + (part?.length ?? 0), 0), joined = new Uint8Array(total), offset = 0;
+    for (let part of parts)
+      part !== null && (joined.set(part, offset), offset += part.length);
+    for (let listener of listeners) listener(joined);
+  });
+  return {
+    roomId,
+    authority: false,
+    publish: () => {
+    },
+    subscribe: (listener) => (listeners.add(listener), () => {
+      listeners.delete(listener), listeners.size === 0 && unsubscribe();
+    })
+  };
+}
+
+// src/interactives/parts/index.ts
+var parts_exports = {};
+__export(parts_exports, {
+  CDC_MAX_BYTES: () => CDC_MAX_BYTES,
+  CDC_MIN_BYTES: () => CDC_MIN_BYTES,
+  DELTA_LIMIT: () => (0.5),
+  DeltaOp: () => DeltaOp,
+  MANIFEST_HEADER_BYTES: () => MANIFEST_HEADER_BYTES,
+  MANIFEST_MAGIC: () => MANIFEST_MAGIC,
+  MANIFEST_PART_BYTES: () => MANIFEST_PART_BYTES,
+  MANIFEST_VERSION: () => MANIFEST_VERSION,
+  MAX_ASSET_BYTES: () => MAX_ASSET_BYTES,
+  MAX_MANIFEST_PARTS: () => MAX_MANIFEST_PARTS,
+  MIN_PART_BYTES: () => (2048),
+  PART_HEADER_BYTES: () => PART_HEADER_BYTES,
+  PART_MAGIC: () => PART_MAGIC,
+  PART_VERSION: () => PART_VERSION,
+  PartFormatError: () => PartFormatError,
+  PartIndex: () => PartIndex,
+  PartKind: () => PartKind,
+  SEGMENT_BYTES: () => SEGMENT_BYTES,
+  SegmentOp: () => SegmentOp,
+  WEAVE_BOUNDARY_MASK: () => WEAVE_BOUNDARY_MASK,
+  WEAVE_CHILD_ENTRY_BYTES: () => WEAVE_CHILD_ENTRY_BYTES,
+  WEAVE_HEAD_DOMAIN: () => WEAVE_HEAD_DOMAIN,
+  WEAVE_LEAF_DECORATED: () => WEAVE_LEAF_DECORATED,
+  WEAVE_LEAF_ENTRY_BYTES: () => WEAVE_LEAF_ENTRY_BYTES,
+  WEAVE_LEAF_TWINNED: () => WEAVE_LEAF_TWINNED,
+  WEAVE_MAX_HEIGHT: () => WEAVE_MAX_HEIGHT,
+  WEAVE_MAX_NODE_BYTES: () => WEAVE_MAX_NODE_BYTES,
+  WEAVE_MAX_NODE_ENTRIES: () => WEAVE_MAX_NODE_ENTRIES,
+  WEAVE_MIN_NODE_ENTRIES: () => WEAVE_MIN_NODE_ENTRIES,
+  WEAVE_NODE_HEADER_BYTES: () => WEAVE_NODE_HEADER_BYTES,
+  WEAVE_NODE_MAGIC: () => WEAVE_NODE_MAGIC,
+  WEAVE_NODE_ZONE: () => WEAVE_NODE_ZONE,
+  WEAVE_VERSION: () => WEAVE_VERSION,
+  WeaveRefusal: () => WeaveRefusal,
+  WeaveVerifyError: () => WeaveVerifyError,
+  applyDelta: () => applyDelta,
+  assemble: () => assemble,
+  assembleInto: () => assembleInto,
+  buildAsset: () => buildAsset,
+  buildWeave: () => buildWeave,
+  childDigestAt: () => childDigestAt,
+  chunkWeaveSource: () => chunkWeaveSource,
+  coalesce: () => coalesce,
+  combinedBases: () => combinedBases,
+  contentSpans: () => contentSpans,
+  decodeManifest: () => decodeManifest,
+  decodePart: () => decodePart,
+  deliverSchedule: () => deliverSchedule,
+  encodeDelta: () => encodeDelta,
+  encodeManifest: () => encodeManifest,
+  encodePart: () => encodePart,
+  isManifest: () => isManifest,
+  leafAt: () => leafAt,
+  leafDigest: () => leafDigest,
+  leafDigestAt: () => leafDigestAt,
+  leafFlags: () => leafFlags,
+  leafLength: () => leafLength,
+  leafZone: () => leafZone,
+  manifestBytes: () => manifestBytes,
+  nodeMatches: () => nodeMatches,
+  openWeaveHead: () => openWeaveHead,
+  openWeaveSession: () => openWeaveSession,
+  partKindName: () => partKindName,
+  planWeave: () => planWeave,
+  progressiveSpans: () => progressiveSpans,
+  sealPart: () => sealPart,
+  segmentOutput: () => segmentOutput,
+  soleSpan: () => soleSpan,
+  splitAsset: () => splitAsset,
+  storeWeaveSource: () => storeWeaveSource,
+  structuralSpans: () => structuralSpans,
+  unweaveIndex: () => unweaveIndex,
+  validWeaveRoot: () => validWeaveRoot,
+  verifyChild: () => verifyChild,
+  verifyRoot: () => verifyRoot,
+  walkWeave: () => walkWeave,
+  weaveHeadMessage: () => weaveHeadMessage,
+  weaveNodeCount: () => weaveNodeCount,
+  weaveNodeLevel: () => weaveNodeLevel,
+  weaveNodeValid: () => weaveNodeValid,
+  weaveParts: () => weaveParts,
+  woven: () => woven
+});
+
+// src/interactives/parts/split.ts
+var MIN_PART_BYTES = 2048, CDC_MIN_BYTES = 8 * 1024, CDC_MAX_BYTES = 128 * 1024, CDC_MASK = 32767, GEAR_SEED = 2654435769, GLB_MAGIC = 1179937895, GLB_VERSION = 2, GLB_HEADER_BYTES = 12, GLB_CHUNK_HEADER_BYTES = 8, GLB_JSON = 1313821514, GLB_BIN = 5130562, KTX2_IDENTIFIER = [171, 75, 84, 88, 32, 50, 48, 187, 13, 10, 26, 10], KTX2_LEVEL_COUNT = 40, KTX2_LEVEL_INDEX = 80, KTX2_LEVEL_BYTES = 24, CELLS_MAGIC = 1263556419, CELLS_HEADER_BYTES = 16, CELLS_ENTRY_BYTES = 16, WORLD_MAGIC = 1145853763;
+function view(bytes) {
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function gearTable() {
+  let table = new Uint32Array(256), x = (2654435769);
+  for (let i = 0; i < 256; i++)
+    x ^= x << 13, x ^= x >>> 17, x ^= x << 5, table[i] = x >>> 0;
+  return table;
+}
+var GEAR = gearTable();
+function contentSpans(bytes, start, end, kind) {
+  let out = [], at = start;
+  for (; at < end; ) {
+    let limit = Math.min(end, at + CDC_MAX_BYTES), cut = limit;
+    if (limit - at > CDC_MIN_BYTES) {
+      let h = 0;
+      for (let i = at + CDC_MIN_BYTES; i < limit; i++)
+        if (h = (h << 1) + GEAR[bytes[i]] >>> 0, (h & (32767)) === 0) {
+          cut = i + 1;
+          break;
+        }
+    }
+    out.push({ start: at, end: cut, kind }), at = cut;
+  }
+  return out;
+}
+function covering(length, ranges) {
+  ranges.sort((a, b) => a.start - b.start || b.end - a.end);
+  let out = [], cursor = 0;
+  for (let r of ranges)
+    r.start < cursor || r.end > length || r.end <= r.start || (r.start > cursor && out.push({ start: cursor, end: r.start, kind: null }), out.push(r), cursor = r.end);
+  return cursor < length && out.push({ start: cursor, end: length, kind: null }), out;
+}
+function list(value) {
+  return Array.isArray(value) ? value : [];
+}
+function num(value) {
+  return typeof value == "number" && Number.isInteger(value) && value >= 0 ? value : null;
+}
+function glbViewKinds(gltf) {
+  let kinds = /* @__PURE__ */ new Map(), accessors = list(gltf.accessors), mark = (accessor, kind) => {
+    let a = num(accessor), view2 = a === null ? null : num(accessors[a]?.bufferView);
+    view2 !== null && !kinds.has(view2) && kinds.set(view2, kind);
+  };
+  for (let mesh of list(gltf.meshes))
+    for (let primitive of list(mesh.primitives)) {
+      mark(primitive.indices, PartKind.mesh_index);
+      let attributes = primitive.attributes ?? {};
+      for (let key of Object.keys(attributes).sort()) mark(attributes[key], PartKind.mesh_vertex);
+      for (let target of list(primitive.targets)) for (let key of Object.keys(target).sort()) mark(target[key], PartKind.mesh_vertex);
+    }
+  for (let skin of list(gltf.skins)) mark(skin.inverseBindMatrices, PartKind.skeleton);
+  for (let animation of list(gltf.animations))
+    for (let sampler of list(animation.samplers))
+      mark(sampler.input, PartKind.clip), mark(sampler.output, PartKind.clip);
+  for (let image of list(gltf.images)) {
+    let view2 = num(image.bufferView);
+    view2 !== null && !kinds.has(view2) && kinds.set(view2, PartKind.image);
+  }
+  return kinds;
+}
+function splitGlb(bytes) {
+  if (bytes.length < (12) + (8)) return null;
+  let v = view(bytes);
+  if (v.getUint32(0, true) !== (1179937895) || v.getUint32(4, true) !== (2) || v.getUint32(8, true) !== bytes.length) return null;
+  let jsonLength = v.getUint32((12), true);
+  if (v.getUint32((12) + 4, true) !== (1313821514)) return null;
+  let jsonStart = (12) + (8), jsonEnd = jsonStart + jsonLength;
+  if (jsonEnd > bytes.length) return null;
+  let gltf;
+  try {
+    gltf = JSON.parse(new TextDecoder().decode(bytes.subarray(jsonStart, jsonEnd)));
+  } catch {
+    return null;
+  }
+  let ranges = [{ start: jsonStart, end: jsonEnd, kind: PartKind.scene }], binHeader = jsonEnd;
+  if (binHeader + (8) <= bytes.length && v.getUint32(binHeader + 4, true) === (5130562)) {
+    let binStart = binHeader + (8), binEnd = Math.min(bytes.length, binStart + v.getUint32(binHeader, true)), kinds = glbViewKinds(gltf), views = list(gltf.bufferViews);
+    for (let i = 0; i < views.length; i++) {
+      let bufferView = views[i], kind = kinds.get(i) ?? PartKind.data, source = bufferView.extensions?.EXT_meshopt_compression ?? bufferView;
+      if ((num(source.buffer) ?? 0) !== 0) continue;
+      let offset = num(source.byteOffset) ?? 0, length = num(source.byteLength);
+      if (length === null) continue;
+      let start = binStart + offset, end = start + length;
+      end <= binEnd && ranges.push({ start, end, kind });
+    }
+  }
+  return covering(bytes.length, ranges);
+}
+function isKtx2(bytes) {
+  if (bytes.length < (80)) return false;
+  for (let i = 0; i < KTX2_IDENTIFIER.length; i++) if (bytes[i] !== KTX2_IDENTIFIER[i]) return false;
+  return true;
+}
+function splitKtx2(bytes) {
+  if (!isKtx2(bytes)) return null;
+  let v = view(bytes), levels = Math.max(1, v.getUint32((40), true));
+  if ((80) + levels * (24) > bytes.length) return null;
+  let ranges = [];
+  for (let l = 0; l < levels; l++) {
+    let at = (80) + l * (24), offset = Number(v.getBigUint64(at, true)), length = Number(v.getBigUint64(at + 8, true));
+    offset + length <= bytes.length && ranges.push({ start: offset, end: offset + length, kind: PartKind.texture });
+  }
+  return covering(bytes.length, ranges);
+}
+function splitCells(bytes) {
+  if (bytes.length < (16)) return null;
+  let v = view(bytes);
+  if (v.getUint32(0, true) !== (1263556419)) return null;
+  let count2 = v.getUint32(8, true);
+  if ((16) + count2 * (16) > bytes.length) return null;
+  let ranges = [];
+  for (let e = 0; e < count2; e++) {
+    let at = (16) + e * (16), offset = v.getUint32(at + 4, true), length = v.getUint32(at + 8, true);
+    ranges.push({ start: offset, end: offset + length, kind: PartKind.cell });
+  }
+  return covering(bytes.length, ranges);
+}
+function expandLarge(bytes, spans) {
+  let out = [];
+  for (let s9 of spans)
+    if (s9.kind !== null && s9.end - s9.start > CDC_MAX_BYTES) for (let c of contentSpans(bytes, s9.start, s9.end, s9.kind)) out.push(c);
+    else out.push(s9);
+  return out;
+}
+function joinSmall(spans, minPart) {
+  let out = [];
+  for (let i = 0; i < spans.length; i++) {
+    let s9 = spans[i];
+    if (s9.kind === null) {
+      out.push(s9);
+      continue;
+    }
+    let end = s9.end, j = i + 1;
+    for (; end - s9.start < minPart; ) {
+      let k = j;
+      for (; k < spans.length && spans[k].kind === null && spans[k].end - spans[k].start <= (16) && spans[k].end - end <= (16); ) k++;
+      let next = spans[k];
+      if (next === void 0 || next.kind !== s9.kind || next.start - end > (16) || next.end - s9.start > CDC_MAX_BYTES) break;
+      end = next.end, j = k + 1;
+    }
+    out.push({ start: s9.start, end, kind: s9.kind }), i = j - 1;
+  }
+  return out;
+}
+var MAX_JOIN_GAP = 16;
+function coalesce(input, minPart = (2048)) {
+  let spans = joinSmall(input, minPart), out = [];
+  for (let s9 of spans) {
+    let kind = s9.kind !== null && s9.end - s9.start >= minPart ? s9.kind : null, last = out[out.length - 1];
+    kind === null && last !== void 0 && last.kind === null && last.end === s9.start ? out[out.length - 1] = { start: last.start, end: s9.end, kind: null } : out.push({ start: s9.start, end: s9.end, kind });
+  }
+  return out;
+}
+function structuralSpans(bytes) {
+  let structured = splitGlb(bytes) ?? splitKtx2(bytes) ?? splitCells(bytes);
+  return structured !== null ? expandLarge(bytes, structured) : bytes.length >= 4 && view(bytes).getUint32(0, true) === (1145853763) ? contentSpans(bytes, 0, bytes.length, PartKind.data) : null;
+}
+var PROGRESSIVE_PART_KIND = {
+  [ProgressiveKind.opaque]: PartKind.data,
+  [ProgressiveKind.texture]: PartKind.texture,
+  [ProgressiveKind.mesh]: PartKind.mesh_vertex,
+  [ProgressiveKind.splat]: PartKind.data,
+  [ProgressiveKind.audio]: PartKind.audio,
+  [ProgressiveKind.cells]: PartKind.cell
+};
+function progressiveSpans(bytes) {
+  let bounds2 = containerBounds(bytes);
+  if (bounds2 === null) return null;
+  let kind = PROGRESSIVE_PART_KIND[bounds2.kind] ?? PartKind.data, refine = [], at = bounds2.first;
+  for (let end of bounds2.unitEnds)
+    end <= at || (refine.push({ start: at, end, kind }), at = end);
+  return { base: [{ start: 0, end: bounds2.first, kind }], refine };
+}
+function splitAsset(bytes, minPart = (2048)) {
+  let progressive = progressiveSpans(bytes);
+  if (progressive !== null) {
+    let merged2 = [...coalesce(expandLarge(bytes, progressive.base), minPart), ...coalesce(expandLarge(bytes, progressive.refine), minPart)];
+    return merged2.some((s9) => s9.kind !== null) ? merged2 : null;
+  }
+  let spans = structuralSpans(bytes);
+  if (spans === null) return null;
+  let merged = coalesce(spans, minPart);
+  return merged.some((s9) => s9.kind !== null) ? merged : null;
+}
+
+// src/interactives/parts/build.ts
+var DELTA_LIMIT = 0.5, ANCHOR_WINDOW = 64, ANCHOR_MASK = 511, MIN_SHARED_ANCHORS = 0.25, SAME_LENGTH_CANDIDATES = 4, HASH_BASE = 16777619;
+function anchors(body) {
+  let out = /* @__PURE__ */ new Set(), h = 0;
+  for (let i = 0; i < body.length; i++) {
+    if (h = Math.imul(h, 31) + body[i] | 0, (h & (511)) !== 0 || i + (64) > body.length) continue;
+    let w = 0;
+    for (let j = i; j < i + (64); j++) w = Math.imul(w, (16777619)) + body[j] | 0;
+    out.add(w);
+  }
+  return out;
+}
+function combinedBases(...sources) {
+  return {
+    has: (digest) => sources.some((s9) => s9.has(digest)),
+    candidates: (kind, body) => {
+      let out = [];
+      for (let s9 of sources) for (let c of s9.candidates(kind, body)) out.some((o) => o.digest === c.digest) || out.push(c);
+      return out;
+    }
+  };
+}
+var PartIndex = class {
+  constructor() {
+    this.parts = [];
+    this.digests = /* @__PURE__ */ new Set();
+    this.byAnchor = /* @__PURE__ */ new Map();
+    this.byLength = /* @__PURE__ */ new Map();
+  }
+  get size() {
+    return this.parts.length;
+  }
+  has(digest) {
+    return this.digests.has(digest);
+  }
+  add(part) {
+    if (this.digests.has(part.digest)) return;
+    this.digests.add(part.digest);
+    let at = this.parts.length;
+    this.parts.push(part);
+    for (let a of anchors(part.body)) {
+      let list2 = this.byAnchor.get(a);
+      list2 === void 0 ? this.byAnchor.set(a, [at]) : list2.push(at);
+    }
+    let key = `${part.kind}:${part.body.length}`, same = this.byLength.get(key);
+    same === void 0 ? this.byLength.set(key, [at]) : same.push(at);
+  }
+  candidates(kind, body) {
+    let out = [], mine = anchors(body);
+    if (mine.size > 0) {
+      let counts = /* @__PURE__ */ new Map();
+      for (let a of mine) for (let at of this.byAnchor.get(a) ?? []) counts.set(at, (counts.get(at) ?? 0) + 1);
+      let best = -1, bestCount = 0;
+      for (let [at, count2] of counts)
+        this.parts[at].kind === kind && (count2 > bestCount || count2 === bestCount && at < best) && (best = at, bestCount = count2);
+      best >= 0 && bestCount >= mine.size * (0.25) && out.push(best);
+    }
+    for (let at of (this.byLength.get(`${kind}:${body.length}`) ?? []).slice(0, (4))) out.indexOf(at) < 0 && out.push(at);
+    return out.map((at) => this.parts[at]);
+  }
+}, Literal = class {
+  constructor() {
+    this.chunks = [];
+    this.length = 0;
+  }
+  push(bytes) {
+    let at = this.length;
+    return this.chunks.push(bytes), this.length += bytes.length, at;
+  }
+  bytes() {
+    let out = new Uint8Array(this.length), at = 0;
+    for (let c of this.chunks)
+      out.set(c, at), at += c.length;
+    return out;
+  }
+};
+function sealPart(kind, body, seal) {
+  let payload = encodePart(kind, body);
+  return { digest: seal(payload), kind, body: payload.subarray(payload.length - body.length), payload };
+}
+function buildAsset(bytes, assetKind, seal, options = {}) {
+  let spans = splitAsset(bytes, options.minPart ?? (2048));
+  if (spans === null) return null;
+  let literal = new Literal(), refs = [], sealed = [], slot2 = /* @__PURE__ */ new Map(), segments = [], deltas = [], partSlot = (part) => {
+    let known = slot2.get(part.digest);
+    if (known !== void 0) return known;
+    let at = refs.length;
+    return slot2.set(part.digest, at), refs.push({ digest: part.digest, kind: part.kind, length: part.body.length }), sealed.push(part), at;
+  };
+  for (let span of spans) {
+    let body = bytes.subarray(span.start, span.end);
+    if (span.kind === null) {
+      segments.push({ op: SegmentOp.literal, offset: literal.push(body), length: body.length });
+      continue;
+    }
+    let part = sealPart(span.kind, body, seal), bases = options.bases ?? null, derived = false;
+    if (bases !== null && !bases.has(part.digest))
+      for (let base of bases.candidates(span.kind, body)) {
+        let delta = encodeDelta(base.body, body, Math.floor(body.length * (0.5)));
+        if (delta !== null) {
+          segments.push({ op: SegmentOp.delta, part: partSlot(base), offset: literal.push(delta), length: delta.length, output: body.length }), deltas.push({ base: base.digest, variantBytes: body.length, deltaBytes: delta.length }), derived = true;
+          break;
+        }
+      }
+    derived || segments.push({ op: SegmentOp.part, part: partSlot(part), offset: 0, length: body.length });
+  }
+  let manifest = { kind: assetKind, length: bytes.length, parts: refs, segments, literal: literal.bytes() };
+  return { manifest: encodeManifest(manifest), parts: sealed, deltas, literalBytes: manifest.literal.length };
+}
+
+// src/interactives/progressive/index.ts
+var progressive_exports = {};
+__export(progressive_exports, {
+  DEFAULT_PROGRESSIVE_KINDS: () => DEFAULT_PROGRESSIVE_KINDS,
+  FILL_BYTE_MAX: () => FILL_BYTE_MAX,
+  HEADER_BYTES: () => HEADER_BYTES,
+  Header: () => Header,
+  LEVEL_BYTES: () => LEVEL_BYTES,
+  MAX_PROGRESSIVE_BYTES: () => MAX_PROGRESSIVE_BYTES,
+  MAX_PROGRESSIVE_DECODE_BYTES: () => MAX_PROGRESSIVE_DECODE_BYTES,
+  MERGE_PARAM_BYTES: () => MERGE_PARAM_BYTES,
+  MIN_PROGRESSIVE_BYTES: () => MIN_PROGRESSIVE_BYTES,
+  PATCH_BYTES: () => PATCH_BYTES,
+  PPM: () => PPM,
+  PROGRESSIVE_MAGIC: () => PROGRESSIVE_MAGIC,
+  PROGRESSIVE_VERSION: () => PROGRESSIVE_VERSION,
+  PatchOp: () => PatchOp,
+  ProgressiveCancelled: () => ProgressiveCancelled,
+  ProgressiveDecoder: () => ProgressiveDecoder,
+  ProgressiveFeed: () => ProgressiveFeed,
+  ProgressiveFormatError: () => ProgressiveFormatError,
+  ProgressiveKind: () => ProgressiveKind,
+  ProgressiveLayout: () => ProgressiveLayout,
+  SAMPLE_BYTES: () => SAMPLE_BYTES,
+  SEGMENT_BYTES: () => SEGMENT_BYTES2,
+  SEGMENT_STAGED: () => SEGMENT_STAGED,
+  TableWriter: () => TableWriter,
+  UNIT_BYTES: () => UNIT_BYTES,
+  UNLIFT_PARAM_BYTES: () => UNLIFT_PARAM_BYTES,
+  buildProgressive: () => buildProgressive,
+  checkLayout: () => checkLayout,
+  coarseKeys: () => coarseKeys,
+  containerBounds: () => containerBounds,
+  decodeProgressive: () => decodeProgressive,
+  encodeContainer: () => encodeContainer,
+  headBytes: () => headBytes,
+  isCoarseKey: () => isCoarseKey,
+  isProgressive: () => isProgressive,
+  liftForward: () => liftForward,
+  planAudio: () => planAudio,
+  planCells: () => planCells,
+  planMesh: () => planMesh,
+  planSplat: () => planSplat,
+  planTexture: () => planTexture,
+  progressiveKindName: () => progressiveKindName,
+  readKtx2: () => readKtx2,
+  readLayout: () => readLayout,
+  writePatch: () => writePatch
+});
+
+// src/interactives/progressive/audio.ts
+var RIFF = 1179011410, WAVE = 1163280727, FMT = 544501094, DATA = 1635017060, RIFF_HEADER_BYTES = 12, CHUNK_HEADER_BYTES = 8, PCM = 1, BITS = 16, FMT_CHANNELS = 2, FMT_RATE = 4, FMT_BYTE_RATE = 8, FMT_BITS = 14, FMT_MIN_BYTES = 16, RIFF_SIZE = 4, MIN_BASE_RATE = 8e3, MAX_BANDS = 3;
+function u32(value) {
+  let out = new Uint8Array(4);
+  return new DataView(out.buffer).setUint32(0, value, true), out;
+}
+function isWave(bytes) {
+  if (bytes.length < (12)) return false;
+  let v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return v.getUint32(0, true) === (1179011410) && v.getUint32(8, true) === (1163280727);
+}
+function planAudio(bytes) {
+  if (!isWave(bytes)) return null;
+  let v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), at = (12), fmt = -1, dataStart = -1, dataBytes = 0;
+  for (; at + (8) <= bytes.length; ) {
+    let id = v.getUint32(at, true), size = v.getUint32(at + 4, true), body = at + (8);
+    if (id === (544501094) && size >= (16) && (fmt = body), id === (1635017060)) {
+      dataStart = body, dataBytes = size;
+      break;
+    }
+    at = body + size + (size & 1);
+  }
+  if (fmt < 0 || dataStart < 0 || dataStart + dataBytes !== bytes.length || v.getUint16(fmt, true) !== (1) || v.getUint16(fmt + (14), true) !== (16)) return null;
+  let channels = v.getUint16(fmt + (2), true), rate = v.getUint32(fmt + (4), true), block = channels * SAMPLE_BYTES;
+  if (channels === 0 || dataBytes % block !== 0) return null;
+  let frames = dataBytes / block, bands = 0;
+  for (; bands < (3) && rate % 2 ** (bands + 1) === 0 && rate / 2 ** (bands + 1) >= (8e3) && frames >> bands + 1 > 0; ) bands++;
+  if (bands === 0) return null;
+  let samples = new Int16Array(frames * channels);
+  for (let i = 0; i < samples.length; i++) samples[i] = v.getInt16(dataStart + i * SAMPLE_BYTES, true);
+  let lows = [samples], details = [new Int16Array(0)], counts = [frames];
+  for (let k = 1; k <= bands; k++) {
+    let lifted = liftForward(lows[k - 1], counts[k - 1], channels);
+    lows.push(lifted.low), details.push(lifted.detail), counts.push(Math.ceil(counts[k - 1] / 2));
+  }
+  let table = new TableWriter(), state = (k) => {
+    let r = rate / 2 ** k, size = counts[k] * block;
+    return [
+      { op: PatchOp.write, a: (4), b: table.bytes(u32(dataStart + size - (8))), c: 4 },
+      { op: PatchOp.write, a: fmt + (4), b: table.bytes(u32(r)), c: 4 },
+      { op: PatchOp.write, a: fmt + (8), b: table.bytes(u32(r * block)), c: 4 },
+      { op: PatchOp.write, a: dataStart - 4, b: table.bytes(u32(size)), c: 4 }
+    ];
+  }, pcm = (s9) => {
+    let out = new Uint8Array(s9.length * SAMPLE_BYTES), ov = new DataView(out.buffer);
+    for (let i = 0; i < s9.length; i++) ov.setInt16(i * SAMPLE_BYTES, s9[i], true);
+    return out;
+  }, levels = [
+    [
+      {
+        segments: [
+          { dest: 0, bytes: bytes.subarray(0, dataStart) },
+          { dest: dataStart, bytes: pcm(lows[bands]) }
+        ],
+        patches: state(bands),
+        quality: Math.floor(PPM / 2 ** bands)
+      }
+    ]
+  ];
+  for (let k = bands; k >= 1; k--) {
+    let params = table.words(counts[k], counts[k - 1], channels);
+    levels.push([
+      {
+        segments: [{ dest: 0, bytes: pcm(details[k]), staged: true }],
+        patches: [{ op: PatchOp.unlift, a: dataStart, b: 0, c: params }, ...state(k - 1)],
+        quality: k === 1 ? PPM : Math.floor(PPM / 2 ** (k - 1))
+      }
+    ]);
+  }
+  return { kind: ProgressiveKind.audio, output: bytes.length, levels, table: table.finish() };
+}
+
+// src/interactives/progressive/cells.ts
+var PACK_MAGIC = 1263556419, PACK_VERSION = 3, PACK_HEADER_BYTES = 16, PACK_ENTRY_BYTES = 16, PACK_COUNT = 8, ENTRY_OFFSET = 4, ENTRY_LENGTH = 8, ENTRY_LEVEL = 12, LEVEL_PROXY = 2;
+function isCellPack(bytes) {
+  return bytes.length >= (16) && new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, true) === (1263556419);
+}
+function count(value) {
+  let out = new Uint8Array(4);
+  return new DataView(out.buffer).setUint32(0, value, true), out;
+}
+function planCells(bytes) {
+  if (!isCellPack(bytes)) return null;
+  let v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (v.getUint32(4, true) !== (3)) return null;
+  let cells = v.getUint32((8), true), tableEnd = (16) + cells * (16);
+  if (cells < 2 || tableEnd > bytes.length) return null;
+  let offsets = [], level = (e) => v.getUint32((16) + e * (16) + (12), true), tiers = level(0) === (2);
+  for (let e = 0; e < cells; e++) {
+    let at = (16) + e * (16), offset = v.getUint32(at + (4), true), length = v.getUint32(at + (8), true);
+    if ((tiers ? level(e) !== (2) : level(e) >= (2)) || offset < tableEnd || offset + length > bytes.length || e > 0 && offset <= offsets[e - 1] || e > 0 && offsets[e - 1] + v.getUint32(at - (16) + (8), true) > offset) return null;
+    offsets.push(offset);
+  }
+  let end = (e) => e + 1 < cells ? offsets[e + 1] : bytes.length, bodies = bytes.length - offsets[0], table = new TableWriter(), quality = (e) => e === cells - 1 ? PPM : Math.floor((end(e) - offsets[0]) * PPM / bodies), levels = [[{ segments: [{ dest: 0, bytes: bytes.subarray(0, end(0)) }], patches: [writePatch(table, (8), count(1))], quality: quality(0) }]];
+  for (let e = 1; e < cells; e++) {
+    let unit = { segments: [{ dest: offsets[e], bytes: bytes.subarray(offsets[e], end(e)) }], patches: [writePatch(table, (8), count(e + 1))], quality: quality(e) };
+    (e & e - 1) === 0 && levels.push([]), levels[levels.length - 1].push(unit);
+  }
+  return { kind: ProgressiveKind.cells, output: bytes.length, levels, table: table.finish() };
+}
+
+// src/interactives/progressive/simplify.ts
+function stampKey(from, to) {
+  return from * 1048576 + to % 1048576;
+}
+var LOD_RATIO = 4, MIN_LOD_TRIANGLES = 64, MIN_PROGRESSIVE_TRIANGLES = 256, Heap = class {
+  constructor() {
+    this.cost = [];
+    this.from = [];
+    this.to = [];
+    this.stamp = [];
+  }
+  get size() {
+    return this.cost.length;
+  }
+  push(cost, from, to, stamp) {
+    let i = this.cost.length;
+    for (this.cost.push(cost), this.from.push(from), this.to.push(to), this.stamp.push(stamp); i > 0; ) {
+      let parent = i - 1 >> 1;
+      if (!this.less(i, parent)) break;
+      this.swap(i, parent), i = parent;
+    }
+  }
+  less(a, b) {
+    let d = this.cost[a] - this.cost[b];
+    return d !== 0 ? d < 0 : this.from[a] - this.from[b] < 0 || this.from[a] === this.from[b] && this.to[a] < this.to[b];
+  }
+  swap(a, b) {
+    let c = this.cost[a];
+    this.cost[a] = this.cost[b], this.cost[b] = c;
+    let f = this.from[a];
+    this.from[a] = this.from[b], this.from[b] = f;
+    let t2 = this.to[a];
+    this.to[a] = this.to[b], this.to[b] = t2;
+    let s9 = this.stamp[a];
+    this.stamp[a] = this.stamp[b], this.stamp[b] = s9;
+  }
+  pop(out) {
+    if (this.cost.length === 0) return false;
+    out[0] = this.from[0], out[1] = this.to[0], out[2] = this.stamp[0];
+    let last = this.cost.length - 1;
+    this.swap(0, last), this.cost.pop(), this.from.pop(), this.to.pop(), this.stamp.pop();
+    let i = 0, n = this.cost.length;
+    for (; ; ) {
+      let l = 2 * i + 1, r = l + 1, m = i;
+      if (l < n && this.less(l, m) && (m = l), r < n && this.less(r, m) && (m = r), m === i) break;
+      this.swap(i, m), i = m;
+    }
+    return true;
+  }
+};
+function addPlane(q, at, nx, ny, nz, d, w) {
+  q[at] += w * nx * nx, q[at + 1] += w * nx * ny, q[at + 2] += w * nx * nz, q[at + 3] += w * nx * d, q[at + 4] += w * ny * ny, q[at + 5] += w * ny * nz, q[at + 6] += w * ny * d, q[at + 7] += w * nz * nz, q[at + 8] += w * nz * d, q[at + 9] += w * d * d;
+}
+function evaluate(q, a, b, x, y, z) {
+  let s9 = (k) => q[a + k] + q[b + k];
+  return s9(0) * x * x + 2 * s9(1) * x * y + 2 * s9(2) * x * z + 2 * s9(3) * x + s9(4) * y * y + 2 * s9(5) * y * z + 2 * s9(6) * y + s9(7) * z * z + 2 * s9(8) * z + s9(9);
+}
+function weld(positions, vertices) {
+  let bits = new Uint32Array(positions.buffer, positions.byteOffset, vertices * 3), seen = /* @__PURE__ */ new Map(), of = new Int32Array(vertices);
+  for (let w = 0; w < vertices; w++) {
+    let key = `${bits[w * 3]},${bits[w * 3 + 1]},${bits[w * 3 + 2]}`, known = seen.get(key);
+    known === void 0 ? (of[w] = seen.size, seen.set(key, seen.size)) : of[w] = known;
+  }
+  return { of, count: seen.size };
+}
+function simplifyLods(input, targets) {
+  let { positions, indices, vertices, signatures, signatureWidth } = input, faces = indices.length / 3, { of, count: count2 } = weld(positions, vertices), px = new Float64Array(count2), py = new Float64Array(count2), pz = new Float64Array(count2);
+  for (let w = 0; w < vertices; w++)
+    px[of[w]] = positions[w * 3], py[of[w]] = positions[w * 3 + 1], pz[of[w]] = positions[w * 3 + 2];
+  let corners = Int32Array.from(indices), alive = new Uint8Array(faces).fill(1), ring = Array.from({ length: count2 }, () => []);
+  for (let f = 0; f < faces; f++) for (let k = 0; k < 3; k++) ring[of[corners[f * 3 + k]]].push(f);
+  let q = new Float64Array(count2 * 10), normal = (f, out) => {
+    let a = of[corners[f * 3]], b = of[corners[f * 3 + 1]], c = of[corners[f * 3 + 2]], ux = px[b] - px[a], uy = py[b] - py[a], uz = pz[b] - pz[a], vx = px[c] - px[a], vy = py[c] - py[a], vz = pz[c] - pz[a], nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx, len = Math.hypot(nx, ny, nz);
+    return out[0] = len > 0 ? nx / len : 0, out[1] = len > 0 ? ny / len : 0, out[2] = len > 0 ? nz / len : 0, len * 0.5;
+  }, n = [0, 0, 0], edgeFaces = /* @__PURE__ */ new Map(), edgeKey = (a, b) => a < b ? a * count2 + b : b * count2 + a;
+  for (let f = 0; f < faces; f++) {
+    let area = normal(f, n), a = of[corners[f * 3]];
+    if (area > 1e-12) {
+      let d = -(n[0] * px[a] + n[1] * py[a] + n[2] * pz[a]);
+      for (let k = 0; k < 3; k++) addPlane(q, of[corners[f * 3 + k]] * 10, n[0], n[1], n[2], d, area);
+    }
+    for (let k = 0; k < 3; k++) {
+      let key = edgeKey(of[corners[f * 3 + k]], of[corners[f * 3 + (k + 1) % 3]]), list2 = edgeFaces.get(key);
+      list2 === void 0 ? edgeFaces.set(key, [f]) : list2.push(f);
+    }
+  }
+  let wedgeAt = (f, p) => {
+    for (let k = 0; k < 3; k++) if (of[corners[f * 3 + k]] === p) return corners[f * 3 + k];
+    return -1;
+  };
+  for (let [key, list2] of edgeFaces) {
+    let a = Math.floor(key / count2), b = key % count2, seam = list2.length === 2 && (wedgeAt(list2[0], a) !== wedgeAt(list2[1], a) || wedgeAt(list2[0], b) !== wedgeAt(list2[1], b));
+    if (list2.length !== 1 && !seam) continue;
+    let weight = list2.length === 1 ? 16 : 2;
+    for (let f of list2) {
+      normal(f, n);
+      let ex = px[b] - px[a], ey = py[b] - py[a], ez = pz[b] - pz[a], cx = ey * n[2] - ez * n[1], cy = ez * n[0] - ex * n[2], cz = ex * n[1] - ey * n[0], len = Math.hypot(cx, cy, cz);
+      if (len <= 0) continue;
+      cx /= len, cy /= len, cz /= len;
+      let d = -(cx * px[a] + cy * py[a] + cz * pz[a]), w = weight * (ex * ex + ey * ey + ez * ez);
+      addPlane(q, a * 10, cx, cy, cz, d, w), addPlane(q, b * 10, cx, cy, cz, d, w);
+    }
+  }
+  let stamp = new Int32Array(count2), removed = new Uint8Array(count2), heap = new Heap(), cost = (u, v) => evaluate(q, u * 10, v * 10, px[v], py[v], pz[v]), pushAround = (u) => {
+    let seen = /* @__PURE__ */ new Set();
+    for (let f of ring[u])
+      if (alive[f] !== 0)
+        for (let k = 0; k < 3; k++) {
+          let v = of[corners[f * 3 + k]];
+          v === u || seen.has(v) || (seen.add(v), heap.push(cost(u, v), u, v, stampKey(stamp[u], stamp[v])), heap.push(cost(v, u), v, u, stampKey(stamp[v], stamp[u])));
+        }
+  };
+  for (let p = 0; p < count2; p++) pushAround(p);
+  let live = faces, lods = [], snapshot = () => {
+    let out = new Uint32Array(live * 3), at = 0;
+    for (let f = 0; f < faces; f++)
+      alive[f] !== 0 && (out[at++] = corners[f * 3], out[at++] = corners[f * 3 + 1], out[at++] = corners[f * 3 + 2]);
+    lods.push(out);
+  }, before = [0, 0, 0], after = [0, 0, 0], nearest2 = (w, candidates) => {
+    if (signatures === null || candidates.length === 1) return candidates[0];
+    let best = candidates[0], bestDistance = 1 / 0;
+    for (let c of candidates) {
+      let d = 0;
+      for (let k = 0; k < signatureWidth; k++) {
+        let e = signatures[w * signatureWidth + k] - signatures[c * signatureWidth + k];
+        d += e * e;
+      }
+      (d < bestDistance || d === bestDistance && c < best) && (best = c, bestDistance = d);
+    }
+    return best;
+  }, valid = (u, v) => {
+    let shared = false;
+    for (let f of ring[u]) {
+      if (alive[f] === 0) continue;
+      let hasV = false;
+      for (let k = 0; k < 3; k++) of[corners[f * 3 + k]] === v && (hasV = true);
+      if (hasV) {
+        shared = true;
+        continue;
+      }
+      normal(f, before);
+      let saved = [px[u], py[u], pz[u]];
+      px[u] = px[v], py[u] = py[v], pz[u] = pz[v];
+      let area = normal(f, after);
+      if (px[u] = saved[0], py[u] = saved[1], pz[u] = saved[2], area <= 1e-12 || before[0] * after[0] + before[1] * after[1] + before[2] * after[2] < 0.25) return false;
+    }
+    return shared;
+  }, collapse = (u, v) => {
+    let mapped = /* @__PURE__ */ new Map(), targets2 = [];
+    for (let f of ring[v])
+      if (alive[f] !== 0)
+        for (let k = 0; k < 3; k++) {
+          let w = corners[f * 3 + k];
+          of[w] === v && targets2.indexOf(w) < 0 && targets2.push(w);
+        }
+    for (let f of ring[u]) {
+      if (alive[f] === 0) continue;
+      let wu = wedgeAt(f, u), wv = wedgeAt(f, v);
+      wv >= 0 && !mapped.has(wu) && mapped.set(wu, wv);
+    }
+    for (let f of ring[u])
+      if (alive[f] !== 0) {
+        if (wedgeAt(f, v) >= 0) {
+          alive[f] = 0, live--;
+          continue;
+        }
+        for (let k = 0; k < 3; k++) {
+          let w = corners[f * 3 + k];
+          if (of[w] !== u) continue;
+          let to = mapped.get(w);
+          to === void 0 && (to = nearest2(w, targets2), mapped.set(w, to)), corners[f * 3 + k] = to;
+        }
+        ring[v].push(f);
+      }
+    ring[u] = [], removed[u] = 1;
+    for (let k = 0; k < 10; k++) q[v * 10 + k] += q[u * 10 + k];
+    stamp[v]++;
+    let neighbours = /* @__PURE__ */ new Set();
+    for (let f of ring[v]) if (alive[f] === 1) for (let k = 0; k < 3; k++) neighbours.add(of[corners[f * 3 + k]]);
+    for (let p of neighbours) p !== v && stamp[p]++;
+    pushAround(v);
+    for (let p of neighbours) p !== v && pushAround(p);
+  }, popped = [0, 0, 0];
+  for (let t2 = 0; t2 < targets.length; t2++) {
+    let target = targets[t2];
+    for (; live > target && heap.pop(popped); ) {
+      let u = popped[0], v = popped[1];
+      removed[u] === 1 || removed[v] === 1 || popped[2] === stampKey(stamp[u], stamp[v]) && valid(u, v) && collapse(u, v);
+    }
+    let previous = lods.length === 0 ? faces : lods[lods.length - 1].length / 3;
+    if (live > target && live > previous * 0.8 || (snapshot(), live > target)) break;
+  }
+  return lods;
+}
+function lodTargets(triangles) {
+  let out = [], t2 = Math.floor(triangles / (4));
+  for (; t2 >= (64); )
+    out.push(t2), t2 = Math.floor(t2 / (4));
+  return out;
+}
+
+// src/interactives/progressive/texture.ts
+var KTX2_IDENTIFIER2 = [171, 75, 84, 88, 32, 50, 48, 187, 13, 10, 26, 10], KTX2_WIDTH = 20, KTX2_HEIGHT = 24, KTX2_DEPTH = 28, KTX2_LEVEL_COUNT2 = 40, KTX2_SCHEME = 44, KTX2_LEVEL_INDEX2 = 80, KTX2_LEVEL_BYTES2 = 24, KTX2_LEVEL_LENGTH = 8, KTX2_MAX_LEVELS = 32, SCHEME_BASIS_LZ = 1, BASE_TEXTURE_EDGE = 64;
+function isKtx2At(bytes, start, end) {
+  if (end - start < (80) + (24)) return false;
+  for (let i = 0; i < KTX2_IDENTIFIER2.length; i++) if (bytes[start + i] !== KTX2_IDENTIFIER2[i]) return false;
+  return true;
+}
+function readKtx2(bytes, start = 0, end = bytes.length) {
+  if (!isKtx2At(bytes, start, end)) return null;
+  let v = new DataView(bytes.buffer, bytes.byteOffset + start, end - start);
+  if (v.getUint32((44), true) === (1)) return null;
+  let levels = Math.max(1, v.getUint32((40), true));
+  if (levels > (32) || (80) + levels * (24) > end - start) return null;
+  let offsets = [];
+  for (let l = 0; l < levels; l++) {
+    let at = (80) + l * (24), offset = Number(v.getBigUint64(at, true)), length = Number(v.getBigUint64(at + (8), true));
+    if (offset + length > end - start) return null;
+    offsets.push(offset);
+  }
+  if (offsets[levels - 1] < (80) + levels * (24)) return null;
+  for (let l = 0; l < levels; l++) {
+    let length = Number(v.getBigUint64((80) + l * (24) + (8), true));
+    if (offsets[l] + length > (l === 0 ? end - start : offsets[l - 1]) || l + 1 < levels && offsets[l + 1] >= offsets[l]) return null;
+  }
+  return { start, end, width: v.getUint32((20), true), height: v.getUint32((24), true), depth: v.getUint32((28), true), levels, offsets };
+}
+function levelEnd(k, level) {
+  return k.start + (level === 0 ? k.end - k.start : k.offsets[level - 1]);
+}
+function levelStart(k, level) {
+  return k.start + k.offsets[level];
+}
+function shrink(size, level) {
+  return size === 0 ? 0 : Math.max(1, size >>> level);
+}
+function texels(k, level) {
+  return shrink(k.width, level) * Math.max(1, shrink(k.height, level)) * Math.max(1, shrink(k.depth, level));
+}
+function baseLevel(k, edge = (64)) {
+  let level = k.levels - 1;
+  for (; level > 0 && Math.max(shrink(k.width, level - 1), shrink(k.height, level - 1)) <= edge; ) level--;
+  return level;
+}
+var KtxStates = class {
+  constructor(bytes, k, table) {
+    this.bytes = bytes;
+    this.k = k;
+    this.table = table;
+    this.indexAt = -1;
+  }
+  state(finest) {
+    let k = this.k, index = k.start + (80);
+    this.indexAt < 0 && (this.indexAt = this.table.bytes(Uint8Array.from(this.bytes.subarray(index, index + k.levels * (24)))));
+    let fields = Uint8Array.from(this.bytes.subarray(k.start + (20), k.start + (40) + 4)), d = new DataView(fields.buffer);
+    return d.setUint32((20) - (20), shrink(k.width, finest), true), d.setUint32((24) - (20), shrink(k.height, finest), true), d.setUint32((28) - (20), shrink(k.depth, finest), true), d.setUint32((40) - (20), k.levels - finest, true), [
+      writePatch(this.table, k.start + (20), fields),
+      { op: PatchOp.write, a: index, b: this.indexAt + finest * (24), c: (k.levels - finest) * (24) }
+    ];
+  }
+};
+function planTexture(bytes) {
+  let k = readKtx2(bytes);
+  if (k === null) return null;
+  let table = new TableWriter(), states = new KtxStates(bytes, k, table), full = texels(k, 0), base = baseLevel(k), quality = (level) => Math.floor(texels(k, level) * PPM / full), levels = [
+    [{ segments: [{ dest: 0, bytes: bytes.subarray(0, levelEnd(k, base)) }], patches: base === 0 ? [] : states.state(base), quality: base === 0 ? PPM : quality(base) }]
+  ];
+  for (let level = base - 1; level >= 0; level--) {
+    let start = levelStart(k, level);
+    levels.push([{ segments: [{ dest: start, bytes: bytes.subarray(start, levelEnd(k, level)) }], patches: states.state(level), quality: level === 0 ? PPM : quality(level) }]);
+  }
+  return { kind: ProgressiveKind.texture, output: bytes.length, levels, table: table.finish() };
+}
+
+// src/interactives/progressive/mesh.ts
+var GLB_MAGIC2 = 1179937895, GLB_VERSION2 = 2, GLB_HEADER_BYTES2 = 12, GLB_CHUNK_HEADER_BYTES2 = 8, GLB_JSON2 = 1313821514, GLB_BIN2 = 5130562, GLB_ALIGN = 4, JSON_PAD = 32, COUNT_WIDTH = 10, SENTINEL_BASE = 91e8, TRIANGLES = 4, FLOAT = 5126, UNSIGNED_BYTE = 5121, UNSIGNED_SHORT = 5123, UNSIGNED_INT = 5125, MESHOPT = "EXT_meshopt_compression", KTX2_MIME = "image/ktx2", INSTANCING = "EXT_mesh_gpu_instancing", STEP = "STEP", LINEAR = "LINEAR", MIN_DECIMATE_KEYS = 16, DECIMATE_STEP = 4, COMPONENT_BYTES = { 5120: 1, 5121: 1, 5122: 2, 5123: 2, 5125: 4, 5126: 4 }, TYPE_COMPONENTS = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16 };
+function elementBytes(a) {
+  return (COMPONENT_BYTES[a.componentType] ?? 0) * (TYPE_COMPONENTS[a.type] ?? 0);
+}
+function readGlb(bytes) {
+  if (bytes.length < (12) + (8)) return null;
+  let v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (v.getUint32(0, true) !== (1179937895) || v.getUint32(4, true) !== (2) || v.getUint32(8, true) !== bytes.length) return null;
+  let jsonLength = v.getUint32((12), true);
+  if (v.getUint32((12) + 4, true) !== (1313821514)) return null;
+  let jsonStart = (12) + (8), jsonEnd = jsonStart + jsonLength;
+  if (jsonEnd + (8) > bytes.length) return null;
+  let binLength = v.getUint32(jsonEnd, true);
+  if (v.getUint32(jsonEnd + 4, true) !== (5130562) || jsonEnd + (8) + binLength !== bytes.length) return null;
+  let jsonText = new TextDecoder().decode(bytes.subarray(jsonStart, jsonEnd));
+  try {
+    return { gltf: JSON.parse(jsonText), jsonText, bin: bytes.subarray(jsonEnd + (8)) };
+  } catch {
+    return null;
+  }
+}
+function countUsers(gltf) {
+  let accessors = Array.from({ length: gltf.accessors?.length ?? 0 }, () => 0), views = Array.from({ length: gltf.bufferViews?.length ?? 0 }, () => 0), use = (a) => {
+    a !== void 0 && a >= 0 && a < accessors.length && accessors[a]++;
+  };
+  for (let mesh of gltf.meshes ?? [])
+    for (let p of mesh.primitives) {
+      use(p.indices);
+      for (let key of Object.keys(p.attributes)) use(p.attributes[key]);
+      for (let t2 of p.targets ?? []) for (let key of Object.keys(t2)) use(t2[key]);
+    }
+  for (let s9 of gltf.skins ?? []) use(s9.inverseBindMatrices);
+  for (let a of gltf.animations ?? [])
+    for (let s9 of a.samplers)
+      use(s9.input), use(s9.output);
+  for (let n of gltf.nodes ?? []) {
+    let attributes = n.extensions?.[INSTANCING]?.attributes;
+    if (attributes !== void 0) for (let key of Object.keys(attributes)) use(attributes[key]);
+  }
+  let view2 = (index) => {
+    index !== void 0 && index >= 0 && index < views.length && views[index]++;
+  };
+  for (let a of gltf.accessors ?? []) {
+    view2(a.bufferView);
+    let sparse = a.sparse;
+    view2(sparse?.indices?.bufferView), view2(sparse?.values?.bufferView);
+  }
+  for (let image of gltf.images ?? []) view2(image.bufferView);
+  return { accessors, views };
+}
+function plainView(gltf, index) {
+  if (index === void 0) return null;
+  let view2 = gltf.bufferViews?.[index];
+  return view2 === void 0 || view2.buffer !== 0 || view2.extensions?.[MESHOPT] !== void 0 ? null : view2;
+}
+function plainAccessor(gltf, index) {
+  let a = gltf.accessors?.[index];
+  return a === void 0 || a.sparse !== void 0 || a.bufferView === void 0 || elementBytes(a) === 0 ? null : a;
+}
+function readFloats(bin, start, stride, count2, width) {
+  let out = new Float32Array(count2 * width), v = new DataView(bin.buffer, bin.byteOffset, bin.byteLength);
+  for (let i = 0; i < count2; i++) for (let k = 0; k < width; k++) out[i * width + k] = v.getFloat32(start + i * stride + k * 4, true);
+  return out;
+}
+function readIndices(bin, start, count2, componentType) {
+  let out = new Uint32Array(count2), v = new DataView(bin.buffer, bin.byteOffset, bin.byteLength);
+  for (let i = 0; i < count2; i++)
+    out[i] = componentType === (5125) ? v.getUint32(start + i * 4, true) : componentType === (5123) ? v.getUint16(start + i * 2, true) : v.getUint8(start + i);
+  return out;
+}
+function encodeIndices(indices, rank, componentType) {
+  let size = COMPONENT_BYTES[componentType], out = new Uint8Array(indices.length * size), v = new DataView(out.buffer);
+  for (let i = 0; i < indices.length; i++) {
+    let value = rank[indices[i]];
+    componentType === (5125) ? v.setUint32(i * 4, value, true) : componentType === (5123) ? v.setUint16(i * 2, value, true) : v.setUint8(i, value);
+  }
+  return out;
+}
+function primitiveRows(gltf, users, p, vertices) {
+  let accessors = [...Object.values(p.attributes), ...(p.targets ?? []).flatMap((t2) => Object.values(t2))], byView = /* @__PURE__ */ new Map();
+  for (let index of accessors) {
+    let a = plainAccessor(gltf, index);
+    if (a === null || a.count !== vertices || users.accessors[index] !== 1 || plainView(gltf, a.bufferView) === null) return null;
+    let list2 = byView.get(a.bufferView) ?? [];
+    list2.push(index), byView.set(a.bufferView, list2);
+  }
+  let rows = [];
+  for (let [viewIndex, list2] of byView) {
+    let view2 = gltf.bufferViews[viewIndex];
+    if (users.views[viewIndex] !== list2.length) return null;
+    if (list2.length === 1) {
+      let a = gltf.accessors[list2[0]], stride2 = view2.byteStride ?? elementBytes(a);
+      if ((a.byteOffset ?? 0) + vertices * stride2 > view2.byteLength) return null;
+      rows.push({ start: (view2.byteOffset ?? 0) + (a.byteOffset ?? 0), stride: stride2 });
+      continue;
+    }
+    let stride = view2.byteStride;
+    if (stride === void 0 || vertices * stride > view2.byteLength) return null;
+    for (let index of list2) {
+      let a = gltf.accessors[index];
+      if ((a.byteOffset ?? 0) + elementBytes(a) > stride) return null;
+    }
+    rows.push({ start: view2.byteOffset ?? 0, stride });
+  }
+  return rows;
+}
+function planPrimitive(gltf, users, bin, p, index) {
+  if ((p.mode ?? (4)) !== (4) || p.indices === void 0 || p.extensions !== void 0) return null;
+  let position = p.attributes.POSITION;
+  if (position === void 0) return null;
+  let pa = plainAccessor(gltf, position);
+  if (pa === null || pa.componentType !== (5126) || pa.type !== "VEC3") return null;
+  let vertices = pa.count, ia = plainAccessor(gltf, p.indices);
+  if (ia === null || ia.type !== "SCALAR" || users.accessors[p.indices] !== 1 || ia.componentType !== (5121) && ia.componentType !== (5123) && ia.componentType !== (5125) || ia.count % 3 !== 0 || ia.count / 3 < (256)) return null;
+  let iv = plainView(gltf, ia.bufferView);
+  if (iv === null || iv.byteStride !== void 0 || users.views[ia.bufferView] !== 1) return null;
+  let indexStart = (iv.byteOffset ?? 0) + (ia.byteOffset ?? 0), indexBytes = ia.count * elementBytes(ia);
+  if ((ia.byteOffset ?? 0) + indexBytes > iv.byteLength) return null;
+  let rows = primitiveRows(gltf, users, p, vertices);
+  if (rows === null) return null;
+  let pv = gltf.bufferViews[pa.bufferView], positions = readFloats(bin, (pv.byteOffset ?? 0) + (pa.byteOffset ?? 0), pv.byteStride ?? elementBytes(pa), vertices, 3), indices = readIndices(bin, indexStart, ia.count, ia.componentType);
+  for (let i = 0; i < indices.length; i++) if (indices[i] >= vertices) return null;
+  let signatureParts = [], signatureWidth = 0;
+  for (let [name, width] of [
+    ["TEXCOORD_0", 2],
+    ["NORMAL", 3]
+  ]) {
+    let at2 = p.attributes[name], a = at2 === void 0 ? null : plainAccessor(gltf, at2);
+    if (a === null || a.componentType !== (5126)) continue;
+    let view2 = gltf.bufferViews[a.bufferView];
+    signatureParts.push(readFloats(bin, (view2.byteOffset ?? 0) + (a.byteOffset ?? 0), view2.byteStride ?? elementBytes(a), vertices, width)), signatureWidth += width;
+  }
+  let signatures = null;
+  if (signatureWidth > 0) {
+    signatures = new Float32Array(vertices * signatureWidth);
+    let offset = 0;
+    for (let part of signatureParts) {
+      let width = part.length / vertices;
+      for (let w = 0; w < vertices; w++) for (let k = 0; k < width; k++) signatures[w * signatureWidth + offset + k] = part[w * width + k];
+      offset += width;
+    }
+  }
+  let coarse = simplifyLods({ positions, indices, vertices, signatures, signatureWidth }, lodTargets(ia.count / 3));
+  if (coarse.length === 0) return null;
+  let lods = [...coarse.reverse(), indices], group = new Uint32Array(vertices).fill(lods.length - 1);
+  for (let k = lods.length - 1; k >= 0; k--) for (let w of lods[k]) group[w] = k;
+  let order = Uint32Array.from({ length: vertices }, (_, i) => i).sort((a, b) => group[a] - group[b] || a - b), rank = new Uint32Array(vertices);
+  for (let i = 0; i < vertices; i++) rank[order[i]] = i;
+  let prefix = [], at = 0;
+  for (let k = 0; k < lods.length; k++) {
+    for (; at < vertices && group[order[at]] <= k; ) at++;
+    prefix.push(at);
+  }
+  return prefix[lods.length - 1] = vertices, { index, rows, indexStart, indexBytes, componentType: ia.componentType, lods, prefix, order, rank };
+}
+function planClips(gltf, users) {
+  let byInput = /* @__PURE__ */ new Map(), blocked = /* @__PURE__ */ new Set();
+  for (let a of gltf.animations ?? [])
+    for (let s9 of a.samplers) {
+      let interpolation = s9.interpolation ?? LINEAR;
+      interpolation !== LINEAR && interpolation !== STEP && blocked.add(s9.input);
+      let list2 = byInput.get(s9.input) ?? [];
+      list2.push(s9), byInput.set(s9.input, list2);
+    }
+  let out = [], claimed = /* @__PURE__ */ new Set();
+  for (let [input, samplers] of byInput) {
+    if (blocked.has(input)) continue;
+    let ia = plainAccessor(gltf, input);
+    if (ia === null || ia.componentType !== (5126) || ia.type !== "SCALAR" || ia.count < (16) || users.accessors[input] !== samplers.length) continue;
+    let accessors = [input], ok = true;
+    for (let s9 of samplers) {
+      (s9.output === input || accessors.includes(s9.output) || users.accessors[s9.output] !== 1) && (ok = false);
+      let oa = plainAccessor(gltf, s9.output);
+      (oa === null || oa.count % ia.count !== 0) && (ok = false), accessors.push(s9.output);
+    }
+    if (!ok || accessors.some((a) => claimed.has(a))) continue;
+    let plans = [];
+    for (let index of accessors) {
+      let a = gltf.accessors[index], view2 = plainView(gltf, a.bufferView);
+      if (view2 === null || view2.byteStride !== void 0) {
+        ok = false;
+        break;
+      }
+      let rowBytes = a.count / ia.count * elementBytes(a);
+      if ((a.byteOffset ?? 0) + ia.count * rowBytes > view2.byteLength) {
+        ok = false;
+        break;
+      }
+      plans.push({ accessor: index, start: (view2.byteOffset ?? 0) + (a.byteOffset ?? 0), rowBytes });
+    }
+    if (ok) {
+      for (let a of accessors) claimed.add(a);
+      out.push({ keys: ia.count, accessors: plans });
+    }
+  }
+  return out;
+}
+function planImages(gltf, users, bin) {
+  let out = [];
+  for (let image of gltf.images ?? []) {
+    if (image.mimeType !== KTX2_MIME || image.bufferView === void 0 || users.views[image.bufferView] !== 1) continue;
+    let view2 = plainView(gltf, image.bufferView);
+    if (view2 === null) continue;
+    let start = view2.byteOffset ?? 0, k = readKtx2(bin, start, start + view2.byteLength);
+    k === null || baseLevel(k) === 0 || out.push({ start, end: start + view2.byteLength });
+  }
+  return out;
+}
+function overlapping(ranges) {
+  let sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end), bad = /* @__PURE__ */ new Set();
+  for (let i = 1; i < sorted.length; i++)
+    sorted[i].start < sorted[i - 1].end && (bad.add(sorted[i].owner), bad.add(sorted[i - 1].owner));
+  return bad;
+}
+function digits(value) {
+  return new TextEncoder().encode(String(value).padStart((10), " "));
+}
+function sentinelOffsets(json, sentinels) {
+  let text = new TextDecoder("latin1").decode(json), out = [];
+  for (let s9 of sentinels) {
+    let needle = String(s9), at = text.indexOf(needle);
+    if (at < 0 || text.indexOf(needle, at + 1) >= 0) return null;
+    out.push(at);
+  }
+  return out;
+}
+function firstLevelBytes(plan) {
+  let n = 0;
+  for (let unit of plan.levels[0] ?? []) for (let segment of unit.segments) n += segment.bytes.length;
+  return n;
+}
+function planMesh(bytes) {
+  let boot = planBootTier(bytes), layered = planMeshLevels(bytes);
+  return boot === null ? layered : layered === null ? boot : firstLevelBytes(layered.plan) < firstLevelBytes(boot.plan) ? layered : boot;
+}
+function planMeshLevels(bytes) {
+  let glb = readGlb(bytes);
+  if (glb === null) return null;
+  let { gltf } = glb;
+  for (let b = 1; b < (gltf.buffers ?? []).length; b++) {
+    let buffer = (gltf.buffers ?? [])[b];
+    if (buffer.uri !== void 0 || buffer.extensions?.[MESHOPT] === void 0) return null;
+  }
+  if (gltf.buffers?.[0]?.uri !== void 0) return null;
+  let users = countUsers(gltf), bin = Uint8Array.from(glb.bin), primitives = [], primitiveIndex = 0;
+  for (let mesh of gltf.meshes ?? [])
+    for (let p of mesh.primitives) {
+      let planned = planPrimitive(gltf, users, bin, p, primitiveIndex);
+      planned !== null && primitives.push(planned), primitiveIndex++;
+    }
+  let images = planImages(gltf, users, bin), clips = planClips(gltf, users), ranges = [];
+  for (let p of primitives) {
+    for (let r of p.rows) ranges.push({ start: r.start, end: r.start + p.order.length * r.stride, owner: `p${p.index}` });
+    ranges.push({ start: p.indexStart, end: p.indexStart + p.indexBytes, owner: `p${p.index}` });
+  }
+  images.forEach((im, i) => ranges.push({ start: im.start, end: im.end, owner: `i${i}` })), clips.forEach((c, i) => {
+    for (let a of c.accessors) ranges.push({ start: a.start, end: a.start + c.keys * a.rowBytes, owner: `c${i}` });
+  });
+  let bad = overlapping(ranges), keptPrimitives = primitives.filter((p) => !bad.has(`p${p.index}`));
+  if (images = images.filter((_, i) => !bad.has(`i${i}`)), clips = clips.filter((_, i) => !bad.has(`c${i}`)), keptPrimitives.length === 0 && images.length === 0 && clips.length === 0) return null;
+  for (let p of keptPrimitives) {
+    for (let r of p.rows) {
+      let length = p.order.length * r.stride, old = bin.slice(r.start, r.start + length);
+      for (let i = 0; i < p.order.length; i++) bin.set(old.subarray(p.order[i] * r.stride, (p.order[i] + 1) * r.stride), r.start + i * r.stride);
+    }
+    bin.set(encodeIndices(p.lods[p.lods.length - 1], p.rank, p.componentType), p.indexStart);
+  }
+  let edited = structuredClone(gltf), sentinels = [], counted = [], sentinel = (accessor) => {
+    let a = edited.accessors[accessor], value = (91e8) + counted.length;
+    counted.push({ accessor, full: a.count }), sentinels.push(value), a.count = value;
+  };
+  for (let p of keptPrimitives) {
+    let prim = (edited.meshes ?? []).flatMap((m) => m.primitives)[p.index], a = edited.accessors[prim.indices];
+    delete a.min, delete a.max, sentinel(prim.indices);
+  }
+  for (let c of clips) for (let a of c.accessors) sentinel(a.accessor);
+  let encoded = new TextEncoder().encode(JSON.stringify(edited)), jsonLength = Math.ceil(encoded.length / (4)) * (4), json = new Uint8Array(jsonLength).fill((32));
+  json.set(encoded);
+  let found = sentinelOffsets(json, sentinels);
+  if (found === null) return null;
+  let jsonAt = (12) + (8), countAt = /* @__PURE__ */ new Map();
+  counted.forEach((c, i) => {
+    json.set(digits(c.full), found[i]), countAt.set(c.accessor, jsonAt + found[i]);
+  });
+  let binAt = jsonAt + jsonLength + (8), source = new Uint8Array(binAt + bin.length), sv = new DataView(source.buffer);
+  return sv.setUint32(0, (1179937895), true), sv.setUint32(4, (2), true), sv.setUint32(8, source.length, true), sv.setUint32((12), jsonLength, true), sv.setUint32((12) + 4, (1313821514), true), source.set(json, jsonAt), sv.setUint32(jsonAt + jsonLength, bin.length, true), sv.setUint32(jsonAt + jsonLength + 4, (5130562), true), source.set(bin, binAt), { plan: schedule(source, binAt, keptPrimitives, images, clips, countAt, gltf), source };
+}
+function schedule(source, binAt, primitives, images, clips, countAt, gltf) {
+  let table = new TableWriter(), slice = (start, end) => ({ dest: start, bytes: source.subarray(start, end) }), countPatch = (accessor, value) => writePatch(table, countAt.get(accessor), digits(value)), dynamic = [], base = [], basePatches = [], refinements = [], components = [], primitiveList = (gltf.meshes ?? []).flatMap((m) => m.primitives), order = 0;
+  for (let p of primitives) {
+    let indexAccessor = primitiveList[p.index].indices, indexStart = binAt + p.indexStart, rows = p.rows.map((r) => ({ start: binAt + r.start, stride: r.stride })), weight = p.indexBytes;
+    for (let r of rows)
+      dynamic.push({ start: r.start, end: r.start + p.order.length * r.stride, owner: "" }), weight += p.order.length * r.stride;
+    dynamic.push({ start: indexStart, end: indexStart + p.indexBytes, owner: "" });
+    let full = p.lods[p.lods.length - 1].length, component = { weight, quality: p.lods[0].length / full };
+    components.push(component);
+    for (let r of rows) base.push(slice(r.start, r.start + p.prefix[0] * r.stride));
+    base.push({ dest: indexStart, bytes: encodeIndices(p.lods[0], p.rank, p.componentType) }), basePatches.push(countPatch(indexAccessor, p.lods[0].length));
+    for (let k = 1; k < p.lods.length; k++) {
+      let segments = rows.map((r) => slice(r.start + p.prefix[k - 1] * r.stride, r.start + p.prefix[k] * r.stride)), indices = k === p.lods.length - 1 ? source.subarray(indexStart, indexStart + p.indexBytes) : encodeIndices(p.lods[k], p.rank, p.componentType);
+      segments.push({ dest: 0, bytes: indices, staged: true });
+      let patches = [{ op: PatchOp.staged, a: indexStart, b: 0, c: indices.length }, countPatch(indexAccessor, p.lods[k].length)];
+      refinements.push({ step: k, order: order++, unit: { segments, patches }, component, quality: p.lods[k].length / full });
+    }
+  }
+  for (let image of images) {
+    let start = binAt + image.start, k = readKtx2(source, start, binAt + image.end);
+    dynamic.push({ start, end: binAt + image.end, owner: "" });
+    let b = baseLevel(k), full = texels(k, 0), component = { weight: image.end - image.start, quality: texels(k, b) / full };
+    components.push(component);
+    let states = new KtxStates(source, k, table);
+    base.push(slice(start, levelEnd(k, b))), basePatches.push(...states.state(b));
+    for (let level = b - 1; level >= 0; level--) {
+      let unit = { segments: [slice(levelStart(k, level), levelEnd(k, level))], patches: states.state(level) };
+      refinements.push({ step: b - level, order: order++, unit, component, quality: texels(k, level) / full });
+    }
+  }
+  for (let clip of clips) {
+    let coarse = coarseKeys(clip.keys, (4)), weight = 0, staged = [], patches = [], stagingAt = 0;
+    for (let a of clip.accessors) {
+      let start = binAt + a.start, length = clip.keys * a.rowBytes;
+      weight += length, dynamic.push({ start, end: start + length, owner: "" });
+      let front = new Uint8Array(coarse * a.rowBytes), rest = new Uint8Array((clip.keys - coarse) * a.rowBytes), f = 0, r = 0;
+      for (let i = 0; i < clip.keys; i++) {
+        let row = source.subarray(start + i * a.rowBytes, start + (i + 1) * a.rowBytes);
+        isCoarseKey(i, clip.keys, (4)) ? front.set(row, f++ * a.rowBytes) : rest.set(row, r++ * a.rowBytes);
+      }
+      base.push({ dest: start, bytes: front });
+      let ratio = a.rowBytes / elementBytes(gltf.accessors[a.accessor]);
+      basePatches.push(countPatch(a.accessor, coarse * ratio)), staged.push({ dest: stagingAt, bytes: rest, staged: true }), patches.push({ op: PatchOp.merge, a: start, b: stagingAt, c: table.words(clip.keys, a.rowBytes, (4)) }), patches.push(countPatch(a.accessor, clip.keys * ratio)), stagingAt += rest.length;
+    }
+    let component = { weight, quality: coarse / clip.keys };
+    components.push(component), refinements.push({ step: 1, order: order++, unit: { segments: staged, patches }, component, quality: 1 });
+  }
+  dynamic.sort((a, b) => a.start - b.start);
+  let statics = [slice(0, binAt)], cursor = binAt;
+  for (let r of dynamic)
+    r.start > cursor && statics.push(slice(cursor, r.start)), cursor = Math.max(cursor, r.end);
+  cursor < source.length && statics.push(slice(cursor, source.length));
+  let staticWeight = 0;
+  for (let s9 of statics) staticWeight += s9.bytes.length;
+  let total = staticWeight;
+  for (let c of components) total += c.weight;
+  let quality = () => {
+    let value = staticWeight;
+    for (let c of components) value += c.weight * c.quality;
+    return Math.min(PPM, Math.floor(value * PPM / total));
+  }, levels = [[{ segments: [...statics, ...base], patches: basePatches, quality: quality() }]];
+  refinements.sort((a, b) => a.step - b.step || unitBytes(a.unit) - unitBytes(b.unit) || a.order - b.order);
+  let step = 0;
+  for (let i = 0; i < refinements.length; i++) {
+    let r = refinements[i];
+    r.component.quality = r.quality;
+    let last = i === refinements.length - 1, unit = { ...r.unit, quality: last ? PPM : quality() };
+    r.step !== step && (levels.push([]), step = r.step), levels[levels.length - 1].push(unit);
+  }
+  return { kind: ProgressiveKind.mesh, output: source.length, levels, table: table.finish() };
+}
+function unitBytes(unit) {
+  let n = 0;
+  for (let s9 of unit.segments) n += s9.bytes.length;
+  return n;
+}
+var BOOT_HINT = "cimplify_boot", BOOT_HINT_VERSION = 1;
+function accessorRefs(value, out) {
+  if (typeof value == "number" && Number.isInteger(value)) out.add(value);
+  else if (Array.isArray(value)) for (let v of value) accessorRefs(v, out);
+  else if (value !== null && typeof value == "object") for (let v of Object.values(value)) accessorRefs(v, out);
+}
+function usedAccessors(gltf) {
+  let used = /* @__PURE__ */ new Set();
+  for (let mesh of gltf.meshes ?? [])
+    for (let p of mesh.primitives) {
+      p.indices !== void 0 && used.add(p.indices);
+      for (let a of Object.values(p.attributes)) used.add(a);
+      for (let t2 of p.targets ?? []) for (let a of Object.values(t2)) used.add(a);
+      accessorRefs(p.extensions, used);
+    }
+  for (let s9 of gltf.skins ?? []) s9.inverseBindMatrices !== void 0 && used.add(s9.inverseBindMatrices);
+  for (let a of gltf.animations ?? [])
+    for (let s9 of a.samplers)
+      used.add(s9.input), used.add(s9.output);
+  for (let n of gltf.nodes ?? []) accessorRefs(n.extensions?.[INSTANCING]?.attributes, used);
+  return used;
+}
+function usedViews(gltf, accessors) {
+  let views = /* @__PURE__ */ new Set();
+  for (let index of accessors) {
+    let a = gltf.accessors?.[index];
+    a?.bufferView !== void 0 && views.add(a.bufferView);
+    let sparse = a?.sparse;
+    sparse?.indices?.bufferView !== void 0 && views.add(sparse.indices.bufferView), sparse?.values?.bufferView !== void 0 && views.add(sparse.values.bufferView);
+  }
+  for (let image of gltf.images ?? []) image.bufferView !== void 0 && views.add(image.bufferView);
+  return views;
+}
+function viewRange(view2) {
+  let compressed = view2.extensions?.[MESHOPT];
+  return compressed !== void 0 ? compressed.buffer === 0 ? [compressed.byteOffset ?? 0, (compressed.byteOffset ?? 0) + compressed.byteLength] : null : view2.buffer === 0 ? [view2.byteOffset ?? 0, (view2.byteOffset ?? 0) + view2.byteLength] : null;
+}
+function paddedJson(json, length) {
+  let out = new Uint8Array(length).fill((32));
+  return out.set(json), out;
+}
+function planBootTier(bytes) {
+  let glb = readGlb(bytes);
+  if (glb === null) return null;
+  let root = glb.gltf, hint = root.extras?.[BOOT_HINT];
+  if (hint === void 0 || hint.version !== (1)) return null;
+  let whole = structuredClone(root);
+  delete whole.extras[BOOT_HINT], Object.keys(whole.extras ?? {}).length === 0 && delete whole.extras;
+  let base = structuredClone(whole);
+  for (let p of hint.primitives ?? []) {
+    let primitive = base.meshes?.[p.mesh]?.primitives[p.primitive];
+    if (primitive === void 0) return null;
+    primitive.attributes = { ...p.attributes }, primitive.indices = p.indices, delete primitive.extensions;
+  }
+  for (let s9 of hint.samplers ?? []) {
+    let sampler = base.animations?.[s9.animation]?.samplers[s9.sampler];
+    if (sampler === void 0) return null;
+    sampler.input = s9.input, sampler.output = s9.output;
+  }
+  (base.animations ?? []).forEach((animation, index) => {
+    index !== (hint.clip ?? 0) && (animation.samplers = [], animation.channels = []);
+  });
+  let live = usedAccessors(base), baseViews = usedViews(base, live);
+  base.accessors = (base.accessors ?? []).map(
+    (accessor, index) => live.has(index) || accessor.bufferView === void 0 || baseViews.has(accessor.bufferView) ? accessor : { bufferView: accessor.bufferView, componentType: (5121), count: 1, type: "SCALAR" }
+  );
+  let late = [];
+  (base.bufferViews ?? []).forEach((view2, index) => {
+    if (baseViews.has(index)) return;
+    let range = viewRange(view2);
+    range !== null && late.push(range), view2.extensions?.[MESHOPT] !== void 0 && (delete view2.extensions[MESHOPT], Object.keys(view2.extensions).length === 0 && delete view2.extensions);
+  });
+  let kept = (whole.bufferViews ?? []).map((view2, index) => baseViews.has(index) ? viewRange(view2) : null).filter((r) => r !== null), reserved = late.filter(([start, end]) => !kept.some(([a, b]) => a < end && start < b));
+  if (reserved.length === 0) return null;
+  let encoder2 = new TextEncoder(), baseJson = encoder2.encode(JSON.stringify(base)), wholeJson = encoder2.encode(JSON.stringify(whole)), length = Math.ceil(Math.max(baseJson.length, wholeJson.length) / (4)) * (4), jsonAt = (12) + (8), binAt = jsonAt + length + (8), source = new Uint8Array(binAt + glb.bin.length), sv = new DataView(source.buffer);
+  sv.setUint32(0, (1179937895), true), sv.setUint32(4, (2), true), sv.setUint32(8, source.length, true), sv.setUint32((12), length, true), sv.setUint32((12) + 4, (1313821514), true), source.set(paddedJson(wholeJson, length), jsonAt), sv.setUint32(binAt - (8), glb.bin.length, true), sv.setUint32(binAt - (8) + 4, (5130562), true), source.set(glb.bin, binAt), reserved.sort((a, b) => a[0] - b[0]);
+  let slice = (start, end) => ({ dest: start, bytes: source.subarray(start, end) }), head = [slice(0, jsonAt), { dest: jsonAt, bytes: baseJson }, slice(binAt - (8), binAt)], pad = { op: PatchOp.fill, a: jsonAt + baseJson.length, b: (32), c: length - baseJson.length }, refinement = [slice(jsonAt, jsonAt + length)], cursor = 0, deferred = 0;
+  for (let [start, end] of reserved) {
+    start > cursor && head.push(slice(binAt + cursor, binAt + start));
+    let from = Math.max(start, cursor);
+    end > from && (refinement.push(slice(binAt + from, binAt + end)), deferred += end - from), cursor = Math.max(cursor, end);
+  }
+  cursor < glb.bin.length && head.push(slice(binAt + cursor, binAt + glb.bin.length));
+  let quality = Math.floor((source.length - deferred) * PPM / source.length), table = new TableWriter();
+  return {
+    plan: {
+      kind: ProgressiveKind.mesh,
+      output: source.length,
+      levels: [[{ segments: head, patches: pad.c > 0 ? [pad] : [], quality }], [{ segments: refinement, patches: [], quality: PPM }]],
+      table: table.finish()
+    },
+    source
+  };
+}
+
+// src/interactives/progressive/mips.ts
+var VK_R8G8B8A8_UNORM = 37, VK_R8G8B8A8_SRGB = 43, VK_R16G16B16A16_SFLOAT = 97, SCHEME_NONE = 0, SCHEME_ZSTD = 2, HEADER_VK_FORMAT = 12, HEADER_TYPE_SIZE = 16, HEADER_WIDTH = 20, HEADER_HEIGHT = 24, HEADER_DEPTH = 28, HEADER_LAYERS = 32, HEADER_FACES = 36, HEADER_LEVELS = 40, HEADER_SCHEME = 44, HEADER_DFD_OFFSET = 48, HEADER_DFD_LENGTH = 52, HEADER_KVD_OFFSET = 56, HEADER_KVD_LENGTH = 60, HEADER_SGD_OFFSET = 64, HEADER_SGD_LENGTH = 72, LEVEL_INDEX = 80, LEVEL_ENTRY = 24, LEVEL_LENGTH = 8, LEVEL_UNCOMPRESSED = 16, CHANNELS = 4, HALF_BYTES = 2, ALIGN = 4, SRGB_CUTOFF = 0.04045, SRGB_LINEAR_CUTOFF = 31308e-7, SRGB_SCALE = 12.92, SRGB_A = 0.055, SRGB_GAMMA = 2.4, BYTE_MAX = 255, HALF_EXPONENT_BIAS = 15, FLOAT_EXPONENT_BIAS = 127, HALF_MANTISSA_BITS = 10, FLOAT_MANTISSA_BITS = 23, HALF_EXPONENT_MAX = 31, SAMPLES_PER_TEXEL = 4;
+function formatOf(vk) {
+  return vk === (37) ? "unorm" : vk === (43) ? "srgb" : vk === (97) ? "half" : null;
+}
+var scratch = new DataView(new ArrayBuffer(4));
+function halfToFloat(bits) {
+  let sign = bits & 32768 ? -1 : 1, exponent = bits >> (10) & (31), mantissa = bits & 1023;
+  return exponent === 0 ? sign * mantissa * 2 ** (1 - (15) - (10)) : exponent === (31) ? mantissa === 0 ? sign * (1 / 0) : Number.NaN : sign * (1 + mantissa / (1 << (10))) * 2 ** (exponent - (15));
+}
+function floatToHalf(value) {
+  scratch.setFloat32(0, value);
+  let bits = scratch.getUint32(0), sign = bits >>> 16 & 32768, exponent = (bits >>> (23) & 255) - (127) + (15), mantissa = bits & 8388607;
+  return exponent <= 0 ? sign : exponent >= (31) ? sign | 31744 : sign | exponent << (10) | mantissa >>> (23) - (10);
+}
+function toLinear(byte) {
+  let c = byte / (255);
+  return c <= (0.04045) ? c / (12.92) : ((c + (0.055)) / (1 + (0.055))) ** (2.4);
+}
+function toSrgb(linear) {
+  let c = linear <= (31308e-7) ? linear * (12.92) : (1 + (0.055)) * linear ** (1 / (2.4)) - (0.055);
+  return Math.round(Math.min(1, Math.max(0, c)) * (255));
+}
+function read(level, format) {
+  let texels2 = format === "half" ? level.length / (2) : level.length, out = new Float32Array(texels2);
+  if (format === "half") {
+    let view2 = new DataView(level.buffer, level.byteOffset, level.byteLength);
+    for (let i = 0; i < texels2; i++) out[i] = halfToFloat(view2.getUint16(i * (2), true));
+  } else
+    for (let i = 0; i < texels2; i++) out[i] = format === "srgb" && i % (4) !== (4) - 1 ? toLinear(level[i]) : level[i] / (255);
+  return out;
+}
+function write(values, format) {
+  if (format === "half") {
+    let out2 = new Uint8Array(values.length * (2)), view2 = new DataView(out2.buffer);
+    for (let i = 0; i < values.length; i++) view2.setUint16(i * (2), floatToHalf(values[i]), true);
+    return out2;
+  }
+  let out = new Uint8Array(values.length);
+  for (let i = 0; i < values.length; i++)
+    out[i] = format === "srgb" && i % (4) !== (4) - 1 ? toSrgb(values[i]) : Math.round(Math.min(1, Math.max(0, values[i])) * (255));
+  return out;
+}
+function halve(source, width, height) {
+  let w = Math.max(1, width >>> 1), h = Math.max(1, height >>> 1), out = new Float32Array(w * h * (4));
+  for (let y = 0; y < h; y++)
+    for (let x = 0; x < w; x++)
+      for (let c = 0; c < (4); c++) {
+        let sum = 0;
+        for (let dy = 0; dy < 2; dy++)
+          for (let dx = 0; dx < 2; dx++) {
+            let sx = Math.min(width - 1, x * 2 + dx), sy = Math.min(height - 1, y * 2 + dy);
+            sum += source[(sy * width + sx) * (4) + c];
+          }
+        out[(y * w + x) * (4) + c] = sum / (4);
+      }
+  return { values: out, width: w, height: h };
+}
+function align(value) {
+  return Math.ceil(value / (4)) * (4);
+}
+function withMipChain(bytes, inflate, compress) {
+  if (!isKtx2At(bytes, 0, bytes.length)) return null;
+  let v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), format = formatOf(v.getUint32((12), true)), scheme = v.getUint32((44), true), width = v.getUint32((20), true), height = v.getUint32((24), true);
+  if (format === null || Math.max(1, v.getUint32((40), true)) !== 1 || v.getUint32((28), true) !== 0 || v.getUint32((32), true) > 1 || v.getUint32((36), true) !== 1 || width < 2 || height < 2 || scheme !== (0) && (scheme !== (2) || inflate === null || compress === null) || Number(v.getBigUint64((72), true)) !== 0) return null;
+  let offset = Number(v.getBigUint64((80), true)), length = Number(v.getBigUint64((80) + (8), true)), stored = bytes.subarray(offset, offset + length), level0 = scheme === (2) ? inflate?.(stored) ?? null : stored, texelBytes = format === "half" ? (4) * (2) : (4);
+  if (level0 === null || level0.length !== width * height * texelBytes) return null;
+  let levels = [level0], current = { values: read(level0, format), width, height };
+  for (; current.width > 1 || current.height > 1; )
+    current = halve(current.values, current.width, current.height), levels.push(write(current.values, format));
+  let encoded = levels.map((level) => scheme === (2) && compress !== null ? compress(level) : level), dfdOffset = v.getUint32((48), true), dfdLength = v.getUint32((52), true), kvdOffset = v.getUint32((56), true), kvdLength = v.getUint32((60), true), indexEnd = (80) + levels.length * (24), newDfd = align(indexEnd), newKvd = kvdLength === 0 ? 0 : align(newDfd + dfdLength), at = align(kvdLength === 0 ? newDfd + dfdLength : newKvd + kvdLength), placed = new Array(levels.length).fill(0);
+  for (let l = levels.length - 1; l >= 0; l--)
+    placed[l] = at, at = align(at + encoded[l].length);
+  let total = placed[0] + encoded[0].length, out = new Uint8Array(total), w = new DataView(out.buffer);
+  return out.set(bytes.subarray(0, (80))), w.setUint32((40), levels.length, true), w.setUint32((48), newDfd, true), w.setUint32((56), newKvd, true), w.setBigUint64((64), 0n, true), w.setBigUint64((72), 0n, true), w.setUint32((16), v.getUint32((16), true), true), levels.forEach((level, l) => {
+    let entry = (80) + l * (24);
+    w.setBigUint64(entry, BigInt(placed[l]), true), w.setBigUint64(entry + (8), BigInt(encoded[l].length), true), w.setBigUint64(entry + (16), BigInt(level.length), true);
+  }), out.set(bytes.subarray(dfdOffset, dfdOffset + dfdLength), newDfd), kvdLength > 0 && out.set(bytes.subarray(kvdOffset, kvdOffset + kvdLength), newKvd), encoded.forEach((level, l) => out.set(level, placed[l])), out;
+}
+
+// src/interactives/progressive/splat.ts
+var CSPL_MAGIC = 1280332611, CSPL_VERSION = 3, CSPL_VERSION_STATIC = 2, CSPL_HEADER_BYTES = 120, CSPL_HEADER_BYTES_STATIC = 96, CSPL_REGIONS = 96, CSPL_SKIN = 100, REGION_PLANES = 1, SKIN_PLANES = 8, CSPL_COUNT = 8, CSPL_FLAGS = 12, CSPL_LEVEL1 = 56, CSPL_LEVEL2 = 60, CSPL_PALETTE = 64, CSPL_PAYLOAD = 92, SH_DEGREE_MASK = 255, CODEC_SHIFT = 8, CODEC_MASK = 255, CODEC_RAW = 0, CODEC_ZSTD = 1, BASE_PLANES = 16, LABEL_PLANES = 2, CHANNELS2 = 3, REST_BY_DEGREE = [0, 3, 8, 15];
+function isSplatChunk(bytes) {
+  return bytes.length >= (96) && new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, true) === (1280332611);
+}
+function planSplat(bytes, inflate, compress) {
+  if (!isSplatChunk(bytes) || compress === null) return null;
+  let v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), version = v.getUint32(4, true);
+  if (version !== (3) && version !== (2)) return null;
+  let headerBytes = version === (3) ? (120) : (96);
+  if (bytes.length < headerBytes) return null;
+  let skinned = version === (3) && v.getUint32((100), true) !== 0, labelled = version === (3) && v.getUint32((96), true) !== 0, count2 = v.getUint32((8), true), flags = v.getUint32((12), true), codec = flags >>> (8) & (255), degree = flags & (255);
+  if (degree >= REST_BY_DEGREE.length) return null;
+  let planes = (16) + (degree > 0 ? (2) : 0) + (labelled ? (1) : 0) + (skinned ? (8) : 0), paletteBytes = v.getUint32((64), true) * REST_BY_DEGREE[degree] * (3), payloadBytes = v.getUint32((92), true);
+  if (headerBytes + payloadBytes !== bytes.length || count2 === 0) return null;
+  let payload = bytes.subarray(headerBytes), raw = codec === (0) ? payload : codec === (1) && inflate !== null ? inflate(payload) : null;
+  if (raw === null || raw.length !== count2 * planes + paletteBytes) return null;
+  let level1 = Math.min(count2, v.getUint32((56), true)), level2 = Math.min(level1, v.getUint32((60), true)), bounds2 = [0, level2, level1, count2].filter((b, i, all) => i === 0 || b > all[i - 1]), bands = bounds2.length - 1;
+  if (bands < 2) return null;
+  let frames = [];
+  for (let p = 0; p < planes; p++) {
+    let row = [];
+    for (let k = 0; k < bands; k++) row.push(compress(raw.subarray(p * count2 + bounds2[k], p * count2 + bounds2[k + 1])));
+    frames.push(row);
+  }
+  let palette = paletteBytes > 0 ? compress(raw.subarray(count2 * planes)) : new Uint8Array(0), payloadFor = (last) => {
+    let n = palette.length;
+    for (let p = 0; p < planes; p++) for (let k = 0; k <= last; k++) n += frames[p][k].length;
+    return n;
+  }, full = payloadFor(bands - 1), source = new Uint8Array(headerBytes + full);
+  source.set(bytes.subarray(0, headerBytes));
+  let sv = new DataView(source.buffer);
+  sv.setUint32((12), flags & -65281 | (1) << (8), true), sv.setUint32((92), full, true);
+  let at = headerBytes;
+  for (let p = 0; p < planes; p++)
+    for (let k = 0; k < bands; k++)
+      source.set(frames[p][k], at), at += frames[p][k].length;
+  source.set(palette, at);
+  let table = new TableWriter(), scratch2 = frames.map(() => []), staging = 0, paletteAt = 0, levels = [];
+  for (let k = 0; k < bands; k++) {
+    let segments = [];
+    for (let p = 0; p < planes; p++)
+      scratch2[p].push(staging), segments.push({ dest: staging, bytes: frames[p][k], staged: true }), staging += frames[p][k].length;
+    k === 0 && palette.length > 0 && (paletteAt = staging, segments.push({ dest: staging, bytes: palette, staged: true }), staging += palette.length);
+    let records = bounds2[k + 1], last = k === bands - 1, header = source.slice(0, headerBytes), hv = new DataView(header.buffer);
+    hv.setUint32((8), records, true), hv.setUint32((56), Math.min(level1, records), true), hv.setUint32((60), Math.min(level2, records), true), hv.setUint32((92), payloadFor(k), true);
+    let patches = [writePatch(table, 0, header)], out = headerBytes;
+    for (let p = 0; p < planes; p++)
+      for (let b = 0; b <= k; b++)
+        patches.push({ op: PatchOp.staged, a: out, b: scratch2[p][b], c: frames[p][b].length }), out += frames[p][b].length;
+    palette.length > 0 && (patches.push({ op: PatchOp.staged, a: out, b: paletteAt, c: palette.length }), out += palette.length), patches.push({ op: PatchOp.length, a: out, b: 0, c: 0 }), levels.push([{ segments, patches, quality: last ? PPM : Math.floor(records * PPM / count2) }]);
+  }
+  return { plan: { kind: ProgressiveKind.splat, output: source.length, levels, table: table.finish() }, source };
+}
+
+// src/interactives/progressive/build.ts
+var MIN_PROGRESSIVE_BYTES = 16 * 1024, DEFAULT_PROGRESSIVE_KINDS = /* @__PURE__ */ new Set(["texture", "mesh", "audio", "cells", "splat"]);
+function planFor(bytes, options) {
+  let allowed = (kind) => options.kinds === void 0 || options.kinds.has(kind), mesh = allowed("mesh") ? planMesh(bytes) : null;
+  if (mesh !== null) return mesh;
+  if (allowed("texture")) {
+    let mipped = withMipChain(bytes, options.inflate ?? null, options.compress ?? null) ?? bytes, texture = planTexture(mipped);
+    if (texture !== null) return { plan: texture, source: mipped };
+  }
+  let splat = allowed("splat") ? planSplat(bytes, options.inflate ?? null, options.compress ?? null) : null;
+  if (splat !== null) return splat;
+  let audio = allowed("audio") ? planAudio(bytes) : null;
+  if (audio !== null) return { plan: audio, source: bytes };
+  let cells = allowed("cells") ? planCells(bytes) : null;
+  return cells !== null ? { plan: cells, source: bytes } : null;
+}
+function buildProgressive(input, options = {}) {
+  if (input.length < (options.minBytes ?? MIN_PROGRESSIVE_BYTES)) return null;
+  let bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength), planned = planFor(bytes, options);
+  if (planned === null || planned.plan.levels.length < 2) return null;
+  let encoded = encodeContainer(planned.plan);
+  return {
+    kind: planned.plan.kind,
+    source: planned.source,
+    container: encoded.bytes,
+    head: encoded.head,
+    first: encoded.first,
+    levelEnds: encoded.levelEnds,
+    unitEnds: encoded.unitEnds,
+    levelQuality: planned.plan.levels.map((l) => l[l.length - 1].quality)
+  };
+}
+
+export { AI_MARK_LABEL, AI_MARK_NAMESPACE, AI_MARK_SOURCES, AI_MARK_TEXT, AiMark, Badge, COZY_PASTEL, ChatLog, ChatPanel, Countdown, DEFAULT_AI_MARK, DEFAULT_LANGUAGES, DEFAULT_QUALITIES, DamageNumbers, Dropdown, FANTASY_PARCHMENT, GeneratedText, InventoryGrid, KIT_NAMESPACE, Leaderboard, LoadingScreen, MAP_HEADING, MAP_PAN_X, MAP_PAN_Y, Minimap, Modal, ModalStack, NEON_ARCADE, PauseScreen, RICH_COLORS, RadialMenu, ResultsScreen, RichText, RichTextError, SIMULATOR_FIXED_STEP_MS, SPORTS_BROADCAST, SettingsScreen, SimulatorUnsupportedError, Slider, THEME_PACKS, TextButton, Toggle, Tooltip, TutorialHint, UI_DEFAULT_FONT, UI_FONT_ROLES, UI_FONT_SET, UiFocusScope, UiNavigator, UiParticles, VirtualList, aiLabel, aiMark, aiMarkTheme, aiMarkVars, applyThemePack, badge, chatLog, chatPanel, countdown, createSimulatorCtx, currentThemePack, damageNumbers, dropdown, focusNodeOf, fontStyle, generatedText, generate_exports as generation, inventoryGrid, isAiGenerated, kitFamily, kitVars, leaderboard, loadingScreen, minimap, modal, modalStack, parts_exports as parts, pauseScreen, progressive_exports as progressive, radialMenu, registerUiFont, resultsScreen, richText, settingsScreen, slider, textButton, themePack, toggle, tooltip, tutorialHint, uiParticles, virtualList, worlds_exports as worlds };