@triflare/fx 2.1.0-beta.3 → 2.1.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflare/fx",
-  "version": "2.1.0-beta.3",
+  "version": "2.1.0-beta.4",
   "description": "Code PenguinMod projects with text.",
   "type": "module",
   "license": "Apache-2.0",

package/product.yml

@@ -1,7 +1,7 @@
 # Identity
 name: "Triflare Fx"
 command: "fx"
-version: "2.1.0-beta.3"
+version: "2.1.0-beta.4"
 tagline: "Code PenguinMod projects with text."
 author: "Triflare"
 homepage: "https://github.com/triflare/fx"

package/src/catalog.js

@@ -102,6 +102,59 @@ const OF_MENU = {
   field: "OBJECT",
   default: "_stage_",
 };
+const SPRITE_STOP_MENU = {
+  type: "menu",
+  menu: "control_stop_sprite_menu",
+  field: "STOP_OPTION",
+  default: "_stage_",
+};
+const VISIBILITY_MENU = {
+  type: "menu",
+  menu: "looks_changeVisibilityOfSprite_menu",
+  field: "VISIBLE_OPTION",
+  default: "_myself_",
+};
+const OTHER_VISIBILITY_MENU = {
+  type: "menu",
+  menu: "looks_getOtherSpriteVisible_menu",
+  field: "VISIBLE_OPTION",
+  default: "_myself_",
+};
+const COSTUME_INPUT_MENU = {
+  type: "menu",
+  menu: "looks_getinput_menu",
+  field: "INPUT",
+  default: "width",
+};
+const FULL_TOUCHING_MENU = {
+  type: "menu",
+  menu: "sensing_fulltouchingobjectmenu",
+  field: "FULLTOUCHINGOBJECTMENU",
+  default: "_mouse_",
+};
+const SPRITE_TOUCHING_MENU = {
+  type: "menu",
+  menu: "sensing_touchingobjectmenusprites",
+  field: "SPRITETOUCHINGOBJECTMENU",
+  default: "_myself_",
+};
+const SCROLL_MENU = {
+  type: "menu",
+  menu: "sensing_scrolldirections",
+  field: "SCROLL_OPTION",
+  default: "up",
+};
+const FINGER_MENU = {
+  type: "menu",
+  menu: "sensing_fingeroptions",
+  field: "FINGER_OPTION",
+  default: "1",
+};
+
+// Variable and list references are serialized as *fields*, not inputs, but
+// they occupy a positional argument in the Fx call like any other input.
+const VAR_REF = { type: "variable" };
+const LIST_REF = { type: "list" };
 
 const CORE_CATALOG = {
   // ---------------------------------------------------------------- motion
@@ -713,6 +766,867 @@ const CORE_CATALOG = {
     extension: "fxTempVars",
     requiresExtension: true,
   },
+  // ---- control (PenguinMod) --------------------------------------------
+  "control.backToGreenFlag": {
+    opcode: "control_backToGreenFlag",
+  },
+  "control.continueLoop": {
+    opcode: "control_continueLoop",
+  },
+  "control.decrementCounter": {
+    opcode: "control_decr_counter",
+  },
+  "control.deleteClonesOf": {
+    opcode: "control_delete_clones_of",
+    inputs: {
+      CLONE_OPTION: CLONE_MENU,
+    },
+  },
+  "control.escapeLoop": {
+    opcode: "control_exitLoop",
+  },
+  "control.ifReturnElseReturn": {
+    opcode: "control_if_return_else_return",
+    kind: "reporter",
+    inputs: {
+      boolean: BOOLEAN,
+      TEXT1: STRING,
+      TEXT2: STRING,
+    },
+  },
+  "control.javascriptCommand": {
+    opcode: "control_javascript_command",
+    inputs: {
+      JS: STRING,
+    },
+  },
+  "control.repeatForSeconds": {
+    opcode: "control_repeatForSeconds",
+    inputs: {
+      TIMES: POSITIVE,
+      SUBSTACK: SUBSTACK,
+    },
+  },
+  "control.setCounter": {
+    opcode: "control_set_counter",
+    inputs: {
+      VALUE: NUMBER,
+    },
+  },
+  "control.stopSprite": {
+    opcode: "control_stop_sprite",
+    inputs: {
+      STOP_OPTION: SPRITE_STOP_MENU,
+    },
+  },
+  "control.waitSecondsOrUntil": {
+    opcode: "control_waitsecondsoruntil",
+    inputs: {
+      DURATION: POSITIVE,
+      CONDITION: BOOLEAN,
+    },
+  },
+  "control.waitTick": {
+    opcode: "control_waittick",
+  },
+
+  // ---- data (PenguinMod) --------------------------------------------
+  "data.setListFromArray": {
+    opcode: "data_arraylist",
+    inputs: {
+      LIST: LIST_REF,
+      VALUE: STRING,
+    },
+  },
+  "data.itemExists": {
+    opcode: "data_itemexistslist",
+    kind: "boolean",
+    inputs: {
+      INDEX: WHOLE,
+      LIST: LIST_REF,
+    },
+  },
+  "data.listAsArray": {
+    opcode: "data_listarray",
+    kind: "reporter",
+    inputs: {
+      LIST: LIST_REF,
+    },
+  },
+  "data.forEachItem": {
+    opcode: "data_listforeachitem",
+    inputs: {
+      LIST: LIST_REF,
+      VARIABLE: VAR_REF,
+      SUBSTACK: SUBSTACK,
+    },
+  },
+  "data.forEachIndex": {
+    opcode: "data_listforeachnum",
+    inputs: {
+      LIST: LIST_REF,
+      VARIABLE: VAR_REF,
+      SUBSTACK: SUBSTACK,
+    },
+  },
+  "data.listIsEmpty": {
+    opcode: "data_listisempty",
+    kind: "boolean",
+    inputs: {
+      LIST: LIST_REF,
+    },
+  },
+  "data.reverseList": {
+    opcode: "data_reverselist",
+    inputs: {
+      LIST: LIST_REF,
+    },
+  },
+
+  // ---- events (PenguinMod) --------------------------------------------
+  "events.always": {
+    opcode: "event_always",
+    kind: "hat",
+    args: [],
+  },
+  "events.whenAnything": {
+    opcode: "event_whenanything",
+    kind: "hat",
+    args: [{ input: "ANYTHING", type: "boolean" }],
+  },
+  "events.whenJavaScript": {
+    opcode: "event_whenjavascript",
+    kind: "hat",
+    args: [{ input: "JS", type: "string" }],
+  },
+  "events.whenKeyHit": {
+    opcode: "event_whenkeyhit",
+    kind: "hat",
+    args: [{ field: "KEY_OPTION", default: "space" }],
+  },
+  "events.whenMouseScrolled": {
+    opcode: "event_whenmousescrolled",
+    kind: "hat",
+    args: [{ field: "KEY_OPTION", default: "up" }],
+  },
+  "events.whenStopClicked": {
+    opcode: "event_whenstopclicked",
+    kind: "hat",
+    args: [],
+  },
+
+  // ---- looks (PenguinMod) --------------------------------------------
+  "looks.changeStretch": {
+    opcode: "looks_changeStretch",
+    inputs: {
+      X: NUMBER,
+      Y: NUMBER,
+    },
+  },
+  "looks.changeVisibilityOf": {
+    opcode: "looks_changeVisibilityOfSprite",
+    fields: { VISIBLE_TYPE: "show" },
+    inputs: {
+      VISIBLE_OPTION: VISIBILITY_MENU,
+    },
+  },
+  "looks.hideSprite": {
+    opcode: "looks_changeVisibilityOfSpriteHide",
+    inputs: {
+      VISIBLE_OPTION: VISIBILITY_MENU,
+    },
+  },
+  "looks.showSprite": {
+    opcode: "looks_changeVisibilityOfSpriteShow",
+    inputs: {
+      VISIBLE_OPTION: VISIBILITY_MENU,
+    },
+  },
+  "looks.effectValue": {
+    opcode: "looks_getEffectValue",
+    kind: "reporter",
+    fields: { EFFECT: "COLOR" },
+  },
+  "looks.isSpriteVisible": {
+    opcode: "looks_getOtherSpriteVisible",
+    kind: "boolean",
+    inputs: {
+      VISIBLE_OPTION: OTHER_VISIBILITY_MENU,
+    },
+  },
+  "looks.isVisible": {
+    opcode: "looks_getSpriteVisible",
+    kind: "boolean",
+  },
+  "looks.costumeInput": {
+    opcode: "looks_getinputofcostume",
+    kind: "reporter",
+    inputs: {
+      INPUT: COSTUME_INPUT_MENU,
+      COSTUME: COSTUME_MENU,
+    },
+  },
+  "looks.goToTargetLayer": {
+    opcode: "looks_goTargetLayer",
+    fields: { FORWARD_BACKWARD: "infront" },
+    inputs: {
+      VISIBLE_OPTION: OTHER_VISIBILITY_MENU,
+    },
+  },
+  "looks.layer": {
+    opcode: "looks_layersGetLayer",
+    kind: "reporter",
+  },
+  "looks.setLayer": {
+    opcode: "looks_layersSetLayer",
+    inputs: {
+      NUM: INTEGER,
+    },
+  },
+  "looks.previousBackdrop": {
+    opcode: "looks_previousbackdrop",
+  },
+  "looks.previousCostume": {
+    opcode: "looks_previouscostume",
+  },
+  "looks.sayHeight": {
+    opcode: "looks_sayHeight",
+    kind: "reporter",
+  },
+  "looks.sayWidth": {
+    opcode: "looks_sayWidth",
+    kind: "reporter",
+  },
+  "looks.setBubbleColor": {
+    opcode: "looks_setColor",
+    fields: { prop: "BUBBLE_STROKE" },
+    inputs: {
+      color: COLOR,
+    },
+  },
+  "looks.setFont": {
+    opcode: "looks_setFont",
+    inputs: {
+      font: { type: "string", default: "Helvetica" },
+      size: { type: "number", default: "14" },
+    },
+  },
+  "looks.setTextBubbleShape": {
+    opcode: "looks_setShape",
+    fields: { prop: "MIN_WIDTH" },
+    inputs: {
+      color: NUMBER,
+    },
+  },
+  "looks.setStretch": {
+    opcode: "looks_setStretch",
+    inputs: {
+      X: NUMBER,
+      Y: NUMBER,
+    },
+  },
+  "looks.setTintColor": {
+    opcode: "looks_setTintColor",
+    inputs: {
+      color: COLOR,
+    },
+  },
+  "looks.stopTalking": {
+    opcode: "looks_stoptalking",
+  },
+  "looks.stretchX": {
+    opcode: "looks_stretchGetX",
+    kind: "reporter",
+  },
+  "looks.stretchY": {
+    opcode: "looks_stretchGetY",
+    kind: "reporter",
+  },
+  "looks.tintColor": {
+    opcode: "looks_tintColor",
+    kind: "reporter",
+  },
+
+  // ---- motion (PenguinMod) --------------------------------------------
+  "motion.changeByXY": {
+    opcode: "motion_changebyxy",
+    inputs: {
+      DX: NUMBER,
+      DY: NUMBER,
+    },
+  },
+  "motion.ifOnSpriteBounce": {
+    opcode: "motion_ifonspritebounce",
+    inputs: {
+      SPRITE: POINT_MENU,
+    },
+  },
+  "motion.ifOnXYBounce": {
+    opcode: "motion_ifonxybounce",
+    inputs: {
+      X: NUMBER,
+      Y: NUMBER,
+    },
+  },
+  "motion.moveToStageSide": {
+    opcode: "motion_move_sprite_to_scene_side",
+    fields: { ALIGNMENT: "bottom-left" },
+  },
+  "motion.moveBackSteps": {
+    opcode: "motion_movebacksteps",
+    inputs: {
+      STEPS: NUMBER,
+    },
+  },
+  "motion.moveUpDownSteps": {
+    opcode: "motion_moveupdownsteps",
+    fields: { DIRECTION: "up" },
+    inputs: {
+      STEPS: NUMBER,
+    },
+  },
+  "motion.pointInRandomDirection": {
+    opcode: "motion_pointinrandomdirection",
+  },
+  "motion.pointTowardsXY": {
+    opcode: "motion_pointtowardsxy",
+    inputs: {
+      X: NUMBER,
+      Y: NUMBER,
+    },
+  },
+  "motion.turnAround": {
+    opcode: "motion_turnaround",
+  },
+  "motion.turnLeftAroundXY": {
+    opcode: "motion_turnleftaroundxy",
+    inputs: {
+      DEGREES: NUMBER,
+      X: NUMBER,
+      Y: NUMBER,
+    },
+  },
+  "motion.turnRightAroundXY": {
+    opcode: "motion_turnrightaroundxy",
+    inputs: {
+      DEGREES: NUMBER,
+      X: NUMBER,
+      Y: NUMBER,
+    },
+  },
+
+  // ---- operators (PenguinMod) --------------------------------------------
+  "operators.advancedMath": {
+    opcode: "operator_advMath",
+    kind: "reporter",
+    fields: { OPTION: "^" },
+    inputs: {
+      ONE: NUMBER,
+      TWO: NUMBER,
+    },
+  },
+  "operators.advancedMathExpanded": {
+    opcode: "operator_advMathExpanded",
+    kind: "reporter",
+    fields: { OPTION: "root" },
+    inputs: {
+      ONE: NUMBER,
+      TWO: NUMBER,
+      THREE: NUMBER,
+    },
+  },
+  "operators.advancedLog": {
+    opcode: "operator_advlog",
+    kind: "reporter",
+    inputs: {
+      NUM1: NUMBER,
+      NUM2: NUMBER,
+    },
+  },
+  "operators.boolify": {
+    opcode: "operator_boolify",
+    kind: "boolean",
+    inputs: {
+      ONE: STRING,
+    },
+  },
+  "operators.characterToCode": {
+    opcode: "operator_character_to_code",
+    kind: "reporter",
+    inputs: {
+      ONE: STRING,
+    },
+  },
+  "operators.codeToCharacter": {
+    opcode: "operator_code_to_character",
+    kind: "reporter",
+    inputs: {
+      ONE: NUMBER,
+    },
+  },
+  "operators.constrain": {
+    opcode: "operator_constrainnumber",
+    kind: "reporter",
+    inputs: {
+      inp: NUMBER,
+      min: NUMBER,
+      max: NUMBER,
+    },
+  },
+  "operators.countAppearances": {
+    opcode: "operator_countAppearTimes",
+    kind: "reporter",
+    inputs: {
+      TEXT1: STRING,
+      TEXT2: STRING,
+    },
+  },
+  "operators.falseValue": {
+    opcode: "operator_falseBoolean",
+    kind: "boolean",
+  },
+  "operators.lettersBetween": {
+    opcode: "operator_getLettersFromIndexToIndexInText",
+    kind: "reporter",
+    inputs: {
+      INDEX1: NUMBER,
+      INDEX2: NUMBER,
+      TEXT: STRING,
+    },
+  },
+  "operators.lettersBetweenFixed": {
+    opcode: "operator_getLettersFromIndexToIndexInTextFixed",
+    kind: "reporter",
+    inputs: {
+      INDEX1: NUMBER,
+      INDEX2: NUMBER,
+      TEXT: STRING,
+    },
+  },
+  "operators.gte": {
+    opcode: "operator_gtorequal",
+    kind: "boolean",
+    inputs: {
+      OPERAND1: STRING,
+      OPERAND2: STRING,
+    },
+  },
+  "operators.indexOf": {
+    opcode: "operator_indexOfTextInText",
+    kind: "reporter",
+    inputs: {
+      TEXT1: STRING,
+      TEXT2: STRING,
+    },
+  },
+  "operators.javascriptBoolean": {
+    opcode: "operator_javascript_boolean",
+    kind: "boolean",
+    inputs: {
+      JS: STRING,
+    },
+  },
+  "operators.javascriptOutput": {
+    opcode: "operator_javascript_output",
+    kind: "reporter",
+    inputs: {
+      JS: STRING,
+    },
+  },
+  "operators.join3": {
+    opcode: "operator_join3",
+    kind: "reporter",
+    inputs: {
+      STRING1: STRING,
+      STRING2: STRING,
+      STRING3: STRING,
+    },
+  },
+  "operators.lastIndexOf": {
+    opcode: "operator_lastIndexOfTextInText",
+    kind: "reporter",
+    inputs: {
+      TEXT1: STRING,
+      TEXT2: STRING,
+    },
+  },
+  "operators.interpolate": {
+    opcode: "operator_lerpFunc",
+    kind: "reporter",
+    inputs: {
+      ONE: NUMBER,
+      TWO: NUMBER,
+      AMOUNT: NUMBER,
+    },
+  },
+  "operators.lte": {
+    opcode: "operator_ltorequal",
+    kind: "boolean",
+    inputs: {
+      OPERAND1: STRING,
+      OPERAND2: STRING,
+    },
+  },
+  "operators.nand": {
+    opcode: "operator_nand",
+    kind: "boolean",
+    inputs: {
+      OPERAND1: BOOLEAN,
+      OPERAND2: BOOLEAN,
+    },
+  },
+  "operators.newLine": {
+    opcode: "operator_newLine",
+    kind: "reporter",
+  },
+  "operators.nor": {
+    opcode: "operator_nor",
+    kind: "boolean",
+    inputs: {
+      OPERAND1: BOOLEAN,
+      OPERAND2: BOOLEAN,
+    },
+  },
+  "operators.notEqual": {
+    opcode: "operator_notequal",
+    kind: "boolean",
+    inputs: {
+      OPERAND1: STRING,
+      OPERAND2: STRING,
+    },
+  },
+  "operators.power": {
+    opcode: "operator_power",
+    kind: "reporter",
+    inputs: {
+      NUM1: NUMBER,
+      NUM2: NUMBER,
+    },
+  },
+  "operators.randomBoolean": {
+    opcode: "operator_randomBoolean",
+    kind: "boolean",
+  },
+  "operators.readLine": {
+    opcode: "operator_readLineInMultilineText",
+    kind: "reporter",
+    inputs: {
+      LINE: NUMBER,
+      TEXT: STRING,
+    },
+  },
+  "operators.regexMatch": {
+    opcode: "operator_regexmatch",
+    kind: "reporter",
+    inputs: {
+      text: STRING,
+      reg: STRING,
+      regrule: STRING,
+    },
+  },
+  "operators.replaceAll": {
+    opcode: "operator_replaceAll",
+    kind: "reporter",
+    inputs: {
+      text: STRING,
+      term: STRING,
+      res: STRING,
+    },
+  },
+  "operators.replaceFirst": {
+    opcode: "operator_replaceFirst",
+    kind: "reporter",
+    inputs: {
+      text: STRING,
+      term: STRING,
+      res: STRING,
+    },
+  },
+  "operators.stringify": {
+    opcode: "operator_stringify",
+    kind: "reporter",
+    inputs: {
+      ONE: STRING,
+    },
+  },
+  "operators.tabCharacter": {
+    opcode: "operator_tabCharacter",
+    kind: "reporter",
+  },
+  "operators.includesLetterFrom": {
+    opcode: "operator_textIncludesLetterFrom",
+    kind: "boolean",
+    inputs: {
+      TEXT1: STRING,
+      TEXT2: STRING,
+    },
+  },
+  "operators.startsWithOrEndsWith": {
+    opcode: "operator_textStartsOrEndsWith",
+    kind: "boolean",
+    fields: { OPTION: "starts" },
+    inputs: {
+      TEXT1: STRING,
+      TEXT2: STRING,
+    },
+  },
+  "operators.toCase": {
+    opcode: "operator_toUpperLowerCase",
+    kind: "reporter",
+    fields: { OPTION: "upper" },
+    inputs: {
+      TEXT: STRING,
+    },
+  },
+  "operators.trueValue": {
+    opcode: "operator_trueBoolean",
+    kind: "boolean",
+  },
+  "operators.xnor": {
+    opcode: "operator_xnor",
+    kind: "boolean",
+    inputs: {
+      OPERAND1: STRING,
+      OPERAND2: STRING,
+    },
+  },
+  "operators.xor": {
+    opcode: "operator_xor",
+    kind: "boolean",
+    inputs: {
+      OPERAND1: STRING,
+      OPERAND2: STRING,
+    },
+  },
+
+  // ---- sensing (PenguinMod) --------------------------------------------
+  "sensing.directionBetween": {
+    opcode: "sensing_directionTo",
+    kind: "reporter",
+    inputs: {
+      x2: STRING,
+      y2: STRING,
+      x1: STRING,
+      y1: STRING,
+    },
+  },
+  "sensing.distanceBetween": {
+    opcode: "sensing_distanceTo",
+    kind: "reporter",
+    inputs: {
+      x1: STRING,
+      y1: STRING,
+      x2: STRING,
+      y2: STRING,
+    },
+  },
+  "sensing.fingerDown": {
+    opcode: "sensing_fingerdown",
+    kind: "boolean",
+    inputs: {
+      FINGER_OPTION: FINGER_MENU,
+    },
+  },
+  "sensing.fingerTapped": {
+    opcode: "sensing_fingertapped",
+    kind: "boolean",
+    inputs: {
+      FINGER_OPTION: FINGER_MENU,
+    },
+  },
+  "sensing.fingerX": {
+    opcode: "sensing_fingerx",
+    kind: "reporter",
+    inputs: {
+      FINGER_OPTION: FINGER_MENU,
+    },
+  },
+  "sensing.fingerY": {
+    opcode: "sensing_fingery",
+    kind: "reporter",
+    inputs: {
+      FINGER_OPTION: FINGER_MENU,
+    },
+  },
+  "sensing.browser": {
+    opcode: "sensing_getbrowser",
+    kind: "reporter",
+  },
+  "sensing.clipboard": {
+    opcode: "sensing_getclipboard",
+    kind: "reporter",
+  },
+  "sensing.isDraggable": {
+    opcode: "sensing_getdragmode",
+    kind: "boolean",
+  },
+  "sensing.operatingSystem": {
+    opcode: "sensing_getoperatingsystem",
+    kind: "reporter",
+  },
+  "sensing.spriteWithAttribute": {
+    opcode: "sensing_getspritewithattrib",
+    kind: "reporter",
+    inputs: {
+      var: STRING,
+      val: STRING,
+    },
+  },
+  "sensing.url": {
+    opcode: "sensing_geturl",
+    kind: "reporter",
+  },
+  "sensing.touchingSpritePoint": {
+    opcode: "sensing_getxyoftouchingsprite",
+    kind: "reporter",
+    fields: { XY: "x" },
+    inputs: {
+      SPRITE: DISTANCE_MENU,
+    },
+  },
+  "sensing.isUpperCase": {
+    opcode: "sensing_isUpperCase",
+    kind: "boolean",
+    inputs: {
+      text: STRING,
+    },
+  },
+  "sensing.keyHit": {
+    opcode: "sensing_keyhit",
+    kind: "boolean",
+    inputs: {
+      KEY_OPTION: KEY_MENU,
+    },
+  },
+  "sensing.loggedIn": {
+    opcode: "sensing_loggedin",
+    kind: "boolean",
+  },
+  "sensing.isMobile": {
+    opcode: "sensing_mobile",
+    kind: "boolean",
+  },
+  "sensing.mouseClicked": {
+    opcode: "sensing_mouseclicked",
+    kind: "boolean",
+  },
+  "sensing.mouseScrolling": {
+    opcode: "sensing_mousescrolling",
+    kind: "boolean",
+    inputs: {
+      SCROLL_OPTION: SCROLL_MENU,
+    },
+  },
+  "sensing.objectTouchingClone": {
+    opcode: "sensing_objecttouchingclonesprite",
+    kind: "boolean",
+    inputs: {
+      FULLTOUCHINGOBJECTMENU: FULL_TOUCHING_MENU,
+      SPRITETOUCHINGOBJECTMENU: SPRITE_TOUCHING_MENU,
+    },
+  },
+  "sensing.objectTouchingObject": {
+    opcode: "sensing_objecttouchingobject",
+    kind: "boolean",
+    inputs: {
+      FULLTOUCHINGOBJECTMENU: FULL_TOUCHING_MENU,
+      SPRITETOUCHINGOBJECTMENU: SPRITE_TOUCHING_MENU,
+    },
+  },
+  "sensing.regexTest": {
+    opcode: "sensing_regextest",
+    kind: "boolean",
+    inputs: {
+      text: STRING,
+      reg: STRING,
+      regrule: STRING,
+    },
+  },
+  "sensing.setClipboard": {
+    opcode: "sensing_setclipboard",
+    inputs: {
+      ITEM: STRING,
+    },
+  },
+  "sensing.hasNumber": {
+    opcode: "sensing_thing_has_number",
+    kind: "boolean",
+    inputs: {
+      TEXT1: STRING,
+    },
+  },
+  "sensing.isNumber": {
+    opcode: "sensing_thing_is_number",
+    kind: "boolean",
+    inputs: {
+      TEXT1: STRING,
+    },
+  },
+  "sensing.isText": {
+    opcode: "sensing_thing_is_text",
+    kind: "boolean",
+    inputs: {
+      TEXT1: STRING,
+    },
+  },
+
+  // ---- sound (PenguinMod) --------------------------------------------
+  "sound.effectValue": {
+    opcode: "sound_getEffectValue",
+    kind: "reporter",
+    fields: { EFFECT: "PITCH" },
+  },
+  "sound.lengthOf": {
+    opcode: "sound_getLength",
+    kind: "reporter",
+    inputs: {
+      SOUND_MENU: SOUND_MENU,
+    },
+  },
+  "sound.soundVolume": {
+    opcode: "sound_getSoundVolume",
+    kind: "reporter",
+    inputs: {
+      SOUND_MENU: SOUND_MENU,
+    },
+  },
+  "sound.isPlaying": {
+    opcode: "sound_isSoundPlaying",
+    kind: "boolean",
+    inputs: {
+      SOUND_MENU: SOUND_MENU,
+    },
+  },
+  "sound.playAt": {
+    opcode: "sound_play_at_seconds",
+    inputs: {
+      SOUND_MENU: SOUND_MENU,
+      VALUE: NUMBER,
+    },
+  },
+  "sound.playAtUntilDone": {
+    opcode: "sound_play_at_seconds_until_done",
+    inputs: {
+      SOUND_MENU: SOUND_MENU,
+      VALUE: NUMBER,
+    },
+  },
+  "sound.playAllSounds": {
+    opcode: "sound_playallsounds",
+  },
+  "sound.setFadeOut": {
+    opcode: "sound_set_stop_fadeout_to",
+    inputs: {
+      VALUE: NUMBER,
+      SOUND_MENU: SOUND_MENU,
+    },
+  },
+  "sound.stop": {
+    opcode: "sound_stop",
+    inputs: {
+      SOUND_MENU: SOUND_MENU,
+    },
+  },
 };
 
 /**

package/src/cli/commands/catalog.js

@@ -1,15 +1,104 @@
-import { CATALOG, blockNames } from "../../catalog.js";
+import { CATALOG } from "../../catalog.js";
 import { loadProjectState } from "../context.js";
+import { plural, terminalColumns } from "../format.js";
+
+// Language order for the built-in categories; extension groups follow
+// alphabetically so their blocks stay together at the end of the listing.
+const CATEGORY_ORDER = [
+  "motion",
+  "looks",
+  "sound",
+  "sensing",
+  "operators",
+  "control",
+  "events",
+  "data",
+];
+
+// One-character kind marker, so a name alone still says how the block is used.
+const KIND_MARKS = {
+  command: " ",
+  reporter: "→",
+  boolean: "?",
+  hat: "▸",
+};
+
+/** `SCREAMING_SNAKE_CASE` name for a catalog argument. */
+function argumentName(name) {
+  return name
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+    .toUpperCase();
+}
+
+/** Positional arguments a block takes, in the order the compiler fills them. */
+function argumentNames(entry) {
+  // `pm.*` are argument reporters whose VALUE field is the reporter's own
+  // label ("is compiled?"), not a parameter the caller supplies.
+  if (entry.opcode?.startsWith("argument_reporter")) return [];
+  if (entry.kind === "hat")
+    return (entry.args || []).map((arg) => arg.field || arg.input);
+  return [
+    ...Object.keys(entry.fields || {}),
+    ...Object.entries(entry.inputs || {})
+      .filter(([, spec]) => spec.type !== "substack")
+      .map(([name]) => name),
+  ];
+}
+
+/** `category.block(ARG, ...)` call shape shown in the listing. */
+function signature(name, entry) {
+  const args = argumentNames(entry).map(argumentName);
+  return `${name}(${args.join(", ")})`;
+}
+
+function mark(entry) {
+  return KIND_MARKS[entry.kind] ?? " ";
+}
+
+/** Group block names by category, in reading order. */
+function groupNames(names) {
+  const groups = new Map();
+  for (const name of names) {
+    const group = name.split(".")[0];
+    if (!groups.has(group)) groups.set(group, []);
+    groups.get(group).push(name);
+  }
+  const rank = (group) => {
+    const index = CATEGORY_ORDER.indexOf(group);
+    return index < 0 ? CATEGORY_ORDER.length : index;
+  };
+  return new Map(
+    [...groups.entries()].sort(
+      ([left], [right]) =>
+        rank(left) - rank(right) || left.localeCompare(right),
+    ),
+  );
+}
 
 export const catalogCommand = {
   name: "catalog",
   aliases: ["l", "blocks"],
   group: "Core Commands:",
   summary: "List available blocks",
-  description: `List block names, including blocks from extensions configured in the
-project.`,
+  description: `List block names grouped by category, including blocks from extensions
+configured in the project.`,
   arguments: ["[dir]"],
-  examples: ["fx catalog", "fx catalog --json"],
+  options: [
+    {
+      flags: "--category <name>",
+      description: "Only list one category, such as motion or pen",
+    },
+    {
+      flags: "--search <text>",
+      description: "Only list blocks whose name contains the text",
+    },
+  ],
+  examples: [
+    "fx catalog",
+    "fx catalog --category motion",
+    "fx catalog --search glide",
+  ],
   async run({ args, cwd, options, reporter, product, prompts }) {
     const state = await loadProjectState({
       input: args[0],
@@ -19,24 +108,69 @@ project.`,
       prompts,
     });
     const merged = { ...CATALOG, ...state.catalog };
-    const names = Object.keys(merged).sort();
-    const builtIn = blockNames().length;
-
-    reporter.heading(
-      `${product.name} catalog (${names.length} blocks` +
-        (names.length > builtIn
-          ? `, ${names.length - builtIn} from extensions`
-          : "") +
-        "):",
+    const category =
+      typeof options.category === "string"
+        ? options.category.toLowerCase()
+        : null;
+    const search =
+      typeof options.search === "string" ? options.search.toLowerCase() : null;
+    const names = Object.keys(merged)
+      .filter(
+        (name) => !category || name.split(".")[0].toLowerCase() === category,
+      )
+      .filter((name) => !search || name.toLowerCase().includes(search))
+      .sort();
+    const selected = Object.fromEntries(
+      names.map((name) => [name, merged[name]]),
     );
-    for (const name of names) {
-      const entry = merged[name];
-      reporter.item(name, `-> ${entry.opcode} [${entry.kind}]`, {
-        width: 32,
-        suffix: entry.extension ? `(ext ${entry.extension})` : "",
-      });
+
+    if (names.length === 0) {
+      const filters = [
+        category && `--category "${options.category}"`,
+        search && `--search "${options.search}"`,
+      ]
+        .filter(Boolean)
+        .join(" and ");
+      reporter.info(`No blocks match ${filters}.`);
+      reporter.hint(`run "${product.command} catalog" to see every block`);
+      return selected;
+    }
+
+    const groups = groupNames(names);
+    let title = `${product.name} catalog — ${plural(names.length, "block")}`;
+    if (category) title += ` · ${category}`;
+    else if (search) title += ` matching "${options.search}"`;
+    else title += ` in ${plural(groups.size, "group")}`;
+    reporter.heading(title);
+    if (!category && !search)
+      reporter.hint("narrow with --category <name> or --search <text>");
+
+    const width = terminalColumns();
+    for (const [group, entries] of groups) {
+      reporter.text("");
+      reporter.item(group, "", { width: 0, suffix: `· ${entries.length}` });
+      if (reporter.verbose) {
+        for (const name of entries) {
+          const entry = merged[name];
+          reporter.item(
+            `${mark(entry)} ${signature(name, entry)}`,
+            `-> ${entry.opcode} [${entry.kind}]`,
+            {
+              width: 44,
+              suffix: entry.extension ? `(ext ${entry.extension})` : "",
+            },
+          );
+        }
+      } else {
+        reporter.columns(
+          entries.map(
+            (name) => `${mark(merged[name])} ${signature(name, merged[name])}`,
+          ),
+          { width },
+        );
+      }
     }
 
-    return merged;
+    return selected;
   },
 };

package/src/cli/format.js

@@ -29,3 +29,55 @@ export function truncate(text, max) {
   const value = String(text);
   return value.length > max ? `${value.slice(0, max)}…` : value;
 }
+
+/** Usable terminal width, clamped so narrow and huge terminals stay readable. */
+export function terminalColumns(
+  stream = process.stdout,
+  { fallback = 80, min = 40, max = 120 } = {},
+) {
+  const width = stream?.columns;
+  if (!Number.isFinite(width) || width <= 0) return fallback;
+  return Math.min(max, Math.max(min, width));
+}
+
+/**
+ * Lay items out in aligned columns that fit `width`. Entries wider than one
+ * cell get a line of their own, so a single long name does not collapse the
+ * whole listing into one column. Trailing whitespace is removed.
+ */
+export function formatColumns(
+  items,
+  { width = 80, indent = 2, gap = 2, cellWidth = 38 } = {},
+) {
+  if (items.length === 0) return [];
+  const available = Math.max(width - indent, 1);
+  const columns = Math.max(
+    1,
+    Math.min(4, Math.floor((available + gap) / (cellWidth + gap))),
+  );
+  const cell = Math.floor((available - gap * (columns - 1)) / columns);
+  const lines = [];
+  let row = [];
+
+  const flush = () => {
+    if (row.length === 0) return;
+    const cells = row.map((text, index) =>
+      index === row.length - 1 ? text : text.padEnd(cell),
+    );
+    lines.push(`${" ".repeat(indent)}${cells.join(" ".repeat(gap))}`.trimEnd());
+    row = [];
+  };
+
+  for (const item of items) {
+    const text = String(item);
+    if (text.length > cell) {
+      flush();
+      lines.push(`${" ".repeat(indent)}${text}`);
+      continue;
+    }
+    row.push(text);
+    if (row.length === columns) flush();
+  }
+  flush();
+  return lines;
+}

package/src/cli/reporter.js

@@ -8,6 +8,7 @@
 
 import { styleText } from "node:util";
 import { brandText } from "../brand.js";
+import { formatColumns } from "./format.js";
 import { createTheme } from "./theme.js";
 
 const STATUS = {
@@ -145,6 +146,13 @@ export function createReporter({
       stdout.write(`  ${theme.accent(padded)}${detail}${note}\n`);
     },
 
+    /** Compact multi-column rows for long block and file listings. */
+    columns(items, { width = 80, indent = 2, gap = 2 } = {}) {
+      if (!human) return;
+      for (const line of formatColumns(items, { width, indent, gap }))
+        stdout.write(`${line}\n`);
+    },
+
     /** Plain block of text with no decoration. */
     text(message) {
       if (!human) return;

package/src/compiler.js

@@ -45,6 +45,8 @@ const NUMBER_TYPES = {
 const TERMINAL_OPCODES = new Set([
   "procedures_return",
   "control_delete_this_clone",
+  "control_exitLoop",
+  "control_continueLoop",
 ]);
 
 let seed = 0n;
@@ -778,6 +780,9 @@ export class Compiler {
     if (block.opcode === "procedures_return") return "`return`";
     if (block.opcode === "control_delete_this_clone")
       return "`control.deleteThisClone()`";
+    if (block.opcode === "control_exitLoop") return "`control.escapeLoop()`";
+    if (block.opcode === "control_continueLoop")
+      return "`control.continueLoop()`";
     if (block.opcode === "control_stop") {
       const option = block.fields.STOP_OPTION
         ? block.fields.STOP_OPTION[0]
@@ -1034,14 +1039,17 @@ export class Compiler {
    */
   emitCall(ctx, node, parentId) {
     const segments = node.segments;
+    const entry = this.catalog[node.name];
 
     // List method: `items.push(x)`, `items.at(i)`, ...
     if (segments.length === 2) {
       const listInfo = ctx.resolveList(segments[0]);
-      if (listInfo) return this.emitListCall(ctx, node, listInfo, parentId);
+      // Canonical list methods take precedence; aliases resolve in emitListCall
+      // only when the name does not identify a catalog block.
+      if (listInfo && (Object.hasOwn(LIST_OPS, segments[1]) || !entry))
+        return this.emitListCall(ctx, node, listInfo, parentId);
     }
 
-    const entry = this.catalog[node.name];
     if (entry) return this.emitCatalogCall(ctx, node, entry, parentId);
 
     if (segments.length === 1 && ctx.funcs.has(node.name)) {
@@ -1098,6 +1106,33 @@ export class Compiler {
     for (const name of inputNames) {
       const spec = entry.inputs[name];
       if (spec.type === "substack") continue;
+      // Variable and list references are stored as fields in Scratch JSON
+      // even though they read as positional arguments in Fx source.
+      if (spec.type === "variable" || spec.type === "list") {
+        if (node.args[argIndex] === undefined)
+          this.fail(
+            `${node.name} requires a ${spec.type} name for ${name}`,
+            node.loc,
+          );
+        const refName = String(this.literalValue(node.args[argIndex]));
+        const resolved =
+          spec.type === "list"
+            ? ctx.resolveList(refName)
+            : ctx.resolveValue(refName);
+        if (
+          !resolved ||
+          (spec.type === "list"
+            ? resolved.kind !== "list"
+            : resolved.kind !== "var")
+        )
+          this.fail(
+            `Unknown ${spec.type} ${JSON.stringify(refName)} for ${node.name}`,
+            node.loc,
+          );
+        fields[name] = [resolved.name, resolved.id];
+        argIndex += 1;
+        continue;
+      }
       if (node.args[argIndex] !== undefined) {
         inputs[name] = this.buildInputForSpec(spec, node.args[argIndex], id);
         argIndex += 1;

package/src/decompiler.js

@@ -18,7 +18,15 @@ const MENU_OPCODES = new Set([
   "looks_backdrops",
   "sound_sounds_menu",
   "control_create_clone_of_menu",
+  "control_stop_sprite_menu",
   "sensing_of_object_menu",
+  "sensing_fulltouchingobjectmenu",
+  "sensing_touchingobjectmenusprites",
+  "sensing_scrolldirections",
+  "sensing_fingeroptions",
+  "looks_changeVisibilityOfSprite_menu",
+  "looks_getOtherSpriteVisible_menu",
+  "looks_getinput_menu",
   "pen_menu_colorParam",
 ]);
 
@@ -50,6 +58,7 @@ const LIST_OPCODE_METHOD = {
 };
 
 const SAFE_TEMP_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const SAFE_VAR_REF = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 
 function escapeString(value) {
   return String(value)
@@ -236,6 +245,12 @@ class Decompiler {
     }
     for (const [inputName, spec] of Object.entries(entry.inputs || {})) {
       if (spec.type === "substack") continue;
+      if (spec.type === "variable" || spec.type === "list") {
+        const field = (block.fields || {})[inputName];
+        const ref = field ? field[0] : "0";
+        args.push(SAFE_VAR_REF.test(ref) ? ref : `"${escapeString(ref)}"`);
+        continue;
+      }
       args.push(this.renderExpression(block.inputs[inputName]));
     }
     return `${name}(${args.join(", ")})`;
@@ -396,6 +411,18 @@ class Decompiler {
           option === "timer" ? "timerGreaterThan" : "loudnessGreaterThan";
         return `${pad}when ${kind}(${this.renderExpression(block.inputs.VALUE)}) {\n${body(block.next)}\n}`;
       }
+      case "event_always":
+        return `${pad}when always {\n${body(block.next)}\n}`;
+      case "event_whenanything":
+        return `${pad}when whenAnything(${this.renderExpression(block.inputs.ANYTHING)}) {\n${body(block.next)}\n}`;
+      case "event_whenjavascript":
+        return `${pad}when whenJavaScript(${this.renderExpression(block.inputs.JS)}) {\n${body(block.next)}\n}`;
+      case "event_whenkeyhit":
+        return `${pad}when whenKeyHit("${escapeString((block.fields.KEY_OPTION || ["space"])[0])}") {\n${body(block.next)}\n}`;
+      case "event_whenmousescrolled":
+        return `${pad}when whenMouseScrolled("${escapeString((block.fields.KEY_OPTION || ["up"])[0])}") {\n${body(block.next)}\n}`;
+      case "event_whenstopclicked":
+        return `${pad}when whenStopClicked {\n${body(block.next)}\n}`;
       default:
         return this.renderExtensionHat(block, pad, body);
     }