@cimplify/sdk 0.108.0 → 0.110.2

package/dist/game/kit/canvas.mjs

@@ -0,0 +1,1039 @@
+import { PlaceViewerScene, PLACE_VIEWER_SET, PLACE_VIEWER_CAMERA, emptyWorld, bakeThingGlb, ThingEffects, LivePlayer, applySky, buildIdentityCharacter, engineAvatarExports, AVATAR_DESIGN_REPORT, AvatarDesignSession, AvatarDesigner, VECTOR_REPORT, VectorEditSession, CROWD_CHARACTER_ASSET } from '../../chunk-GCX7TY4D.mjs';
+export { ANCHOR_ROLL, ANCHOR_SCALE, ANCHOR_STRIDE, ANCHOR_X, ANCHOR_Y, ANY_STATE, ARKIT_COUNT, AVATAR_DESIGN, AVATAR_DESIGN_REPORT, AVATAR_MOODS, AVATAR_OUTPUT_FLOATS, AVATAR_SLOTS, AVATAR_SPRING_GROUPS, AXIS_X, AXIS_Y, AXIS_Z, Achievements, AdaptiveMusic, AiInbox, AnimationGraph, Autosave, AvatarDesignSession, AvatarDesigner, AvatarModels, AvatarPerformer, AvatarRoster, BLANK_ARTBOARD_NAME, BLANK_ARTBOARD_SIZE, BindState, CAST_SHADOW, CATALOGUE_MODELS, CATALOGUE_PROP_RECIPES, CATALOGUE_RECIPE_SOURCES, CHEER_FULL_MOMENT, CROWD_CHARACTER_ASSET, CROWD_CHARACTER_ITEM, Checkpoints, ClipRecorder, CtxTurnRoom, DAY_HOUR, DAY_INDEX, DEFAULT_CLIP_MS, DEFAULT_FLY_ROTATION_KEYS, DEFAULT_MOVEMENT_KEYS, DEFAULT_STACK_LIMIT, DayClock, DragControls, DropTable, ENGINE_AVATAR_EXPORT_NAMES, EXPRESSION_COUNT, EYE_HEIGHT, FIRST_RANK, FaceAnchors, FaceExpression, FaceLandmark, FaceSession, FirstPersonControls, FlyControls, FriendChallenges, GRAPH_BLEND_SECONDS, GRAPH_CURRENT, GRAPH_ELAPSED, GRAPH_PREVIOUS, GRAPH_PRIORITY, GRAPH_STATE_SECONDS, GRAPH_TRANSITION, GyroLookControls, HOURS_PER_DAY, HeadPose, INVENTORY_SNAPSHOT_STRIDE, Inventory, LANDMARK_COUNT, LEVEL_FOR_TIER, LIVE_VALUES, Leaderboard, Ledger, LivePlayer, METRIC_WIDTH, MapControls, MathUtils, MovementAxes, NO_ACHIEVEMENT, NO_CHECKPOINT, NO_ITEM, NO_MOOD, NO_OBJECTIVE, NO_SLOT, NO_STATE, NPC_STRIDE, NPC_WALKING, NpcSchedules, ONE_WATCHER, Objectives, OrbitControls, PLACE_VIEWER_CAMERA, PLACE_VIEWER_SET, PLAYER_WATCHER, POSE_COUNT, PROP_LEVELS, PROP_RECIPES, PlaceViewerScene, PointerLockControls, PortClipAction, PremiumStore, RECEIVE_SHADOW, REPLAY_RATES, RankedScores, ReplayRecorder, SCORE, SCORE_BEST, SCORE_COMBO, SCORE_COMBO_LEFT, SCORE_ELAPSED, SCORE_REMAINING, SCORE_TIME_UP, SETTLE_CYCLES, SETTLE_DAMPING, SKY_PRESETS, SOUND_RECIPES, START_MOMENT, SaveSlots, ScoreHud, ScoreTimer, Shop, ShopResult, SlotPool, StatusLine, TEXTURE_RECIPES, ThingEffects, ThreePort, TrackballControls, UNLIMITED_STOCK, UiBinder, VECTOR_REPORT, VECTOR_VIEWER, VectorEditSession, VectorMessageError, WORLD_LAYERS, Waves, applySky, arkitWeight, authorValue, bakeThingGlb, beats, blankVectorFile, blockoutKinds, buildIdentityCharacter, buildPropGlb, captureFace, catalogueProblems, chemistry_exports as chemistry, chooseMotion, choosePreset, clockText, defineEconomy, deviceQuaternion, economyManifest, economyToml, emptyWorld, encodeWav, engineAvatarExports, giftKey, hasModel, hourAt, keyOfCode, kindsWithoutModels, loadThingSounds, modelCost, modelRecipeFor, moodIndex, newStreak, oddsMatch, offerMatches, openSaveSlots, parseStreak, playable, propBounds, propTriangles, quiltTexture, readImageRequest, readInput, readPlayback, readShow, recordPlay, remainingCimples, replayInputs, showcase_exports as showcase, slottedRunner, slottedShootout, streakAlive, streakAtRisk, streakStatus, synthesizeSound, synthesizeTexture, voteKey, weatherOf } from '../../chunk-GCX7TY4D.mjs';
+import { wordPuzzleTemplate } from '../../chunk-SAFJIGYB.mjs';
+export { word_exports as word } from '../../chunk-SAFJIGYB.mjs';
+import { jollofTycoonTemplate } from '../../chunk-F3UJ6ZRM.mjs';
+export { DailyChallenges, MS_PER_DAY, dayIndex, daySeed, hashSalt, tycoon_exports as tycoon, utcOffsetMinutes } from '../../chunk-F3UJ6ZRM.mjs';
+import { danfoRouteTemplate } from '../../chunk-7IQQQENP.mjs';
+export { danfo_exports as danfo } from '../../chunk-7IQQQENP.mjs';
+import { courierTemplate } from '../../chunk-KU7O4IXU.mjs';
+export { CIRCLE_RADIUS, CIRCLE_WORDS, CIRCLE_X, CIRCLE_Z, KEEP_OUT_STRIDE, KeepOut, MAX_SCATTER_TRIES, NO_PICKUP, PICKUP_STRIDE, Pickups, SeekBot, courier_exports as courier, daylight, staticBox, walledArena, withinCircle, withinRadius } from '../../chunk-KU7O4IXU.mjs';
+export { worlds_exports as worlds } from '../../chunk-AQ5RLBU2.mjs';
+export { ANIM_AIR, ANIM_CROUCH, ANIM_PELVIS_OFFSET, ANIM_SPEED, CHASE_DISTANCE, CHASE_FOV, CHASE_PITCH, CHASE_SPEED, CHASE_X, CHASE_Y, CHASE_YAW, CHASE_Z, CharacterAnimator, ChaseCamera, FirstPersonView, TOUCH_CONTROLS, VIEW_BOB_PHASE, VIEW_BOB_WEIGHT, VIEW_DIP, VIEW_FOV, VIEW_PITCH, VIEW_X, VIEW_Y, VIEW_YAW, VIEW_Z, chasePreset, defineDriveActions, definePlayActions, engineSurfaceOf, firstPerson, thirdPersonCharacter, vehicleDriver } from '../../chunk-ZCY6YKKP.mjs';
+export { KitVehicle, vehiclePreset } from '../../chunk-CYBMFMJD.mjs';
+export { frontier_exports as frontier } from '../../chunk-J6KQZ4FO.mjs';
+export { genesis_exports as genesis } from '../../chunk-6PFNJPBJ.mjs';
+export { COMMERCE_CAPABILITIES, ECONOMY_IDENTIFIER, IN_WORLD_CATEGORY, REAL_MONEY_SUGGESTION, auditEconomy, auditManifestEconomy, inWorldRefusal, judgeEconomy, kitPublicationGates, realMoneyIn } from '../../chunk-XZSDGZX6.mjs';
+export { Bool, Character, Choice, ContentRef, DIGEST_PREFIX, INLINE_VALUE_BYTES, Int, MAX_REMIX_DEPTH, Num, Palette, Params, REMIX_FORMAT, RemixError, SLOT_TEMPLATES, SceneReportError, SceneSlot, TEMPLATE_SCHEMA_FORMAT, TEMPLATE_SLOTS_FLAG, THEME_PRESETS, TemplateSlotError, Theme, Track, anchors, assignSlots, canonicalSlotJson, checkSlot, colorInt, contrastRatio, decodeRemix, describeIssue, describeSlot, encodeRemix, memoryRemixSources, parseColor, remix, remixDigest, remixLineage, resolveRemix, runnerSlots, shootoutSlots, slotChoices, slotContent, slotDigest, slotPresets, slotSceneFromReport, template, templateFromSchema, templateRef, templateSchema, templateSlotsEnabled } from '../../chunk-NMQT4HG3.mjs';
+import { attachSurfaceInput } from '../../chunk-6DATW7TB.mjs';
+export { CtxAudioPort, ORIGIN_QW, ORIGIN_QX, ORIGIN_QY, ORIGIN_QZ, ORIGIN_X, ORIGIN_Y, ORIGIN_Z, Particles, SILENT, SPAWN_B, SPAWN_END_B, SPAWN_END_G, SPAWN_END_R, SPAWN_G, SPAWN_LIFE, SPAWN_R, SPAWN_SIZE, SPAWN_SPIN, SPAWN_VX, SPAWN_VY, SPAWN_VZ, SPAWN_X, SPAWN_Y, SPAWN_Z, Spray, attachSurfaceInput, firstFrame } from '../../chunk-6DATW7TB.mjs';
+import { penaltyShootoutTemplate } from '../../chunk-K3HW5I2A.mjs';
+export { shootout_exports as shootout } from '../../chunk-K3HW5I2A.mjs';
+import { endlessRunnerTemplate } from '../../chunk-LIV3KXJG.mjs';
+export { CameraRig, LaneRunner, RUN_BEST, RUN_DISTANCE, RUN_SPEED, RUN_VY, RUN_X, RUN_Y, RUN_Z, runner_exports as runner } from '../../chunk-LIV3KXJG.mjs';
+export { writePosition, writeScale } from '../../chunk-GPS2THCL.mjs';
+export { ODDS_TOTAL_PPM, discloseOdds, effect, faucet, fixedOffer, grant, inWorldCurrency, premiumCurrency, premiumExchange, premiumItem, randomExchange, randomOffer, sink, softCurrency, softExchange, softItem, unlock } from '../../chunk-3DAD2LDF.mjs';
+export { HitStop, SHAKE_ROLL, SHAKE_X, SHAKE_Y, SHAKE_Z, ScreenShake } from '../../chunk-2UN4SFLR.mjs';
+export { ScreenFlash, Springs } from '../../chunk-A7MQSN2V.mjs';
+import { fiveASideTemplate } from '../../chunk-6DAEZKIG.mjs';
+export { PlanarSnapshotSync, SNAPSHOT_CHANNEL, five_a_side_exports as fiveASide } from '../../chunk-6DAEZKIG.mjs';
+import { ludoTemplate } from '../../chunk-A7V4L2IT.mjs';
+export { DEFAULT_TURN_LOG_CAPACITY, LocalTurnRoom, NO_WINNER, TURN_PASS_ACTION, TurnGame, ludo_exports as ludo } from '../../chunk-A7V4L2IT.mjs';
+export { KitError } from '../../chunk-4DYKAYFO.mjs';
+export { BOX_ROTATION, BOX_SX, BOX_SY, BOX_SZ, BOX_X, BOX_Y, BOX_Z, BoxBatch, addSceneCamera } from '../../chunk-QDYFLATW.mjs';
+export { createTemplateHarness, digestFloats, digestInts, templateFrameStamp } from '../../chunk-KGHJH5KJ.mjs';
+import { compileThing, ThingError } from '../../chunk-W65JIRI4.mjs';
+export { BUTTON_MIDDLE, BUTTON_PRIMARY, BUTTON_SECONDARY, CELL_ROAD, CELL_SOLID, CELL_TAKEN, CLOSE_SEGMENTS, CROWD_VOTE_BYTES, CROWD_VOTE_TAG, CSG_EPSILON, CameraPose, CheerMeter, CsgPlane, CsgPolygon, DEFAULT_CELL, DEFAULT_PART_LENGTH, DEFAULT_PART_RADIUS, DEFAULT_PART_SIZE, DEFAULT_THING_MATERIAL, EFFECT_TRIANGLE_COST, FIT_HEADROOM, GROUND_AREA_UNIT, LAYER_COST, LIGHT_SHARE, LIGHT_TRIANGLES, MAX_THING_PARTS, MAX_VOTE_CHOICES, MAX_VOTE_INDEX, MEDIUM_TRIANGLES, MIDDLE_SEGMENTS, NO_VOTE_WINNER, OccupancyGrid, SCATTER_ATTEMPTS, SHOP_TAG, SMALL_PART_SHARE, THING_COMBINES, THING_EFFECTS, THING_MATERIALS, THING_MIRRORS, THING_SHAPE_KINDS, TIER_BUDGET, ThingError, VotePoll, applyGround, buildWorld, checkWorld, colliderOf, compileThing, csg, decodeVote, encodeVote, fewerPeople, flatPart, footprintOf, frameDamping, giftMoments, gridOf, heavyWithoutPeople, layerCounts, lighten, markPlacement, massOf, partOfFlat, peopleForTier, peopleOn, phoneCost, rotationMatrix, scatter, shapeFaces, shapeOfFlat, shapePolygons, shapeRadius, simplifyStroke, thingBreaks, thingMaterial, thingMaterialIds, verdict, votesOpenedBy, walkFrom, worldWeight } from '../../chunk-W65JIRI4.mjs';
+export { CHAR_AIR_SECONDS, CHAR_BUFFER, CHAR_COYOTE, CHAR_CROUCH, CHAR_GROUND_NX, CHAR_GROUND_NY, CHAR_GROUND_NZ, CHAR_HEADING, CHAR_LANDING_SPEED, CHAR_MOVE_MAGNITUDE, CHAR_MOVE_X, CHAR_MOVE_Z, CHAR_PLATFORM_VX, CHAR_PLATFORM_VY, CHAR_PLATFORM_VZ, CHAR_SPEED, CHAR_SPEED_NORMALIZED, CHAR_VX, CHAR_VY, CHAR_VZ, CONTACT_LOCKED, CONTACT_LOCK_BLEND, CONTACT_LOCK_X, CONTACT_LOCK_Y, CONTACT_LOCK_Z, CONTACT_PLANTED, CONTACT_WEIGHT, CharacterMotor, ClipEventReader, DEFAULT_CLIP_EVENT_CAPACITY, DEFAULT_FOOT_UP, DEFAULT_GAMEPAD_LOOK_SPEED, DEFAULT_LOOK_SENSITIVITY, DEFAULT_MAX_FOOT_TILT, FOLLOW_CAMERA_X, FOLLOW_CAMERA_Y, FOLLOW_CAMERA_Z, FOLLOW_CLOSENESS, FOLLOW_DISTANCE, FOLLOW_FOV, FOLLOW_PITCH, FOLLOW_PIVOT_X, FOLLOW_PIVOT_Y, FOLLOW_PIVOT_Z, FOLLOW_SHOULDER, FOLLOW_YAW, FollowCamera, FootContact, MAX_TOUCH_BUTTONS, MOVE_IN_X, MOVE_IN_Y, MOVE_IO_MAGNITUDE, MOVE_IO_WORDS, MOVE_IO_X, MOVE_IO_Z, MOVE_OUT_X, MOVE_OUT_Z, ROOT_IO_DX, ROOT_IO_DZ, ROOT_IO_YAW, STICK_AIM, STICK_CURVE, STICK_DEAD_ZONE, STICK_DX, STICK_DY, STICK_IO_WORDS, STICK_MAGNITUDE, STICK_MOVE, STICK_OUT_WORDS, STICK_RADIUS, STICK_X, STICK_Y, TouchControls, createFootTiltChain, followOrigin, followOriginInto, shapeStick, shapeStickInto, touchLayout } from '../../chunk-ECDK6QBF.mjs';
+export { BOOM_DISTANCE, BOOM_DX, BOOM_DY, BOOM_DZ, BOOM_FREE, BOOM_IO_WORDS, BOOM_OX, BOOM_OY, BOOM_OZ, CameraBoom, DEFAULT_BOOM_RADIUS, LensDriver, POSE_PITCH, POSE_X, POSE_Y, POSE_YAW, POSE_Z, interpolatedPosition, placeCamera, wrapAngle, yawOfQuat } from '../../chunk-Y2EMGN4T.mjs';
+import '../../chunk-UCEPNO6N.mjs';
+import '../../chunk-IRVFYAKP.mjs';
+import '../../chunk-R56P64LB.mjs';
+import '../../chunk-GHPUYD4I.mjs';
+import { STARTER_CATALOGUE } from '../../chunk-TJCAE7RC.mjs';
+import '../../chunk-2LHLG4OB.mjs';
+import { createPreparedBackend, createEngineBackend } from '../../chunk-AGV33FWC.mjs';
+import '../../chunk-BBGKQIJJ.mjs';
+import '../../chunk-3ZYSAW2T.mjs';
+import '../../chunk-NPSYB6DC.mjs';
+import '../../chunk-RQXN5A34.mjs';
+export { IdentityFitter, identityCapturePolicy, identityFromCapture } from '../../chunk-KK6HYVBI.mjs';
+export { REPLAY_FORMAT_VERSION, ReplayClipRecorder, decodeReplay, encodeReplay, playFromReplay, simulateReplay, stateDigest } from '../../chunk-DDJLDOUX.mjs';
+import { attachDomInput } from '../../chunk-HMWYTXCY.mjs';
+import { createGame } from '../../chunk-KVFNRJOR.mjs';
+import '../../chunk-KDTVOLHI.mjs';
+import '../../chunk-RM2V4IND.mjs';
+import '../../chunk-22BD3RHN.mjs';
+import '../../chunk-ME6HGG4I.mjs';
+import '../../chunk-5BYDGGWO.mjs';
+import { EngineGraphics } from '../../chunk-Y65LXQGA.mjs';
+import '../../chunk-7ARSJPV3.mjs';
+import '../../chunk-7BHW5GTC.mjs';
+import '../../chunk-RUVGVNOF.mjs';
+import '../../chunk-HF5HPS4T.mjs';
+import '../../chunk-XPG3N5CF.mjs';
+import '../../chunk-KIZOA5LX.mjs';
+import '../../chunk-7SXOHAIR.mjs';
+import '../../chunk-ATAWRACV.mjs';
+import '../../chunk-T3AFF3L7.mjs';
+import '../../chunk-TL2SVO4P.mjs';
+import { FRAME_SECONDS_SLOT, FRAME_NOW_MS_SLOT } from '../../chunk-IDLW4NWA.mjs';
+import '../../chunk-3GXH2NFD.mjs';
+export { ENGINE_RAGDOLL_POLICY_EXPORT_NAMES, POLICY_ACTION_MODES, POLICY_DRIVE_PRESETS, RagdollPolicies, RagdollPolicy, policyActionSize, policyObservationSize } from '../../chunk-PRSR4FAV.mjs';
+import '../../chunk-TM63CYGN.mjs';
+import '../../chunk-X6CN6KQF.mjs';
+import '../../chunk-73SGZLAQ.mjs';
+import '../../chunk-M5EXQZYY.mjs';
+import '../../chunk-TU5RYTYU.mjs';
+import '../../chunk-3OY3VYNF.mjs';
+import '../../chunk-EIB4OWVQ.mjs';
+import '../../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 '../../chunk-JURRXY2J.mjs';
+import { bindEngineRuntime } from '../../chunk-GHS6MIL6.mjs';
+import '../../chunk-GDCV4IWO.mjs';
+import '../../chunk-Y66WVMO5.mjs';
+import '../../chunk-A33OORT7.mjs';
+export { IdentityCaptureError } from '../../chunk-5C3C7VDM.mjs';
+import '../../chunk-LYEZZEEF.mjs';
+import { sendToStudio, onStudio } from '../../chunk-HAGEIC2L.mjs';
+import '../../chunk-K46SMZ66.mjs';
+import '../../chunk-PPF2BYFL.mjs';
+export { themeTokens as slotUiTheme } from '../../chunk-WLMINRC4.mjs';
+import { UiVectorPlay } from '../../chunk-RFVRPYR2.mjs';
+import '../../chunk-5YWN6H5Q.mjs';
+import '../../chunk-F6XRYEM3.mjs';
+import '../../chunk-OQRVEM56.mjs';
+import '../../chunk-SPCRQ6NO.mjs';
+import '../../chunk-V7ZRH3PY.mjs';
+import '../../chunk-GYLP6UG4.mjs';
+import '../../chunk-XJA2NGTI.mjs';
+import '../../chunk-2IC4H6OV.mjs';
+import '../../chunk-MOMOZEUM.mjs';
+import '../../chunk-N4RGGDEL.mjs';
+import { GameError } from '../../chunk-XJIHN3BY.mjs';
+import { base64Bytes } from '../../chunk-Z3A3AFVU.mjs';
+import { LAUNCH_ITEMS, LAUNCH_FILES } from '../../chunk-JKGTBMU7.mjs';
+export { LAUNCH_CLIPS, LAUNCH_FILES, LAUNCH_HAIR_STYLES, LAUNCH_ITEMS, LAUNCH_RIG } from '../../chunk-JKGTBMU7.mjs';
+import { parseIdentityBase, decodeIdentity } from '../../chunk-XD2PMH46.mjs';
+export { MONK_TONES, NEUTRAL_HAIR, NO_PART, catalogueHair, decodeIdentity, encodeIdentity, isCatalogueHair, monkTone, neutralIdentity, parseIdentityBase, snapTone, toneColour, toneFromColour } from '../../chunk-XD2PMH46.mjs';
+import '../../chunk-25T4JHEA.mjs';
+
+// src/game/kit/host/canvas-backend.ts
+var PREPARED_ENGINE = { kind: "prepared" }, PREPARED_PLATFORM = { engine: () => Promise.resolve(PREPARED_ENGINE) };
+async function canvasPlatformBackend(graphics, options = {}) {
+  let platform = await graphics.engine();
+  return platform.kind === "prepared" ? createPreparedBackend(options.prepared) : createEngineBackend(bindEngineRuntime(platform.runtime), options.engine);
+}
+
+// src/game/kit/host/warmup.ts
+var WARMUP_FRAMES = 4800, WARMUP_SLICE_MS = 4, WARMUP_SEED = 24301, WARMUP_FRAME_INTERVAL_MS = 1e3 / 120, WARMUP_SURFACE_PIXELS = 64;
+function warmupSurface() {
+  return typeof OffscreenCanvas != "function" ? null : { canvas: new OffscreenCanvas((64), (64)), width: (64), height: (64), pixelRatio: 1 };
+}
+var TEMPLATES = [
+  fiveASideTemplate,
+  penaltyShootoutTemplate,
+  endlessRunnerTemplate,
+  ludoTemplate,
+  wordPuzzleTemplate,
+  jollofTycoonTemplate,
+  danfoRouteTemplate,
+  courierTemplate
+];
+function warmupTemplateFor(sceneName) {
+  for (let i = 0; i < TEMPLATES.length; i++) if (TEMPLATES[i].id === sceneName) return TEMPLATES[i];
+  return null;
+}
+var yieldTask = () => new Promise((resolve) => setTimeout(resolve, 0)), TASK_CLOCK = { now: () => performance.now(), yield: yieldTask };
+function warmTemplate(template2, backend, clock = TASK_CLOCK, frames = (4800)) {
+  let cancelled = false;
+  return {
+    done: (async () => {
+      let game = await createGame({ backend: await backend(), seed: (24301), ui: null, surface: warmupSurface() }), scene = template2.scene(), bot = template2.bot();
+      game.addScene(scene), game.start(scene.name);
+      let frame = 0, now = clock.now();
+      try {
+        for (; frame < frames && !cancelled; ) {
+          let until = clock.now() + (4);
+          for (; frame < frames && clock.now() < until; )
+            bot.drive(scene, game, frame++), now += WARMUP_FRAME_INTERVAL_MS, game.clock[FRAME_NOW_MS_SLOT] = now, game.runFrame();
+          await clock.yield();
+        }
+      } finally {
+        game.dispose();
+      }
+      return frame;
+    })(),
+    cancel() {
+      cancelled = true;
+    }
+  };
+}
+
+// src/game/kit/host/canvas.ts
+var PIXEL_RATIO_CAP = 2, UNSUPPORTED = "unsupported_feature", NO_FRAME = 0;
+function animationFrames() {
+  let scope = globalThis;
+  return typeof scope.requestAnimationFrame == "function" && typeof scope.cancelAnimationFrame == "function" ? scope : null;
+}
+async function runNativeGame(ctx, options, runtime) {
+  let backend = options.backend ?? createEngineBackend(bindEngineRuntime(runtime), {
+    renderer: "cimplify",
+    attach: (render, attach) => ctx.graphics.attach_engine(render, { ...attach, pixel_ratio_cap: (2) })
+  }), game = await createGame({ backend, seed: options.seed, ui: options.ui ?? null, surface: null }).catch((error) => {
+    throw backend.graphics.dispose(), backend.physics.dispose(), backend.audio.dispose(), error;
+  }), surface = backend.graphics instanceof EngineGraphics ? backend.graphics.native : null;
+  if (surface === null)
+    throw game.dispose(), new GameError("unsupported_feature", "the host did not attach a native engine surface");
+  let detachInput = attachSurfaceInput(game.input, surface);
+  game.addScene(options.scene), game.start(options.scene.name);
+  let onFrame = options.onFrame ?? null, running = true, stopFrames = surface.on_frame((targetMs) => {
+    running && (onFrame?.(game, targetMs), game.clock[FRAME_NOW_MS_SLOT] = targetMs, game.runFrame());
+  }), pause = () => {
+    running = false;
+  }, resume = () => {
+    running = true;
+  }, listeners = [
+    ctx.lifecycle.on("hidden", pause),
+    ctx.lifecycle.on("suspend", pause),
+    ctx.lifecycle.on("visible", resume),
+    ctx.lifecycle.on("resume", resume)
+  ];
+  return ctx.on_dispose(() => {
+    running = false, stopFrames(), detachInput();
+    for (let i = 0; i < listeners.length; i++) listeners[i]();
+    game.dispose();
+  }), game;
+}
+function scheduler() {
+  let scope = globalThis;
+  if (typeof scope.requestAnimationFrame != "function" || typeof scope.cancelAnimationFrame != "function")
+    throw new Error("the canvas profile needs requestAnimationFrame");
+  return scope;
+}
+async function runWebGpuGame(ctx, options) {
+  if (options.backend !== void 0 || options.api === "webgl2") return null;
+  let platform = await ctx.graphics.engine();
+  if (platform.kind !== "engine" || !(ctx.graphics.features.apis.indexOf("webgpu") >= 0 && !!platform.runtime.gpu) && !platform.runtime.gl) return null;
+  try {
+    return await runNativeGame(ctx, options, platform.runtime);
+  } catch (error) {
+    if (error?.code === UNSUPPORTED) return null;
+    throw error;
+  }
+}
+async function runCanvasGame(ctx, options) {
+  if (animationFrames() === null) {
+    let platform = await ctx.graphics.engine();
+    if (platform.kind === "engine") return runNativeGame(ctx, options, platform.runtime);
+  }
+  let webgpu = await runWebGpuGame(ctx, options);
+  if (webgpu !== null) return webgpu;
+  let template2 = options.warmup === false ? null : warmupTemplateFor(options.scene.name), warming = null, surface = await ctx.graphics.acquire_surface({
+    api: options.api ?? "webgl2",
+    transparent: false,
+    pixel_ratio_cap: (2),
+    offscreen: false
+  }), game = await createGame({
+    backend: options.backend ?? await canvasPlatformBackend(ctx.graphics),
+    seed: options.seed,
+    ui: options.ui ?? null,
+    surface: { canvas: surface.canvas, width: surface.width, height: surface.height, pixelRatio: surface.pixel_ratio }
+  }), canvas = surface.canvas, detachInput = canvas instanceof HTMLCanvasElement ? attachDomInput(game.input, canvas, globalThis) : null, stopResize = surface.on_resize((width, height) => game.graphics.resize(width, height, surface.pixel_ratio));
+  game.addScene(options.scene), game.start(options.scene.name);
+  let frames = scheduler(), onFrame = options.onFrame ?? null, handle = (0), running = false, tick = (now) => {
+    running && (template2 !== null && warming === null && (warming = warmTemplate(template2, () => canvasPlatformBackend(ctx.graphics))), onFrame?.(game, now), game.clock[FRAME_NOW_MS_SLOT] = now, game.runFrame(), handle = frames.requestAnimationFrame(tick));
+  }, resume = () => {
+    running || (running = true, handle = frames.requestAnimationFrame(tick));
+  }, pause = () => {
+    running = false, handle !== (0) && frames.cancelAnimationFrame(handle), handle = (0);
+  }, listeners = [
+    ctx.lifecycle.on("hidden", pause),
+    ctx.lifecycle.on("suspend", pause),
+    ctx.lifecycle.on("visible", resume),
+    ctx.lifecycle.on("resume", resume),
+    ctx.graphics.on_context_lost(pause),
+    ctx.graphics.on_context_restored(resume)
+  ];
+  return ctx.on_dispose(() => {
+    warming?.cancel(), pause();
+    for (let i = 0; i < listeners.length; i++) listeners[i]();
+    stopResize(), detachInput?.(), game.dispose(), surface.release();
+  }), resume(), game;
+}
+
+// src/game/kit/viewers/place-viewer-main.ts
+var PLACE_DOC_BINDING = "doc", PLACE_TIER_BINDING = "tier", PLACE_CAMERA_BINDING = "camera", TIERS = ["low", "mid", "high"], CAMERAS = ["walk", "orbit"];
+function valueOf(values, binding) {
+  return values?.find((entry) => entry.binding === binding)?.value;
+}
+function isWorldDoc(value) {
+  if (typeof value != "object" || value === null) return false;
+  let doc = value;
+  return Array.isArray(doc.size) && Array.isArray(doc.scatters) && Array.isArray(doc.roads) && typeof doc.sky == "object";
+}
+function shownFrom(values) {
+  let doc = valueOf(values, PLACE_DOC_BINDING);
+  if (!isWorldDoc(doc)) return null;
+  let tier = valueOf(values, PLACE_TIER_BINDING);
+  return { doc, tier: TIERS.includes(tier) ? tier : "high" };
+}
+function cameraFrom(values) {
+  let camera = valueOf(values, PLACE_CAMERA_BINDING);
+  return CAMERAS.includes(camera) ? camera : null;
+}
+async function crowdCharacter(ctx) {
+  if (ctx.assets.has?.(CROWD_CHARACTER_ASSET) === false) return null;
+  try {
+    return (await ctx.assets.take(CROWD_CHARACTER_ASSET)).slice().buffer;
+  } catch {
+    return null;
+  }
+}
+async function placeViewer(ctx) {
+  let scene = new PlaceViewerScene(null, STARTER_CATALOGUE, await crowdCharacter(ctx));
+  ctx.ui.on_event((event) => {
+    if (event.action === PLACE_VIEWER_SET) {
+      let shown = shownFrom(event.values);
+      shown !== null && scene.show(shown);
+      return;
+    }
+    if (event.action === PLACE_VIEWER_CAMERA) {
+      let camera = cameraFrom(event.values);
+      camera !== null && scene.setCamera(camera);
+    }
+  }), await runCanvasGame(ctx, { scene }), ctx.program.ready(), await scene.ready();
+}
+
+// src/game/kit/viewers/draft-player-main.ts
+var DRAFT_ASSET = "assets/core/studio/draft.json", STUDIO_TEST_GIFT = "studio.test_gift", STUDIO_GIFT_BINDING = "gift", DRAFT_FORMAT = 1, SHOWCASE_SIZE = [30, 30], decoder = new TextDecoder();
+function liveOf(value) {
+  if (typeof value != "object" || value === null) return null;
+  let live = value;
+  return !Array.isArray(live.bindings) || live.music === void 0 || live.crowd === void 0 ? null : { bindings: live.bindings, music: live.music, crowd: live.crowd };
+}
+function readDraftFile(bytes) {
+  try {
+    let value = JSON.parse(decoder.decode(bytes));
+    return value.format !== (1) || typeof value.title != "string" ? null : {
+      format: (1),
+      title: value.title,
+      kind: typeof value.kind == "string" ? value.kind : "game",
+      place: value.place ?? null,
+      things: Array.isArray(value.things) ? value.things : [],
+      live: liveOf(value.live)
+    };
+  } catch {
+    return null;
+  }
+}
+function showcaseWorld(draft) {
+  return draft.place !== null ? draft.place : {
+    ...emptyWorld(draft.title, SHOWCASE_SIZE),
+    gates: [[SHOWCASE_SIZE[0] / 2, SHOWCASE_SIZE[1] / 2]]
+  };
+}
+var BREAK_PIECES = 16, BREAK_EFFECT = "break", SEED_PRIME = 16777619, SEED_BASIS = 2166136261;
+function bakedThings(things) {
+  let out = [];
+  for (let thing of things)
+    try {
+      let compiled = compileThing(thing);
+      out.push({ thing, compiled, glb: bakeThingGlb(compiled, thing.name) });
+    } catch (error) {
+      if (!(error instanceof ThingError)) throw error;
+    }
+  return out;
+}
+function breaks(thing) {
+  return thing.effects.some((effect2) => effect2.kind === BREAK_EFFECT);
+}
+function seedOf(name) {
+  let hash = (2166136261);
+  for (let i = 0; i < name.length; i++)
+    hash = Math.imul(hash ^ name.charCodeAt(i), (16777619)) >>> 0;
+  return hash;
+}
+async function brokenThing(game, baked) {
+  let port = game.backend.destruction;
+  if (!breaks(baked.thing) || port?.fracture === void 0) return null;
+  let mesh = baked.compiled.levels[0].mesh;
+  try {
+    let result = port.fracture(
+      { positions: mesh.positions, normals: mesh.normals, indices: mesh.indices },
+      { pieces: (16), seed: seedOf(baked.thing.name) }
+    );
+    return { model: await game.graphics.loadModel({ bytes: result.model.slice().buffer }), fracture: result.asset };
+  } catch {
+    return null;
+  }
+}
+function draftSounds(draft) {
+  let out = /* @__PURE__ */ new Set(), live = draft.live;
+  if (live !== null) {
+    for (let stem of live.music.stems) stem.sound.length > 0 && out.add(stem.sound);
+    for (let cue of live.music.cues) cue.sound.length > 0 && out.add(cue.sound);
+  }
+  for (let thing of draft.things)
+    for (let effect2 of thing.effects) effect2.sound && out.add(effect2.sound);
+  return [...out];
+}
+var DraftScene = class {
+  constructor(place) {
+    this.place = place;
+    this.name = "studio-draft";
+    this.live = null;
+    this.ui = null;
+    this.things = [];
+    this.broken = [];
+    this.sounds = /* @__PURE__ */ new Map();
+    this.effects = [];
+    this.effectsFor = -1;
+  }
+  attachLive(live, ui) {
+    this.live = live, this.ui = ui;
+  }
+  attachThings(things, sounds, broken = []) {
+    this.things = things, this.sounds = sounds, this.broken = broken, this.effectsFor = -1;
+  }
+  enter(game) {
+    this.place.enter(game);
+  }
+  exit() {
+    this.disposeEffects(), this.place.exit();
+  }
+  fixedUpdate(game) {
+    for (let effects of this.effects) effects.fixedUpdate(game);
+  }
+  disposeEffects() {
+    for (let effects of this.effects) effects.dispose();
+    this.effects = [];
+  }
+  syncEffects(game) {
+    if (this.effectsFor === this.place.shownVersion) return;
+    this.effectsFor = this.place.shownVersion, this.disposeEffects();
+    let camera = this.place.cameraEntity, shown = this.place.thingsShown;
+    if (camera !== null)
+      for (let i = 0; i < shown.length && i < this.things.length; i++) {
+        let thing = this.things[i];
+        if (thing.effects.length === 0) continue;
+        let effects = new ThingEffects(game, shown[i], thing.effects, {
+          camera,
+          sounds: this.sounds,
+          broken: this.broken[i] ?? null
+        });
+        effects.play(), this.effects.push(effects);
+      }
+  }
+  update(game) {
+    this.place.update(game), this.syncEffects(game);
+    for (let effects of this.effects) effects.update(game);
+    let live = this.live;
+    live !== null && (live.frame({
+      seconds: game.clock[FRAME_SECONDS_SLOT],
+      tick: game.tick,
+      hour: this.place.hour,
+      people: this.place.people
+    }), this.ui?.flush());
+  }
+};
+async function optionalAsset(ctx, name) {
+  if (ctx.assets.has?.(name) === false) return null;
+  try {
+    return await ctx.assets.take(name);
+  } catch {
+    return null;
+  }
+}
+async function loadSounds(ctx, game, paths) {
+  let sounds = /* @__PURE__ */ new Map();
+  for (let path of paths) {
+    let bytes = await optionalAsset(ctx, path);
+    if (bytes !== null)
+      try {
+        sounds.set(path, await game.audio.load({ bytes: bytes.slice().buffer }));
+      } catch {
+        continue;
+      }
+  }
+  return sounds;
+}
+async function draftPlayer(ctx) {
+  let draft = readDraftFile(await ctx.assets.take(DRAFT_ASSET));
+  if (draft === null) throw new Error("this Interactive's draft could not be read");
+  let character = await optionalAsset(ctx, CROWD_CHARACTER_ASSET), place = new PlaceViewerScene(
+    { doc: showcaseWorld(draft), tier: ctx.graphics.features.device_tier },
+    STARTER_CATALOGUE,
+    character === null ? null : character.slice().buffer
+  );
+  place.setCamera("walk");
+  let scene = new DraftScene(place), game = await runCanvasGame(ctx, { scene }), sounds = await loadSounds(ctx, game, draftSounds(draft));
+  if (draft.live !== null) {
+    let ui = ctx.ui.game(), live = new LivePlayer(ui, draft.live, game.audio.conductor, sounds, 1 / game.stepSeconds);
+    scene.attachLive(live, ui), ctx.ui.on_event((event) => {
+      if (event.action !== STUDIO_TEST_GIFT) return;
+      let gift = event.values?.find((entry) => entry.binding === STUDIO_GIFT_BINDING)?.value;
+      typeof gift == "string" && live.gift(gift);
+    });
+  }
+  let baked = bakedThings(draft.things), broken = await Promise.all(baked.map((entry) => brokenThing(game, entry)));
+  scene.attachThings(
+    baked.map((entry) => entry.thing),
+    sounds,
+    broken
+  ), await place.setThings(baked.map((entry) => entry.glb)), ctx.program.ready(), await place.ready();
+}
+
+// src/game/kit/viewers/avatar-viewer.ts
+var AVATAR_VIEWER_SET = "avatar.set", AVATAR_VIEWER_TURN = "avatar.turn", MAX_TURN_RADIANS = Math.PI / 3, TURN_SPAN = 1, IDLE_CLIP = "idle", GESTURE_SECONDS = 2.4, ATTITUDE_CLIPS = {
+  neutral: null,
+  warm: "clap",
+  cool: "shrug",
+  playful: "wave"
+}, FRAMINGS = {
+  head: { target: 1.6, distance: 0.75 },
+  bust: { target: 1.45, distance: 1.25 },
+  full: { target: 0.9, distance: 3.4 }
+}, FOV = 30, NEAR = 0.05, FAR = 50, SUN_INTENSITY = 1.6, SKY_INTENSITY = 0.9, SUN_POSITION = [2, 4, 3], STUDIO_SKY = { hour: 15, weather: "clear", dayMinutes: 0 }, SPRING_RATE = Math.sqrt(90), SETTLED = 1e-4, FADE_SECONDS = 0.25, HALF = 0.5, AvatarViewerScene = class {
+  constructor(baseBytes, clipBytes) {
+    this.baseBytes = baseBytes;
+    this.clipBytes = clipBytes;
+    this.name = "avatar-viewer";
+    this.game = null;
+    this.base = null;
+    this.camera = null;
+    this.body = null;
+    this.node = null;
+    this.idle = null;
+    this.gesture = null;
+    this.gestureLeft = 0;
+    this.shown = null;
+    this.turning = new AvatarTurn();
+    this.turnInput = { down: false, released: false, dragX: 0 };
+    this.generation = 0;
+    this.arrivals = [];
+  }
+  get canDraw() {
+    return this.baseBytes !== null;
+  }
+  get turned() {
+    return this.turning.value;
+  }
+  enter(game) {
+    this.game = game;
+    let sun = game.world.spawn();
+    game.transforms.add(sun, SUN_POSITION[0], SUN_POSITION[1], SUN_POSITION[2]), game.graphics.create(sun, { kind: "light", light: "directional", intensity: (1.6) });
+    let sky = game.world.spawn();
+    game.transforms.add(sky), game.graphics.create(sky, { kind: "light", light: "hemisphere", intensity: (0.9) });
+    let camera = game.world.spawn();
+    game.transforms.add(camera), game.graphics.camera(camera, (30), (0.05), (50)), this.camera = camera, applySky(game.graphics, STUDIO_SKY, 0), this.shown !== null && this.show(this.shown);
+  }
+  exit() {
+    this.clear(), this.game = null;
+  }
+  shownOnce() {
+    return this.node !== null ? Promise.resolve() : new Promise((resolve) => this.arrivals.push(resolve));
+  }
+  show(shown) {
+    this.shown = shown;
+    let game = this.game;
+    if (game === null || this.baseBytes === null) return;
+    this.frame(shown.framing);
+    let glb;
+    try {
+      this.base ?? (this.base = parseIdentityBase(this.baseBytes)), glb = buildIdentityCharacter(this.base, decodeIdentity(shown.identity));
+    } catch {
+      return;
+    }
+    let generation = ++this.generation;
+    game.graphics.loadModel({ bytes: glb.slice().buffer }).then(
+      (info) => {
+        generation !== this.generation || this.game === null || this.place(this.game, info.id);
+      },
+      () => {
+      }
+    );
+  }
+  setTurn(turn) {
+    this.turning.set(turn);
+  }
+  frame(framing) {
+    let game = this.game, camera = this.camera;
+    if (game === null || camera === null) return;
+    let view = FRAMINGS[framing];
+    game.transforms.setPosition(camera, 0, view.target, view.distance);
+  }
+  place(game, model) {
+    this.clear();
+    let body = game.world.spawn();
+    game.transforms.add(body), this.body = body;
+    let node = game.graphics.instantiate(body, model);
+    this.node = node, this.applyTurn(game), this.clipBytes !== null && game.graphics.loadClips(node, { bytes: this.clipBytes }).then(
+      (names) => {
+        this.node === node && this.animate(game, node, names);
+      },
+      () => {
+      }
+    );
+    for (let arrived of this.arrivals.splice(0)) arrived();
+  }
+  animate(game, node, names) {
+    let shown = this.shown;
+    if (shown === null || shown.still) return;
+    names.includes(IDLE_CLIP) && (this.idle = game.graphics.playClip(node, IDLE_CLIP, true, 0));
+    let gesture = ATTITUDE_CLIPS[shown.attitude];
+    gesture === null || !names.includes(gesture) || (this.gesture = game.graphics.playClip(node, gesture, false, (0.25)), this.gestureLeft = (2.4), this.idle !== null && game.graphics.setClipWeight(this.idle, 0));
+  }
+  clear() {
+    let game = this.game;
+    game !== null && this.body !== null && game.world.despawn(this.body), this.body = null, this.node = null, this.idle = null, this.gesture = null, this.gestureLeft = 0;
+  }
+  applyTurn(game) {
+    if (this.body === null) return;
+    let yaw = this.turning.value * MAX_TURN_RADIANS;
+    game.transforms.setRotation(this.body, 0, Math.sin(yaw * (0.5)), 0, Math.cos(yaw * (0.5)));
+  }
+  update(game) {
+    let seconds = game.clock[FRAME_SECONDS_SLOT], frame = game.input.frame;
+    this.turnInput.down = game.input.pointer.down, this.turnInput.released = frame.released, this.turnInput.dragX = frame.drag.x, this.turning.frame(this.turnInput, seconds, this.shown?.still === true), this.applyTurn(game), this.gesture !== null && (this.gestureLeft -= seconds, this.gestureLeft <= 0 && (this.idle !== null && game.graphics.setClipWeight(this.idle, 1), this.gesture = null));
+  }
+}, AvatarTurn = class {
+  constructor() {
+    this.turn = 0;
+    this.velocity = 0;
+  }
+  get value() {
+    return this.turn;
+  }
+  set(turn) {
+    this.turn = clampTurn(turn), this.velocity = 0;
+  }
+  frame(input, seconds, still) {
+    if (input.down || input.released) {
+      this.turn = clampTurn(this.turn + input.dragX / (1)), this.velocity = 0;
+      return;
+    }
+    if (this.turn === 0 && this.velocity === 0) return;
+    if (still) {
+      this.turn = 0, this.velocity = 0;
+      return;
+    }
+    let decay = Math.exp(-SPRING_RATE * seconds), lead = this.velocity + SPRING_RATE * this.turn;
+    this.turn = (this.turn + lead * seconds) * decay, this.velocity = (this.velocity - SPRING_RATE * lead * seconds) * decay, Math.abs(this.turn) < (1e-4) && Math.abs(this.velocity) < (1e-4) && (this.turn = 0, this.velocity = 0);
+  }
+};
+function clampTurn(turn) {
+  return Math.max(-1, Math.min(1, turn));
+}
+
+// src/game/kit/viewers/avatar-viewer-main.ts
+var AVATAR_IDENTITY_ASSET = `content/${LAUNCH_ITEMS.identity}/${LAUNCH_FILES.identity}`, AVATAR_CLIPS_ASSET = `content/${LAUNCH_ITEMS.animations}/${LAUNCH_FILES.animations}`, AVATAR_IDENTITY_BINDING = "identity", AVATAR_ATTITUDE_BINDING = "attitude", AVATAR_FRAMING_BINDING = "framing", AVATAR_STILL_BINDING = "still", AVATAR_TURN_BINDING = "turn", ATTITUDES = ["neutral", "warm", "cool", "playful"], FRAMINGS2 = ["head", "bust", "full"];
+function valueOf2(values, binding) {
+  return values?.find((entry) => entry.binding === binding)?.value;
+}
+function avatarShownFrom(values) {
+  let identity = valueOf2(values, AVATAR_IDENTITY_BINDING);
+  if (typeof identity != "string" || identity.length === 0) return null;
+  let attitude = valueOf2(values, AVATAR_ATTITUDE_BINDING), framing = valueOf2(values, AVATAR_FRAMING_BINDING);
+  return {
+    identity: base64Bytes(identity),
+    attitude: ATTITUDES.find((entry) => entry === attitude) ?? "neutral",
+    framing: FRAMINGS2.find((entry) => entry === framing) ?? "bust",
+    still: valueOf2(values, AVATAR_STILL_BINDING) === true
+  };
+}
+async function asset(ctx, name) {
+  if (ctx.assets.has?.(name) === false) return null;
+  try {
+    return new Uint8Array(await ctx.assets.take(name));
+  } catch {
+    return null;
+  }
+}
+async function avatarViewer(ctx) {
+  let [base, clips] = await Promise.all([
+    asset(ctx, AVATAR_IDENTITY_ASSET),
+    asset(ctx, AVATAR_CLIPS_ASSET)
+  ]), scene = new AvatarViewerScene(base, clips === null ? null : clips.buffer);
+  ctx.ui.on_event((event) => {
+    if (event.action === AVATAR_VIEWER_SET) {
+      let shown = avatarShownFrom(event.values);
+      shown !== null && scene.show(shown);
+      return;
+    }
+    if (event.action === AVATAR_VIEWER_TURN) {
+      let turn = valueOf2(event.values, AVATAR_TURN_BINDING);
+      typeof turn == "number" && Number.isFinite(turn) && scene.setTurn(turn);
+    }
+  }), await runCanvasGame(ctx, { scene }), openDesigner(ctx, scene), scene.canDraw && (await scene.shownOnce(), ctx.program.ready());
+}
+var DESIGN_SHOWN = { attitude: "neutral", framing: "full", still: false };
+function openDesigner(ctx, scene) {
+  ctx.graphics.engine().then((platform) => {
+    let runtime = platform.kind === "engine" ? bindEngineRuntime(platform.runtime) : null, exports = runtime === null ? null : engineAvatarExports(runtime);
+    if (runtime === null || exports === null) {
+      sendToStudio({ topic: AVATAR_DESIGN_REPORT.ready, body: { designing: false, schema: null } });
+      return;
+    }
+    let session = new AvatarDesignSession({
+      open: (file) => new AvatarDesigner(runtime, exports, file),
+      send: (message) => {
+        sendToStudio(message);
+      },
+      show: (identity) => scene.show({ identity, ...DESIGN_SHOWN })
+    });
+    ctx.on_dispose(() => session.close()), onStudio((message) => session.handle(message)), sendToStudio({
+      topic: AVATAR_DESIGN_REPORT.ready,
+      body: { designing: true, schema: AvatarDesigner.schema(runtime, exports) }
+    });
+  });
+}
+
+// src/game/vector/author.ts
+var AUTHOR_REGISTER_WORDS = 8, AUTHOR_ITEMS = 0, AUTHOR_CAN_UNDO = 1, AUTHOR_CAN_REDO = 2;
+var AUTHOR_FAILED_ITEM = 4, AUTHOR_FAILED_KEY = 5, AUTHOR_ITEM_WORDS = 6, AUTHOR_VALUE_WORDS = 2, AUTHOR_NONE = 4294967295, AUTHOR_KINDS = ["uint", "int", "float", "color", "bool", "ref", "str", "bytes"], ENGINE_VECTOR_AUTHOR_EXPORT_NAMES = [
+  "engine_vector_author_open",
+  "engine_vector_author_close",
+  "engine_vector_author_registers",
+  "engine_vector_author_item",
+  "engine_vector_author_prop",
+  "engine_vector_author_prop_bytes",
+  "engine_vector_author_set",
+  "engine_vector_author_set_bytes",
+  "engine_vector_author_unset",
+  "engine_vector_author_insert",
+  "engine_vector_author_add",
+  "engine_vector_author_remove",
+  "engine_vector_author_add_asset",
+  "engine_vector_author_add_artboard",
+  "engine_vector_author_bind",
+  "engine_vector_author_json",
+  "engine_vector_author_edit_json",
+  "engine_vector_author_result",
+  "engine_vector_author_checkpoint",
+  "engine_vector_author_undo",
+  "engine_vector_author_redo",
+  "engine_vector_author_write",
+  "engine_vector_author_bake"
+];
+var NULL = 0, BYTE_ALIGN = 1, WORD_BYTES = 4, UNKNOWN = -3, CONTENDED = -6, WORD_BITS = 32n, WORD_MASK = 0xffffffffn, SCRATCH_WORDS = 8, ENGINE_VECTOR_AUTHOR_SCHEMA_EXPORT = "engine_vector_author_schema";
+function vectorAuthorSchema(runtime) {
+  let call = runtime.symbols[ENGINE_VECTOR_AUTHOR_SCHEMA_EXPORT];
+  if (typeof call != "function") return null;
+  let schema = call, length = schema((0), 0);
+  if (length <= 0) return null;
+  let at = runtime.exports.engine_alloc(length, (1));
+  if (at === (0)) return null;
+  try {
+    return schema(at, length) !== length ? null : JSON.parse(new TextDecoder().decode(new Uint8Array(runtime.memory.buffer, at, length).slice()));
+  } finally {
+    runtime.exports.engine_free(at, length, (1));
+  }
+}
+function engineVectorAuthorExports(runtime) {
+  let symbols = runtime.symbols;
+  return ENGINE_VECTOR_AUTHOR_EXPORT_NAMES.every((name) => typeof symbols[name] == "function") ? symbols : null;
+}
+function optional(word) {
+  return word === (4294967295) ? null : word;
+}
+var VectorAuthor = class {
+  constructor(runtime, exports, file) {
+    this.runtime = runtime;
+    this.exports = exports;
+    this.encoder = new TextEncoder();
+    this.decoder = new TextDecoder();
+    this.closed = false;
+    let at = this.alloc(Math.max(file.length, 1), (1));
+    try {
+      new Uint8Array(runtime.memory.buffer).set(file, at), this.handle = exports.engine_vector_author_open(at, file.length);
+    } finally {
+      runtime.exports.engine_free(at, Math.max(file.length, 1), (1));
+    }
+    if (this.handle === (0)) throw new GameError("invalid_argument", "the engine could not open that vector file for editing");
+    this.scratch = this.alloc((8) * (4), (4));
+  }
+  alloc(bytes, align) {
+    let at = this.runtime.exports.engine_alloc(bytes, align);
+    if (at === (0)) throw new GameError("capacity_exceeded", "engine memory cannot hold the vector file");
+    return at;
+  }
+  live() {
+    if (this.closed) throw new GameError("unknown_resource", "this vector document was closed");
+    return this.handle;
+  }
+  registers() {
+    return new Uint32Array(this.runtime.memory.buffer, this.exports.engine_vector_author_registers(this.live()), (8));
+  }
+  check(code, what) {
+    if (code >= 0) return code;
+    let r = this.registers(), where = ` (item ${optional(r[(4)]) ?? "none"}, property ${optional(r[(5)]) ?? "none"})`;
+    throw code === (-3) ? new GameError("unknown_resource", `the ${what} names nothing in this document${where}`) : code === (-6) ? new GameError("invalid_argument", `the ${what} would break a reference the document still holds${where}`) : new GameError("invalid_argument", `the engine refused the ${what}${where}`);
+  }
+  get length() {
+    return this.registers()[(0)];
+  }
+  get canUndo() {
+    return this.registers()[(1)] !== 0;
+  }
+  get canRedo() {
+    return this.registers()[(2)] !== 0;
+  }
+  get refused() {
+    let r = this.registers();
+    return { item: optional(r[(4)]), property: optional(r[(5)]) };
+  }
+  item(index) {
+    this.check(this.exports.engine_vector_author_item(this.live(), index, this.scratch), "item");
+    let w = new Uint32Array(this.runtime.memory.buffer, this.scratch, (6));
+    return { id: w[0], type: w[1], props: w[2], owner: optional(w[3]), artboard: optional(w[4]), parent: optional(w[5]) };
+  }
+  items() {
+    let out = [];
+    for (let i = 0; i < this.length; i++) out.push(this.item(i));
+    return out;
+  }
+  prop(id, key) {
+    let code = this.exports.engine_vector_author_prop(this.live(), id, key, this.scratch);
+    if (code === (-3)) return null;
+    let kind = AUTHOR_KINDS[this.check(code, "property")], w = new Uint32Array(this.runtime.memory.buffer, this.scratch, (2));
+    switch (kind) {
+      case "uint":
+        return { kind, value: BigInt(w[1]) << WORD_BITS | BigInt(w[0]) };
+      case "int":
+        return { kind, value: w[0] | 0 };
+      case "float":
+        return { kind, value: new Float32Array(w.buffer, w.byteOffset, 1)[0] };
+      case "color":
+      case "ref":
+        return { kind, value: w[0] };
+      case "bool":
+        return { kind, value: w[0] !== 0 };
+      case "str":
+      case "bytes": {
+        let bytes = this.bytes(id, key, w[0]);
+        return kind === "str" ? { kind, value: this.decoder.decode(bytes) } : { kind, value: bytes };
+      }
+      default:
+        throw new GameError("invalid_argument", "the engine returned an unknown property kind");
+    }
+  }
+  bytes(id, key, length) {
+    let at = this.alloc(Math.max(length, 1), (1));
+    try {
+      return this.check(this.exports.engine_vector_author_prop_bytes(this.live(), id, key, at, length), "property bytes"), new Uint8Array(this.runtime.memory.buffer, at, length).slice();
+    } finally {
+      this.runtime.exports.engine_free(at, Math.max(length, 1), (1));
+    }
+  }
+  set(id, key, value) {
+    let h = this.live();
+    if (value.kind === "str" || value.kind === "bytes") {
+      let data = value.kind === "str" ? this.encoder.encode(value.value) : value.value, at = this.alloc(Math.max(data.length, 1), (1));
+      try {
+        new Uint8Array(this.runtime.memory.buffer).set(data, at), this.check(this.exports.engine_vector_author_set_bytes(h, id, key, AUTHOR_KINDS.indexOf(value.kind), at, data.length), "property");
+      } finally {
+        this.runtime.exports.engine_free(at, Math.max(data.length, 1), (1));
+      }
+      return;
+    }
+    let lo = 0, hi = 0;
+    if (value.kind === "uint")
+      lo = Number(value.value & WORD_MASK), hi = Number(value.value >> WORD_BITS & WORD_MASK);
+    else if (value.kind === "bool")
+      lo = value.value ? 1 : 0;
+    else if (value.kind === "float") {
+      let word = new Uint32Array(1);
+      new Float32Array(word.buffer)[0] = value.value, lo = word[0];
+    } else
+      lo = value.value >>> 0;
+    this.check(this.exports.engine_vector_author_set(h, id, key, AUTHOR_KINDS.indexOf(value.kind), lo, hi), "property");
+  }
+  unset(id, key) {
+    this.check(this.exports.engine_vector_author_unset(this.live(), id, key), "property");
+  }
+  insert(parent, type, before = null) {
+    return this.check(this.exports.engine_vector_author_insert(this.live(), parent, type, before ?? (4294967295)), "insert");
+  }
+  add(owner, type, frame = null) {
+    return this.check(this.exports.engine_vector_author_add(this.live(), owner, type, frame ?? (4294967295)), "add");
+  }
+  addAsset(type, contents = null) {
+    let h = this.live();
+    if (contents === null) return this.check(this.exports.engine_vector_author_add_asset(h, type, (0), 0), "asset");
+    let at = this.alloc(Math.max(contents.length, 1), (1));
+    try {
+      return new Uint8Array(this.runtime.memory.buffer).set(contents, at), this.check(this.exports.engine_vector_author_add_asset(h, type, at, contents.length), "asset");
+    } finally {
+      this.runtime.exports.engine_free(at, Math.max(contents.length, 1), (1));
+    }
+  }
+  addArtboard() {
+    return this.check(this.exports.engine_vector_author_add_artboard(this.live()), "artboard");
+  }
+  bind(target, type) {
+    return this.check(this.exports.engine_vector_author_bind(this.live(), target, type), "bind");
+  }
+  later(name) {
+    let call = this.runtime.symbols[name];
+    if (typeof call != "function") throw new GameError("unsupported_feature", `this engine does not have ${name}`);
+    return call;
+  }
+  supports(name) {
+    return typeof this.runtime.symbols[name] == "function";
+  }
+  addViewModel() {
+    return this.check(this.later("engine_vector_author_add_view_model")(this.live()), "view model");
+  }
+  addViewModelProperty(viewModel, type) {
+    return this.check(this.later("engine_vector_author_add_view_model_property")(this.live(), viewModel, type), "view model property");
+  }
+  addViewModelInstance(viewModel) {
+    return this.check(this.later("engine_vector_author_add_view_model_instance")(this.live(), viewModel), "view model instance");
+  }
+  hit(artboard, x, y) {
+    return this.check(this.later("engine_vector_author_hit")(this.live(), artboard, x, y), "hit test");
+  }
+  remove(id) {
+    return this.check(this.exports.engine_vector_author_remove(this.live(), id), "removal");
+  }
+  checkpoint() {
+    this.check(this.exports.engine_vector_author_checkpoint(this.live()), "checkpoint");
+  }
+  undo() {
+    return this.check(this.exports.engine_vector_author_undo(this.live()), "undo") === 1;
+  }
+  redo() {
+    return this.check(this.exports.engine_vector_author_redo(this.live()), "redo") === 1;
+  }
+  output(call, what) {
+    let length = this.check(call((0), 0), what), at = this.alloc(Math.max(length, 1), (1));
+    try {
+      return this.check(call(at, length), what), new Uint8Array(this.runtime.memory.buffer, at, length).slice();
+    } finally {
+      this.runtime.exports.engine_free(at, Math.max(length, 1), (1));
+    }
+  }
+  json() {
+    return this.decoder.decode(this.output((out, capacity) => this.exports.engine_vector_author_json(this.live(), out, capacity), "document listing"));
+  }
+  editJson(ops) {
+    let data = this.encoder.encode(ops), at = this.alloc(Math.max(data.length, 1), (1));
+    try {
+      new Uint8Array(this.runtime.memory.buffer).set(data, at), this.check(this.exports.engine_vector_author_edit_json(this.live(), at, data.length), "edit");
+    } finally {
+      this.runtime.exports.engine_free(at, Math.max(data.length, 1), (1));
+    }
+    let result = this.decoder.decode(this.output((out, capacity) => this.exports.engine_vector_author_result(this.live(), out, capacity), "edit result"));
+    return JSON.parse(result).created;
+  }
+  write() {
+    return this.output((out, capacity) => this.exports.engine_vector_author_write(this.live(), out, capacity), "write");
+  }
+  bake() {
+    return this.output((out, capacity) => this.exports.engine_vector_author_bake(this.live(), out, capacity), "bake");
+  }
+  close() {
+    this.closed || (this.closed = true, this.exports.engine_vector_author_close(this.handle), this.runtime.exports.engine_free(this.scratch, (8) * (4), (4)));
+  }
+};
+
+// src/game/kit/viewers/vector-viewer-main.ts
+var VECTOR_BACKDROP = "#26262b", NO_ASSET = 0, ORIGIN = [0, 0], VectorStage = class {
+  constructor(ui) {
+    this.ui = ui;
+    this.asset = (0);
+    this.element = null;
+    this.shown = null;
+    this.playing = null;
+    this.sought = null;
+  }
+  get loaded() {
+    return this.asset;
+  }
+  draw(file) {
+    let previous = this.asset, next = previous + 1;
+    this.ui.loadVector(next, file), this.asset = next;
+    let artboard = this.shown?.artboard ?? 0;
+    if (this.element === null) {
+      let backdrop = this.ui.box().style({ width: "100%", height: "100%", fill: VECTOR_BACKDROP, pointerEvents: "none" });
+      this.element = this.ui.vector(next, artboard).style({ position: "absolute", pointerEvents: "none", origin: ORIGIN }), backdrop.append(this.element), this.ui.root(backdrop);
+    } else
+      this.element.vector(next, artboard);
+    previous !== (0) && this.ui.unloadVector(previous), this.place(), this.replay();
+  }
+  show(show) {
+    let artboard = this.shown?.artboard ?? 0;
+    this.shown = show, this.element !== null && (show.artboard !== artboard && (this.element.vector(this.asset, show.artboard), this.replay()), this.place());
+  }
+  play(play) {
+    this.playing = play.kind === "stop" ? null : play, this.sought = null, this.element !== null && (play.kind === "stop" ? this.element.play(UiVectorPlay.stop, 0) : this.replay());
+  }
+  seek(seek) {
+    this.sought = seek, this.playing = null, this.replay();
+  }
+  input(input) {
+    this.element?.setInput(input.name, input.value);
+  }
+  place() {
+    let view = this.shown?.view;
+    this.element === null || view === void 0 || this.element.style({
+      left: view.left,
+      top: view.top,
+      width: view.width,
+      height: view.height,
+      scale: view.scale
+    });
+  }
+  replay() {
+    let sought = this.sought;
+    if (this.element !== null && sought !== null) {
+      this.element.seek(sought.kind === "machine" ? UiVectorPlay.machine : UiVectorPlay.animation, sought.index, sought.seconds).play(UiVectorPlay.stop, 0);
+      return;
+    }
+    let play = this.playing;
+    this.element === null || play === null || this.element.play(
+      play.kind === "machine" ? UiVectorPlay.machine : UiVectorPlay.animation,
+      play.index
+    );
+  }
+}, VectorPointerScene = class {
+  constructor(report) {
+    this.report = report;
+    this.name = "vector-viewer";
+    this.lastU = -1;
+    this.lastV = -1;
+  }
+  update(game) {
+    let pointer = game.input.pointer, frame = game.input.frame;
+    frame.pressed ? this.send("down", pointer.x, pointer.y) : pointer.down && (pointer.x !== this.lastU || pointer.y !== this.lastV) && this.send("move", pointer.x, pointer.y), frame.released && this.send("up", pointer.x, pointer.y);
+  }
+  send(phase, u, v) {
+    this.lastU = u, this.lastV = v, this.report({ phase, u, v });
+  }
+};
+async function vectorViewer(ctx) {
+  let scene = new VectorPointerScene(
+    (pointer) => sendToStudio({ topic: VECTOR_REPORT.pointer, body: pointer })
+  );
+  await runCanvasGame(ctx, { scene });
+  let platform = await ctx.graphics.engine(), runtime = platform.kind === "engine" ? bindEngineRuntime(platform.runtime) : null, exports = runtime === null ? null : engineVectorAuthorExports(runtime);
+  if (runtime === null || exports === null) {
+    sendToStudio({ topic: VECTOR_REPORT.ready, body: { editing: false, schema: null } }), ctx.program.ready();
+    return;
+  }
+  let ui = ctx.ui.game(), stage = new VectorStage(ui), session = new VectorEditSession({
+    open: (file) => new VectorAuthor(runtime, exports, file),
+    send: (message) => {
+      sendToStudio(message);
+    },
+    draw: (file) => stage.draw(file),
+    show: (show) => stage.show(show),
+    play: (play) => stage.play(play),
+    seek: (seek) => stage.seek(seek),
+    input: (input) => stage.input(input)
+  });
+  ctx.on_dispose(() => session.close()), onStudio((message) => session.handle(message)), sendToStudio({
+    topic: VECTOR_REPORT.ready,
+    body: { editing: true, schema: vectorAuthorSchema(runtime) }
+  }), ctx.program.ready();
+}
+
+export { ATTITUDE_CLIPS, AVATAR_ATTITUDE_BINDING, AVATAR_FRAMING_BINDING, AVATAR_IDENTITY_BINDING, AVATAR_STILL_BINDING, AVATAR_TURN_BINDING, AVATAR_VIEWER_SET, AVATAR_VIEWER_TURN, AvatarTurn, AvatarViewerScene, BREAK_PIECES, DRAFT_ASSET, DRAFT_FORMAT, DraftScene, MAX_TURN_RADIANS, PLACE_CAMERA_BINDING, PLACE_DOC_BINDING, PLACE_TIER_BINDING, PREPARED_PLATFORM, STUDIO_GIFT_BINDING, STUDIO_TEST_GIFT, VECTOR_BACKDROP, VectorPointerScene, VectorStage, avatarShownFrom, avatarViewer, bakedThings, breaks, brokenThing, cameraFrom, draftPlayer, draftSounds, placeViewer, canvasPlatformBackend as platformBackend, readDraftFile, runCanvasGame, showcaseWorld, shownFrom, vectorViewer };