gamesteel 0.6.0 → 0.6.1

package/dist/pkgs/model/dist/worker.js

@@ -24846,7 +24846,7 @@ function shouldInterruptAfterDeadline(deadline) {
 var import_sucrase3 = __toESM(require_dist2(), 1);
 
 // ../core/dist/version.js
-var ENGINE_VERSION = "0.10.0";
+var ENGINE_VERSION = "0.10.1";
 
 // ../core/dist/sim/trig-table.js
 var QUARTER_WAVE = [
@@ -26111,6 +26111,10 @@ function ticksOf(d, line = 1, column = 1) {
   return ticks;
 }
 
+// ../core/dist/script/scan.js
+var import_parser = __toESM(require_parser(), 1);
+var import_types = __toESM(require_types(), 1);
+
 // ../core/dist/home.js
 import { existsSync, renameSync, symlinkSync } from "node:fs";
 import { homedir } from "node:os";
@@ -27968,7 +27972,7 @@ var Parser = class {
     return clauses;
   }
 };
-function parse(source) {
+function parse2(source) {
   return new Parser(tokenize(source)).parse();
 }
 
@@ -29274,7 +29278,7 @@ function checkStrings(ast, out) {
 function checkControls(ast, out) {
   const lines = ast.controls?.bindings ?? [];
   const players = playerButtonsOf(ast);
-  const mouse = ["click", "right_click", "middle_click"];
+  const mouse = ["click", "right_click", "middle_click", "menu"];
   const builtIn = /* @__PURE__ */ new Set([...BUTTONS, ...mouse, ...players]);
   const buttons = [...BUTTONS, ...mouse, ...players, ...lines.map((l) => l.button).filter((b) => !builtIn.has(b))];
   const own2 = lines.filter((l) => !builtIn.has(l.button));
@@ -29535,6 +29539,27 @@ function numericProps(props) {
   return out;
 }
 
+// ../core/dist/script/prefs.js
+var NO_PREFS_YET = { sound: true, music: true, fullscreen: false, canFullscreen: false, touch: false };
+var usesPrefs = (sources) => sources.some((source) => /\.\s*prefs\b/.test(source));
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function isPrefs(value) {
+  return isObject(value) && Object.keys(value).length === 5 && typeof value["sound"] === "boolean" && typeof value["music"] === "boolean" && typeof value["fullscreen"] === "boolean" && typeof value["canFullscreen"] === "boolean" && typeof value["touch"] === "boolean";
+}
+var CHANGEABLE = ["sound", "music", "fullscreen"];
+function prefsChangeOf(raw) {
+  const said2 = "prefs.set takes sound, music and fullscreen, each true or false, like prefs.set({ music: false })";
+  if (!isObject(raw))
+    throw new Error(said2);
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (!CHANGEABLE.includes(key) || typeof value !== "boolean")
+      throw new Error(`${said2}, not ${JSON.stringify({ [key]: value })}`);
+    out[key] = value;
+  }
+  return out;
+}
+
 // ../core/dist/script/ads.js
 var AD_KINDS = ["break", "reward"];
 var NO_ADS_YET = { pending: null, lastBreak: null, lastPress: null, lastPlay: null, played: false, scene: null, ready: AD_KINDS, banner: null };
@@ -29591,7 +29616,7 @@ var ONLINE_LIMITS = {
   downloadBytes: 1e6
 };
 var TOO_MANY_ASKS = `a tick asks the game's server at most ${String(ONLINE_LIMITS.asksPerTick)} times: spread the calls over ticks`;
-var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var jsonBytes = (data) => {
   try {
     const text2 = JSON.stringify(data);
@@ -29620,7 +29645,7 @@ var uploadProblem = (ask) => {
 };
 function askProblem(ask) {
   const kinds = "an online ask is a call, join, leave, send, upload, download or askPush";
-  if (!isObject(ask))
+  if (!isObject2(ask))
     return kinds;
   switch (ask["kind"]) {
     case "call":
@@ -29644,7 +29669,7 @@ function askProblem(ask) {
 }
 var usesOnline = (sources) => sources.some((source) => /\bonline\s*\.\s*(call|join|leave|send|state|upload|uploadScreen|download|askPush)\b/.test(source));
 function isOnlineHeard(value) {
-  if (!isObject(value))
+  if (!isObject2(value))
     return false;
   switch (value["kind"]) {
     case "answer":
@@ -29671,9 +29696,9 @@ function isOnlineHeard(value) {
 // ../core/dist/script/purchases.js
 var PURCHASE_RESULTS = ["granted", "pending", "cancelled", "unavailable", "refused"];
 var PRODUCT_ID = /^[a-z0-9][a-z0-9_.]{0,39}$/;
-var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isObject3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function purchaseAskProblem(ask) {
-  if (!isObject2(ask))
+  if (!isObject3(ask))
     return "a purchase ask is a buy of a product or a restore";
   if (ask["kind"] === "restore")
     return null;
@@ -29682,9 +29707,9 @@ function purchaseAskProblem(ask) {
   const id = ask["id"];
   return typeof id === "string" && PRODUCT_ID.test(id) ? null : `a product id is 1 to 40 lowercase letters, digits, _ and ., starting with a letter or digit, like coins_100, not ${JSON.stringify(id) ?? String(id)}`;
 }
-var isProduct = (value) => isObject2(value) && typeof value["id"] === "string" && typeof value["price"] === "string" && typeof value["name"] === "string";
+var isProduct = (value) => isObject3(value) && typeof value["id"] === "string" && typeof value["price"] === "string" && typeof value["name"] === "string";
 function isPurchaseHeard(value) {
-  if (!isObject2(value))
+  if (!isObject3(value))
     return false;
   switch (value["kind"]) {
     case "products":
@@ -30721,6 +30746,16 @@ const __online = Object.freeze({
   askPush() { __call('onlineAskPush', {}) },
   get state() { return __call('onlineState', {}) },
 })
+/** The player's settings (a game's own pause menu): read as the page last said them; a change asked of the page, which
+ *  makes it after the tick and says it on a later one. */
+const __prefs = Object.freeze({
+  get sound() { return __call('prefs', {}).sound === true },
+  get music() { return __call('prefs', {}).music === true },
+  get fullscreen() { return __call('prefs', {}).fullscreen === true },
+  get canFullscreen() { return __call('prefs', {}).canFullscreen === true },
+  get touch() { return __call('prefs', {}).touch === true },
+  set(change) { __call('prefsSet', { change: change === undefined ? null : change }) },
+})
 /** Purchases (the online services spec, part 3): asked of the page, which asks the store; answered on a later tick as a
  *  'purchase' event. */
 const __purchases = Object.freeze({
@@ -31006,6 +31041,7 @@ const __game = {
   get ui() { return __ui },
   get ads() { return __ads },
   get online() { return __online },
+  get prefs() { return __prefs },
   get purchases() { return __purchases },
   /** The game script's own fields, read only; null without one. */
   get script() { return __frozen(__revived(__call('gameScript', null))) },
@@ -31440,19 +31476,19 @@ globalThis.noise = noise
 `;
 
 // ../core/dist/script/top-level.js
-var import_parser = __toESM(require_parser(), 1);
+var import_parser2 = __toESM(require_parser(), 1);
 var import_tokenizer = __toESM(require_tokenizer(), 1);
-var import_types = __toESM(require_types(), 1);
+var import_types2 = __toESM(require_types(), 1);
 var import_keywords = __toESM(require_keywords(), 1);
 var CHANGEABLE_TOP_LEVEL = "a script keeps its state in its fields: a top-level let or var lives outside the game, where a snapshot cannot hold it and a second play does not start from it; make it a field, or const if it never changes";
 var PRIVATE_STATIC = "a private static field cannot be frozen, so it would keep state outside the game, shared by every object: make it an instance field, or a const at the top of the script";
 var PRIVATE_MEMBER = "a private field or method (#name) cannot be kept between ticks: a script's state is its plain fields, and an object made again from them, after a restore or a failed call, has no private ones; drop the #, and keep it as a field or a method";
-var DECLARING = /* @__PURE__ */ new Set([import_types.TokenType._const, import_types.TokenType._let, import_types.TokenType._var, import_types.TokenType._function, import_types.TokenType._class, import_types.TokenType._enum]);
-var OPENING = /* @__PURE__ */ new Set([import_types.TokenType.parenL, import_types.TokenType.bracketL, import_types.TokenType.braceL, import_types.TokenType.dollarBraceL]);
-var CLOSING = /* @__PURE__ */ new Set([import_types.TokenType.parenR, import_types.TokenType.bracketR, import_types.TokenType.braceR]);
+var DECLARING = /* @__PURE__ */ new Set([import_types2.TokenType._const, import_types2.TokenType._let, import_types2.TokenType._var, import_types2.TokenType._function, import_types2.TokenType._class, import_types2.TokenType._enum]);
+var OPENING = /* @__PURE__ */ new Set([import_types2.TokenType.parenL, import_types2.TokenType.bracketL, import_types2.TokenType.braceL, import_types2.TokenType.dollarBraceL]);
+var CLOSING = /* @__PURE__ */ new Set([import_types2.TokenType.parenR, import_types2.TokenType.bracketR, import_types2.TokenType.braceR]);
 var lineAt = (source, offset) => source.slice(0, offset).split("\n").length;
 function topLevelOf(source) {
-  const { tokens, scopes } = (0, import_parser.parse)(source, false, true, false);
+  const { tokens, scopes } = (0, import_parser2.parse)(source, false, true, false);
   const at2 = (i) => {
     const token = tokens[i];
     return { name: token === void 0 ? "" : source.slice(token.start, token.end), line: lineAt(source, token?.start ?? 0) };
@@ -31464,21 +31500,21 @@ function topLevelOf(source) {
   const functions = scopes.filter((scope) => scope.isFunctionScope && !(scope.startTokenIndex === 0 && scope.endTokenIndex >= tokens.length));
   const inFunction = (i) => functions.some((scope) => scope.startTokenIndex <= i && i < scope.endTokenIndex);
   for (const [i, token] of tokens.entries()) {
-    if (token.type === import_types.TokenType._var && !inFunction(i))
+    if (token.type === import_types2.TokenType._var && !inFunction(i))
       changeable.push({ ...at2(i + 1), line: at2(i).line });
     if (token.contextualKeyword === import_keywords.ContextualKeyword._static) {
       let next = i + 1;
       while (tokens[next]?.contextualKeyword === import_keywords.ContextualKeyword._readonly)
         next += 1;
-      if (tokens[next]?.type === import_types.TokenType.hash && tokens[next + 2]?.type !== import_types.TokenType.parenL)
+      if (tokens[next]?.type === import_types2.TokenType.hash && tokens[next + 2]?.type !== import_types2.TokenType.parenL)
         privateStatics.push({ ...at2(next + 1), name: `#${at2(next + 1).name}` });
     }
-    if (token.type === import_types.TokenType.hash) {
+    if (token.type === import_types2.TokenType.hash) {
       let back2 = i - 1;
       while (tokens[back2]?.contextualKeyword === import_keywords.ContextualKeyword._readonly)
         back2 -= 1;
       const before2 = tokens[back2];
-      const used = before2 !== void 0 && (before2.type === import_types.TokenType.dot || before2.type === import_types.TokenType.questionDot);
+      const used = before2 !== void 0 && (before2.type === import_types2.TokenType.dot || before2.type === import_types2.TokenType.questionDot);
       if (!used && before2?.contextualKeyword !== import_keywords.ContextualKeyword._static)
         privateMembers.push({ ...at2(i + 1), name: `#${at2(i + 1).name}` });
     }
@@ -31498,7 +31534,7 @@ function topLevelOf(source) {
       else if (depth <= 0 && DECLARING.has(type))
         break;
     }
-    if (tokens[back]?.type === import_types.TokenType._let)
+    if (tokens[back]?.type === import_types2.TokenType._let)
       changeable.push(declared);
   }
   changeable.sort((a, b) => a.line - b.line);
@@ -32369,6 +32405,8 @@ function initialScripts(given, kinds, seed = 1, saved = {}, audio, fonts, adsOff
     ...adsOff === void 0 ? {} : { adsOff },
     // A game whose scripts mention online keeps its state and call count from the first tick; any other never has them.
     ...usesOnline([...Object.values(sources.kinds), sources.game ?? "", ...Object.values(sources.modules ?? {})]) ? { onlineState: "off", nextCall: 1 } : {},
+    // A game whose scripts mention the player's settings keeps them from the first tick; any other never has them.
+    ...usesPrefs([...Object.values(sources.kinds), sources.game ?? "", ...Object.values(sources.modules ?? {})]) ? { prefs: NO_PREFS_YET } : {},
     // A game whose scripts mention purchases keeps its products from the first tick; any other never has them.
     ...usesPurchases([...Object.values(sources.kinds), sources.game ?? "", ...Object.values(sources.modules ?? {})]) ? { purchases: NO_PURCHASES_YET } : {}
   };
@@ -33981,7 +34019,7 @@ type Side = 'above' | 'below' | 'side' | 'overlap'
 type Colour = string | number
 /* KindName, PropName and Button are each game's own (the whole-engine review, I11): its
  * kinds; the properties it declares, or a rule or a script sets; and the buttons every game
- * has (left, right, up, down, jump, action, and click, the left mouse button) with those its
+ * has (left, right, up, down, jump, action, click, the left mouse button, and menu: see Prefs) with those its
  * controls name. A name written
  * in quotes that the game does not have is an error where it is written; a name held in a
  * string (a field, a table) is checked as the game plays. */
@@ -34293,87 +34331,6 @@ interface Turns {
   readonly round: number
 }
 
-/** Where a UI element sits in what holds it (the screen, or the element its in names): one of nine points. */
-type UiAnchor = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right'
-/** A UI element, in design units (480 by 270 unless ui.design says), scaled to the real screen: the design's long side to
- *  its long side, so a phone held either way shows it at the same size, and what is wider than a narrow screen is the
- *  game's to lay out (a playtest look with ui: true says what runs off). */
-interface UiSpec {
-  /** 'panel' when left out. Only a button is hovered, pressed, clicked and focused. A row or column places the elements
-   *  whose in names it, in the order they were first set, gap apart, and is as big as them unless given a size. */
-  kind?: 'panel' | 'button' | 'label' | 'meter' | 'icon' | 'row' | 'column'
-  /** The point of what holds it that it sits at; 'top-left' when left out. */
-  anchor?: UiAnchor
-  /** Design units in from the anchored edges: { anchor: 'top-right', at: [8, 8] } sits 8 in from the top and the
-   *  right; from a middle, x moves right and y down. [0, 0] when left out. A row or column places its own. */
-  at?: [number, number]
-  /** [width, height] in design units: needed, but for a row or column. */
-  size?: [number, number]
-  /** The element it sits inside, by name: anchored in its box, or placed by it when it is a row or column. */
-  in?: string
-  /** Design units between what a row or column holds. */
-  gap?: number
-  /** Design units inside a row's or column's edge. */
-  pad?: number
-  /** Where what a row or column holds sits across it; 'center' when left out. */
-  align?: 'start' | 'center' | 'end'
-  /** Never hovered, pressed, focused or clicked; its state reads 'disabled', to draw it greyed. */
-  disabled?: boolean
-  /** false starts it hidden, for ui.show to bring in. */
-  shown?: boolean
-}
-/** An element as this screen shows it, in pixels as g.screen draws. */
-interface UiBox {
-  readonly x: number
-  readonly y: number
-  readonly w: number
-  readonly h: number
-  /** 0 hidden to 1 shown, eased, as ui.show moves it: draw by it for a slide, a fade or a pop. */
-  readonly shown: number
-  readonly state: 'disabled' | 'pressed' | 'hover' | 'focused' | 'idle'
-  /** Screen pixels in one design unit: size what is drawn in the box by it, as 14 * b.scale. */
-  readonly scale: number
-}
-/** Text fitted to a box: the size it fits at, its lines, and whether what did not fit was cut. */
-interface UiFit { readonly size: number; readonly lines: string[]; readonly width: number; readonly height: number; readonly cut: boolean }
-/** game.ui: the game's UI elements. The engine places them on any screen, kept clear of a phone's notch and corners,
- *  and tracks the pointer, a finger, presses, clicks and focus. It draws nothing: each element looks as the game's draw
- *  draws it at ui.box, so make it look like this game and no other. Declare in start (or in update: the same again
- *  changes nothing), read clicks in update or whilePaused, draw in draw. */
-interface Ui {
-  /** Declares an element, or changes one; 64 at most. Never in draw. */
-  set(name: string, spec: UiSpec): void
-  /** Takes an element away, with those inside it. */
-  remove(name: string): void
-  /** Eases it in (true) or out (false) over the seconds (0.2 when left out), on the real clock, so a pause menu slides
-   *  in while the world holds. A hidden one is never clicked. */
-  show(name: string, shown: boolean, seconds?: number): void
-  /** Gives the keys to a menu: up, down, left and right move focus to the nearest button that way, and jump or action
-   *  clicks it. The game still sees those buttons, so hold its own controls while ui.focused is not null; null gives
-   *  them back. */
-  focus(name: string | null): void
-  /** The size the elements are written in, 480 by 270 when never set. */
-  design(width: number, height: number): void
-  /** Where it is on this screen and how it stands; null for a name never set. update reads it at the screen played,
-   *  draw at the screen drawn. */
-  box(name: string): UiBox | null
-  /** How it stands: idle, hover, pressed, focused or disabled; null for a name not set, as box gives. */
-  state(name: string): UiBox['state'] | null
-  /** Clicked since the last update: pressed and let go on it, by the pointer or a finger, or jump or action on its
-   *  focus. Heard once. A press on a button is the UI's: input.pressed('click') never sees it. False for a name not
-   *  set, so a game reading one it removed runs on. */
-  clicked(name: string): boolean
-  /** The largest size, from size (16 when left out) down to min (8), at which the text wrapped to the box fits it; at
-   *  min, what still does not fit is cut, ending in an ellipsis. text's fit option does this as it draws. */
-  fit(text: string | number, box: { w: number; h: number }, options?: { size?: number; min?: number; font?: FontName; lineHeight?: number }): UiFit
-  /** The focused button, or null. */
-  readonly focused: string | null
-  /** Screen pixels in one design unit on the screen played. */
-  readonly scale: number
-  /** The names set, in the order they were first set. */
-  readonly names: readonly string[]
-}
-
 /** A level's back layer, drawn behind the objects and darker, or its front layer, drawn over them; neither collides. */
 interface TileLayerOption { layer?: 'back' | 'front' }
 
@@ -34683,6 +34640,8 @@ interface Game {
   readonly ads: Ads
   /** The game's own server: calls and live rooms. */
   readonly online: Online
+  /** The player's sound, music and fullscreen, for the game's own pause menu. */
+  readonly prefs: Prefs
   /** Real-money purchases in the game's store app. */
   readonly purchases: Purchases
   /** Opens the game's privacy policy, as a game on the app stores must from inside itself: call it when the player
@@ -34742,6 +34701,116 @@ interface Game {
   burst(x: In3D<number, 'burst(x, y, z)'>, y: number, z: number, options?: BurstOptions): void
 }
 
+/** The player's own settings, which the page keeps for every game they play: what a game's own pause menu shows and
+ *  changes. A game whose scripts read the button 'menu' draws its own pause menu: the page presses menu where it would
+ *  open its own (P, Escape, a pad's Start, the touch pause button, an app's back button), and the game pauses itself
+ *  with game.pause() and resumes with game.resume(). Read as the page last said; a change is asked of the page, which
+ *  makes it after the tick and says it on a later one. */
+interface Prefs {
+  /** Sound effects on. */
+  readonly sound: boolean
+  /** Music on. */
+  readonly music: boolean
+  /** The page fills the screen. */
+  readonly fullscreen: boolean
+  /** The page may fill the screen: false where it cannot (a frame that forbids it, most phones' browsers, an app), so a
+   *  menu leaves its Fullscreen row out. */
+  readonly canFullscreen: boolean
+  /** The player is on a touch screen (a finger has touched it): show the game's own touch controls, the UI elements
+   *  with touch, and its sticks. */
+  readonly touch: boolean
+  /** Asks the page to change them: prefs.set({ music: !this.game.prefs.music }). Fullscreen only on a press or a click,
+   *  as browsers allow it. Never from draw. */
+  set(change: { sound?: boolean; music?: boolean; fullscreen?: boolean }): void
+}
+
+/** Where a UI element sits in what holds it (the screen, or the element its in names): one of nine points. */
+type UiAnchor = 'top-left' | 'top' | 'top-right' | 'left' | 'center' | 'right' | 'bottom-left' | 'bottom' | 'bottom-right'
+/** A UI element, in design units (480 by 270 unless ui.design says), scaled to the real screen: the design's long side to
+ *  its long side, so a phone held either way shows it at the same size, and what is wider than a narrow screen is the
+ *  game's to lay out (a playtest look with ui: true says what runs off). */
+interface UiSpec {
+  /** 'panel' when left out. Only a button is hovered, pressed, clicked and focused. A row or column places the elements
+   *  whose in names it, in the order they were first set, gap apart, and is as big as them unless given a size. A stick
+   *  is a touch control: a finger on it (or that drifts off its edge) is player 1's left stick, -1 to 1 each way from its
+   *  middle, as input.stick('left') reads it. */
+  kind?: 'panel' | 'button' | 'label' | 'meter' | 'icon' | 'row' | 'column' | 'stick'
+  /** The point of what holds it that it sits at; 'top-left' when left out. */
+  anchor?: UiAnchor
+  /** Design units in from the anchored edges: { anchor: 'top-right', at: [8, 8] } sits 8 in from the top and the
+   *  right; from a middle, x moves right and y down. [0, 0] when left out. A row or column places its own. */
+  at?: [number, number]
+  /** [width, height] in design units: needed, but for a row or column. */
+  size?: [number, number]
+  /** The element it sits inside, by name: anchored in its box, or placed by it when it is a row or column. */
+  in?: string
+  /** Design units between what a row or column holds. */
+  gap?: number
+  /** Design units inside a row's or column's edge. */
+  pad?: number
+  /** Where what a row or column holds sits across it; 'center' when left out. */
+  align?: 'start' | 'center' | 'end'
+  /** Never hovered, pressed, focused or clicked; its state reads 'disabled', to draw it greyed. */
+  disabled?: boolean
+  /** false starts it hidden, for ui.show to bring in. */
+  shown?: boolean
+  /** A touch control (the game's own, which the page then draws none of): the button a finger on it holds, as a key
+   *  would, read by input.held and input.pressed; a finger on it, or on a stick, is never a click. Declare touch
+   *  controls shown: false and ui.show them while game.prefs.touch: a hidden one takes no finger. */
+  touch?: Buttons
+}
+/** An element as this screen shows it, in pixels as g.screen draws. */
+interface UiBox {
+  readonly x: number
+  readonly y: number
+  readonly w: number
+  readonly h: number
+  /** 0 hidden to 1 shown, eased, as ui.show moves it: draw by it for a slide, a fade or a pop. */
+  readonly shown: number
+  readonly state: 'disabled' | 'pressed' | 'hover' | 'focused' | 'idle'
+  /** Screen pixels in one design unit: size what is drawn in the box by it, as 14 * b.scale. */
+  readonly scale: number
+}
+/** Text fitted to a box: the size it fits at, its lines, and whether what did not fit was cut. */
+interface UiFit { readonly size: number; readonly lines: string[]; readonly width: number; readonly height: number; readonly cut: boolean }
+/** game.ui: the game's UI elements. The engine places them on any screen, kept clear of a phone's notch and corners,
+ *  and tracks the pointer, a finger, presses, clicks and focus. It draws nothing: each element looks as the game's draw
+ *  draws it at ui.box, so make it look like this game and no other. Declare in start (or in update: the same again
+ *  changes nothing), read clicks in update or whilePaused, draw in draw. */
+interface Ui {
+  /** Declares an element, or changes one; 64 at most. Never in draw. */
+  set(name: string, spec: UiSpec): void
+  /** Takes an element away, with those inside it. */
+  remove(name: string): void
+  /** Eases it in (true) or out (false) over the seconds (0.2 when left out), on the real clock, so a pause menu slides
+   *  in while the world holds. A hidden one is never clicked. */
+  show(name: string, shown: boolean, seconds?: number): void
+  /** Gives the keys to a menu: up, down, left and right move focus to the nearest button that way, and jump or action
+   *  clicks it. The game still sees those buttons, so hold its own controls while ui.focused is not null; null gives
+   *  them back. */
+  focus(name: string | null): void
+  /** The size the elements are written in, 480 by 270 when never set. */
+  design(width: number, height: number): void
+  /** Where it is on this screen and how it stands; null for a name never set. update reads it at the screen played,
+   *  draw at the screen drawn. */
+  box(name: string): UiBox | null
+  /** How it stands: idle, hover, pressed, focused or disabled; null for a name not set, as box gives. */
+  state(name: string): UiBox['state'] | null
+  /** Clicked since the last update: pressed and let go on it, by the pointer or a finger, or jump or action on its
+   *  focus. Heard once. A press on a button is the UI's: input.pressed('click') never sees it, nor the game's own button
+   *  bound to Click. False for a name not set, so a game reading one it removed runs on. */
+  clicked(name: string): boolean
+  /** The largest size, from size (16 when left out) down to min (8), at which the text wrapped to the box fits it; at
+   *  min, what still does not fit is cut, ending in an ellipsis. text's fit option does this as it draws. */
+  fit(text: string | number, box: { w: number; h: number }, options?: { size?: number; min?: number; font?: FontName; lineHeight?: number }): UiFit
+  /** The focused button, or null. */
+  readonly focused: string | null
+  /** Screen pixels in one design unit on the screen played. */
+  readonly scale: number
+  /** The names set, in the order they were first set. */
+  readonly names: readonly string[]
+}
+
 /** On g.screen, a drawing placed from a point of the world, a Thing's middle or a point in tiles: its x and y are then
  *  pixels from where that point is on the screen this frame (a health bar over an enemy, a name over a character).
  *  edge keeps it inside the screen by that many pixels, as an arrow to something off it does. The world layers take
@@ -34905,10 +34974,6 @@ declare const console: {
 }
 `;
 
-// ../core/dist/script/scan.js
-var import_parser2 = __toESM(require_parser(), 1);
-var import_types2 = __toESM(require_types(), 1);
-
 // ../core/dist/script/shader-wrap.js
 var UNIFORM_NUMBERS = {
   float: 1,
@@ -49517,12 +49582,13 @@ function rayOf(text2) {
 var LOOK_WORDS = "which must be <dx,dy in whole pixels from -4000 to 4000, like <12,-3";
 var RAY_WORDS = "which must be ?ox,oy,oz,dx,dy,dz: its origin in 256ths of a block and its direction in 10,000ths, whole numbers, like ?1280,512,0,0,-7071,7071";
 function onlineKey(input) {
-  if (input.online === void 0 && input.onlineState === void 0 && input.purchases === void 0)
+  if (input.online === void 0 && input.onlineState === void 0 && input.purchases === void 0 && input.prefs === void 0)
     return "";
   const json = JSON.stringify({
     ...input.online === void 0 ? {} : { h: input.online },
     ...input.onlineState === void 0 ? {} : { s: input.onlineState },
-    ...input.purchases === void 0 ? {} : { p: input.purchases }
+    ...input.purchases === void 0 ? {} : { p: input.purchases },
+    ...input.prefs === void 0 ? {} : { f: input.prefs }
   });
   let text2 = "";
   for (const byte of new TextEncoder().encode(json))
@@ -49538,19 +49604,22 @@ function onlineOf(text2) {
     const read2 = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
     if (typeof read2 !== "object" || read2 === null || Array.isArray(read2))
       return null;
-    const { h, s, p } = read2;
+    const { h, s, p, f: f2 } = read2;
     if (h !== void 0 && (!Array.isArray(h) || !h.every(isOnlineHeard)))
       return null;
     if (s !== void 0 && !ONLINE_STATES.includes(s))
       return null;
     if (p !== void 0 && (!Array.isArray(p) || !p.every(isPurchaseHeard)))
       return null;
-    if (h === void 0 && s === void 0 && p === void 0)
+    if (f2 !== void 0 && !isPrefs(f2))
+      return null;
+    if (h === void 0 && s === void 0 && p === void 0 && f2 === void 0)
       return null;
     return {
       ...h === void 0 ? {} : { online: h },
       ...s === void 0 ? {} : { onlineState: s },
-      ...p === void 0 ? {} : { purchases: p }
+      ...p === void 0 ? {} : { purchases: p },
+      ...f2 === void 0 ? {} : { prefs: f2 }
     };
   } catch {
     return null;
@@ -51209,7 +51278,7 @@ function nextStepOf(tiles, field2, from, size2, diagonal) {
 }
 
 // ../core/dist/script/ui.js
-var UI_KINDS = ["panel", "button", "label", "meter", "icon", "row", "column"];
+var UI_KINDS = ["panel", "button", "label", "meter", "icon", "row", "column", "stick"];
 var UI_ANCHORS = ["top-left", "top", "top-right", "left", "center", "right", "bottom-left", "bottom", "bottom-right"];
 var MAX_UI_ELEMENTS = 64;
 var MOST_CLICKED = 16;
@@ -51227,7 +51296,7 @@ var NO_UI = {
   clicked: []
 };
 var NAME2 = /^[a-z][a-z0-9_-]{0,39}$/;
-var KEYS = ["kind", "anchor", "at", "size", "in", "gap", "pad", "align", "disabled", "shown"];
+var KEYS = ["kind", "anchor", "at", "size", "in", "gap", "pad", "align", "disabled", "shown", "touch"];
 var words = (list2) => `${list2.slice(0, -1).map((w) => `'${w}'`).join(", ")} or '${list2[list2.length - 1] ?? ""}'`;
 function uiName(raw, what) {
   if (typeof raw === "string" && NAME2.test(raw))
@@ -51276,6 +51345,14 @@ function uiSpecOf(raw, name) {
     throw new Error(`${label}: disabled is true or false`);
   if (o.shown !== void 0 && typeof o.shown !== "boolean")
     throw new Error(`${label}: shown is true or false`);
+  const touch = o.touch === void 0 || o.touch === null ? null : o.touch;
+  if (touch !== null && (typeof touch !== "string" || !/^[a-z][a-z0-9_]{0,39}$/.test(touch))) {
+    throw new Error(`${label}: touch is the name of a button a finger on it holds, like 'jump' or 'fire', not ${JSON.stringify(touch)}`);
+  }
+  if (touch !== null && kind === "stick")
+    throw new Error(`${label}: a stick moves the stick, player 1's left; it holds no button, so it takes no touch`);
+  if (touch !== null && container)
+    throw new Error(`${label}: a row or a column holds its elements, not a button; give touch to an element inside it`);
   return {
     kind,
     anchor,
@@ -51285,7 +51362,8 @@ function uiSpecOf(raw, name) {
     gap: units(o.gap, `${label}: gap`, 0),
     pad: units(o.pad, `${label}: pad`, 0),
     align,
-    disabled: o.disabled === true
+    disabled: o.disabled === true,
+    ...touch === null ? {} : { touch }
   };
 }
 function safeInsets(screen) {
@@ -51427,24 +51505,55 @@ function uiStateOf(ui, name) {
 var sameList = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
 var FOCUS_KEYS = ["left", "right", "up", "down", "jump", "action"];
 var uiFrom = (input) => ({ ...NO_UI, down: input.buttons?.includes("click") === true, keys: FOCUS_KEYS.filter((key) => input[key]) });
-function stepUi(ui, input, real) {
+function pressable(ui, name, real) {
+  const spec = ui.elements[name];
+  return spec !== void 0 && spec.kind === "button" && !spec.disabled && shownOf2(ui, name, real) > 0;
+}
+function boxHolds(boxes, name, p) {
+  const b = boxes.get(name);
+  return b !== void 0 && p.x >= b.x && p.x < b.x + b.w && p.y >= b.y && p.y < b.y + b.h;
+}
+function uiButtonAt(ui, point, screen, real, boxes = layoutUi(ui, screen)) {
+  let found = null;
+  for (const name of ui.order)
+    if (pressable(ui, name, real) && boxHolds(boxes, name, point))
+      found = name;
+  return found;
+}
+function stickHolds(box, p) {
+  return p.x >= box.x - box.w / 2 && p.x <= box.x + box.w * 1.5 && p.y >= box.y - box.h / 2 && p.y <= box.y + box.h * 1.5;
+}
+function touchedOf(ui, input, real) {
+  const fingers = input.touches ?? [];
+  if (fingers.length === 0)
+    return { held: [], stick: null };
   const screen = { width: input.screenSize?.w ?? SCREEN_DEFAULT.w, height: input.screenSize?.h ?? SCREEN_DEFAULT.h };
   const boxes = layoutUi(ui, screen);
-  const eligible = (name) => {
+  const held = [];
+  let stick = null;
+  const clamp4 = (n) => Math.max(-1, Math.min(1, Math.round(n * 100) / 100)) + 0;
+  for (const name of ui.order) {
     const spec = ui.elements[name];
-    return spec !== void 0 && spec.kind === "button" && !spec.disabled && shownOf2(ui, name, real) > 0;
-  };
-  const holds2 = (name, p) => {
-    const b = boxes.get(name);
-    return b !== void 0 && p.x >= b.x && p.x < b.x + b.w && p.y >= b.y && p.y < b.y + b.h;
-  };
-  const pointer = input.screenPointer ?? input.touches?.[0] ?? null;
-  let hover = null;
-  if (pointer !== null) {
-    for (const name of ui.order)
-      if (eligible(name) && holds2(name, pointer))
-        hover = name;
+    const box = boxes.get(name);
+    if (spec === void 0 || box === void 0 || spec.disabled || shownOf2(ui, name, real) <= 0)
+      continue;
+    if (spec.touch !== void 0 && !held.includes(spec.touch) && fingers.some((f2) => boxHolds(boxes, name, f2)))
+      held.push(spec.touch);
+    if (spec.kind === "stick" && stick === null) {
+      const finger = fingers.find((f2) => stickHolds(box, f2));
+      if (finger !== void 0)
+        stick = { x: clamp4((finger.x - (box.x + box.w / 2)) / (box.w / 2)), y: clamp4((finger.y - (box.y + box.h / 2)) / (box.h / 2)) };
+    }
   }
+  return { held, stick };
+}
+function stepUi(ui, input, real) {
+  const screen = { width: input.screenSize?.w ?? SCREEN_DEFAULT.w, height: input.screenSize?.h ?? SCREEN_DEFAULT.h };
+  const boxes = layoutUi(ui, screen);
+  const eligible = (name) => pressable(ui, name, real);
+  const holds2 = (name, p) => boxHolds(boxes, name, p);
+  const pointer = input.screenPointer ?? input.touches?.[0] ?? null;
+  const hover = pointer === null ? null : uiButtonAt(ui, pointer, screen, real, boxes);
   const held = input.buttons?.includes("click") === true;
   const clicked = [...ui.clicked];
   const click = (name) => {
@@ -51845,7 +51954,7 @@ var OWN_AUDIO = /^own:[a-z0-9][a-z0-9-]{0,39}$/;
 var LIB_AUDIO = /^lib:[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/;
 var MOST_BURSTS = 64;
 var MOST_DEFERRED = 1024;
-var DRAW_OPS = /* @__PURE__ */ new Set(["thing", "data", "fields", "shown", "find", "findAll", "findIn", "touching", "tileAt", "tileIn", "tileUnder", "raycast", "path", "setting", "load", "random", "log", "drawn", "clock", "running", "measure", "bodyOf", "nextStep", "vars", "shared", "gameScript", "parentOf", "levelSize", "moving", "turns", "mixer", "typing", "t", "language", "languages", "ui", "uiFit", "onlineState", "purchaseProducts", "overlap3", "blockAt", "toScreen"]);
+var DRAW_OPS = /* @__PURE__ */ new Set(["thing", "data", "fields", "shown", "find", "findAll", "findIn", "touching", "tileAt", "tileIn", "tileUnder", "raycast", "path", "setting", "load", "random", "log", "drawn", "clock", "running", "measure", "bodyOf", "nextStep", "vars", "shared", "gameScript", "parentOf", "levelSize", "moving", "turns", "mixer", "typing", "t", "language", "languages", "ui", "uiFit", "onlineState", "prefs", "purchaseProducts", "overlap3", "blockAt", "toScreen"]);
 function screenOf2(input) {
   const size2 = input.screenSize ?? SCREEN_DEFAULT;
   return { screen: input.screenPointer ?? null, size: { width: size2.w, height: size2.h } };
@@ -51914,7 +52023,7 @@ function fromUnit(raw, unit, what) {
       return fromInt(Math.round(value));
   }
 }
-var BOT_OPS = /* @__PURE__ */ new Set(["thing", "data", "fields", "shown", "find", "findAll", "findIn", "touching", "tileAt", "tileIn", "tileUnder", "raycast", "path", "setting", "load", "random", "log", "clock", "running", "measure", "bodyOf", "nextStep", "vars", "shared", "gameScript", "parentOf", "levelSize", "moving", "turns", "mixer", "typing", "t", "language", "languages", "ui", "uiFit", "onlineState", "purchaseProducts", "overlap3", "blockAt"]);
+var BOT_OPS = /* @__PURE__ */ new Set(["thing", "data", "fields", "shown", "find", "findAll", "findIn", "touching", "tileAt", "tileIn", "tileUnder", "raycast", "path", "setting", "load", "random", "log", "clock", "running", "measure", "bodyOf", "nextStep", "vars", "shared", "gameScript", "parentOf", "levelSize", "moving", "turns", "mixer", "typing", "t", "language", "languages", "ui", "uiFit", "onlineState", "prefs", "purchaseProducts", "overlap3", "blockAt"]);
 function sidesOf(normal) {
   switch (normal) {
     case "a_above_b":
@@ -52035,6 +52144,9 @@ var Turn = class {
    *  game that never mentions online (the online services spec). */
   online;
   onlineState;
+  /** The player's settings as the input last said, and the change of them asked this tick (a game's own pause menu). */
+  prefs;
+  prefsAsk;
   nextCall;
   /** What the scripts asked of the store this tick, and what the game keeps of its purchases, absent for a game that
    *  never mentions them (the online services spec, part 3). */
@@ -52106,6 +52218,8 @@ var Turn = class {
     this.online = fresh || scripts.online === void 0 ? void 0 : [...scripts.online];
     this.onlineState = scripts.onlineState;
     this.nextCall = scripts.nextCall;
+    this.prefs = scripts.prefs;
+    this.prefsAsk = fresh ? void 0 : scripts.prefsAsk;
     this.purchase = fresh ? void 0 : scripts.purchase;
     this.purchases = scripts.purchases;
     this.music = scripts.music;
@@ -52261,6 +52375,8 @@ var Turn = class {
       nextCall: this.nextCall,
       purchase: this.purchase,
       purchases: this.purchases,
+      prefs: this.prefs,
+      prefsAsk: this.prefsAsk,
       bursts: this.bursts.length === 0 ? [] : [...this.bursts],
       screen: this.screen,
       waiting: this.waiting,
@@ -52320,6 +52436,8 @@ var Turn = class {
     this.online = was.online;
     this.onlineState = was.onlineState;
     this.nextCall = was.nextCall;
+    this.prefs = was.prefs;
+    this.prefsAsk = was.prefsAsk;
     this.purchase = was.purchase;
     this.purchases = was.purchases;
     this.bursts = was.bursts;
@@ -53661,6 +53779,14 @@ var Turn = class {
         return null;
       case "onlineState":
         return this.onlineState ?? "off";
+      // The player's settings (a game's own pause menu): read as the input last said; a change asked of the page, which
+      // makes it after the tick and says it on a later one.
+      case "prefs":
+        return this.prefs ?? NO_PREFS_YET;
+      case "prefsSet": {
+        this.prefsAsk = { ...this.prefsAsk ?? {}, ...prefsChangeOf(args.change) };
+        return null;
+      }
       // Purchases (the online services spec, part 3): asked of the page, which asks the store; the answer is heard on a
       // later tick, as input.
       case "purchaseBuy":
@@ -54352,6 +54478,17 @@ var Turn = class {
       throw new Error(TOO_MANY_ASKS);
     this.online = [...asked, ask];
   }
+  /** The player's settings as the page said them this tick, for a game that keeps them. A tick with a finger on the
+   *  screen that says nothing of them says a touch screen, as the page does on that tick: a playtest's track, which no
+   *  page plays, shows the game's touch controls to its look. */
+  takePrefsInput() {
+    if (this.prefs === void 0)
+      return;
+    if (this.input.prefs !== void 0)
+      this.prefs = this.input.prefs;
+    else if (!this.prefs.touch && (this.input.touches?.length ?? 0) > 0)
+      this.prefs = { ...this.prefs, touch: true };
+  }
   /** What the page brought back from the game's server, and whether it is online, for a game that keeps online: each
    *  heard as an 'online' event. A game that never mentions online ignores it. */
   takeOnlineInput() {
@@ -54409,7 +54546,7 @@ var Turn = class {
     this.events.push(name);
   }
   scriptsState() {
-    const { starting: _was, loops: _loops, mixer: _mixer, typing: _typing, ui: _ui, privacy: _privacy, ad: _ad, ads: _ads, online: _online, onlineState: _onlineState, nextCall: _nextCall, purchase: _purchase, purchases: _purchases, ...before2 } = this.scripts;
+    const { starting: _was, loops: _loops, mixer: _mixer, typing: _typing, ui: _ui, privacy: _privacy, ad: _ad, ads: _ads, online: _online, onlineState: _onlineState, nextCall: _nextCall, purchase: _purchase, purchases: _purchases, prefs: _prefs, prefsAsk: _prefsAsk, ...before2 } = this.scripts;
     return {
       ...before2,
       fields: this.fields,
@@ -54441,6 +54578,8 @@ var Turn = class {
       ...this.online === void 0 || this.online.length === 0 ? {} : { online: this.online },
       ...this.onlineState === void 0 ? {} : { onlineState: this.onlineState },
       ...this.nextCall === void 0 ? {} : { nextCall: this.nextCall },
+      ...this.prefs === void 0 ? {} : { prefs: this.prefs },
+      ...this.prefsAsk === void 0 ? {} : { prefsAsk: this.prefsAsk },
       ...this.purchase === void 0 ? {} : { purchase: this.purchase },
       ...this.purchases === void 0 ? {} : { purchases: this.purchases },
       music: this.music,
@@ -54483,12 +54622,33 @@ function uiTick(state, input) {
     return { state, input };
   const stepped = stepUi(ui, input, scripts.clock.real);
   const next = stepped.ui === ui ? state : { ...state, scripts: { ...scripts, ui: stepped.ui } };
-  if (!stepped.swallow || input.buttons?.includes("click") !== true)
-    return { state: next, input };
-  const { buttons, ...rest } = input;
+  const touched = withTouched(input, touchedOf(stepped.ui, input, scripts.clock.real));
+  if (!stepped.swallow || touched.buttons?.includes("click") !== true)
+    return { state: next, input: touched };
+  const { buttons, ...rest } = touched;
   const kept = (buttons ?? []).filter((button) => button !== "click");
   return { state: next, input: kept.length === 0 ? rest : { ...rest, buttons: kept } };
 }
+var SIX2 = /* @__PURE__ */ new Set(["left", "right", "up", "down", "jump", "action"]);
+function withTouched(input, touched) {
+  if (touched.held.length === 0 && touched.stick === null)
+    return input;
+  let out = input;
+  const own2 = new Set(input.buttons ?? []);
+  for (const button of touched.held) {
+    if (SIX2.has(button))
+      out = { ...out, [button]: true };
+    else
+      own2.add(button);
+  }
+  if (own2.size !== (input.buttons ?? []).length)
+    out = { ...out, buttons: [...own2].sort() };
+  if (touched.stick !== null) {
+    const [first, ...rest] = input.sticks ?? [];
+    out = { ...out, sticks: [{ rx: first?.rx ?? 0, ry: first?.ry ?? 0, lx: Math.round(touched.stick.x * 100) + 0, ly: Math.round(touched.stick.y * 100) + 0 }, ...rest] };
+  }
+  return out;
+}
 function heardClicks(turn) {
   if (turn.ui !== void 0 && turn.ui.clicked.length > 0)
     turn.ui = { ...turn.ui, clicked: [] };
@@ -54514,6 +54674,7 @@ function beginScripts(state, input) {
 function beginTurn(turn, scripts) {
   turn.takeAdInput();
   turn.takeOnlineInput();
+  turn.takePrefsInput();
   turn.takePurchaseInput();
   turn.bursts = turn.bursts.filter((b) => turn.now - b.step < b.life * 60);
   dueChange(turn);
@@ -54625,6 +54786,7 @@ function pausedScripts(state, input) {
 function pausedTurn(turn, scripts) {
   turn.takeAdInput();
   turn.takeOnlineInput();
+  turn.takePrefsInput();
   turn.takePurchaseInput();
   dueChange(turn);
   turn.call(null, "whilePaused", [DT]);
@@ -57901,7 +58063,7 @@ function listGames(args = {}, fallback = LIBRARY_ROOT) {
 // ../core/dist/surface/tools/inspect.js
 function compile(args) {
   try {
-    const compiled = load(parse(args.source));
+    const compiled = load(parse2(args.source));
     const first = compiled.levels[0];
     if (first === void 0)
       return fail("this spec declares no levels");
@@ -57914,7 +58076,7 @@ var isResult = (v) => typeof v === "object" && v !== null && "content" in v;
 function validate(args) {
   let ast;
   try {
-    ast = parse(args.source);
+    ast = parse2(args.source);
   } catch (e) {
     const err = e;
     return ok({