@yabgu_gm/tensionscript 0.13.0 → 0.13.1

package/dist/assemblyscript.generated.d.ts

@@ -6730,6 +6730,29 @@ declare module "types:tensionscript/src/compiler" {
          * value materialised somewhere, which is the return path, not this one.
          */
         private expandSroaArrayArgument;
+        /**
+         * Compiles an array literal into one operand per element leaf, starting at
+         * `at`, and returns how many were written.
+         *
+         * Shared by the call site (`expandSroaArrayArgument`) and the return
+         * (`compileMultivalueReturnStatement`) so the two positions accept the same
+         * shapes and refuse the same ones by the same rule, instead of by two copies
+         * of it. `verb` is `"passing"` or `"returning"` — the only word the two
+         * refusals disagree on.
+         *
+         * Three rules:
+         *
+         * - A **record element** is several leaves and no literal names them, so it is
+         *   refused by name; building the array field-by-field in a local is the
+         *   working route in both positions.
+         * - A **short** literal zero-fills. The slot exists either way, and a WASM
+         *   operand cannot be left out.
+         * - A **long** literal is an arity error rather than a write past the operand
+         *   block — `sum([1, 2, 3, 4, 5])` into a `[u32 * 4]` parameter reached
+         *   Binaryen with five operands for four slots and crashed the compiler, so
+         *   this bound is a guard, not a formality.
+         */
+        private pushSroaArrayLiteralOperands;
         private expandSroaArgument;
         /**
          * The SROA local an expression names, or `null`.
@@ -7166,9 +7189,10 @@ declare module "types:tensionscript/src/compiler" {
          * Returns a value-form `[T * N]` value as WASM multivalue results.
          *
          * One result per element leaf, element-major — the order `resultRefs` declares
-         * and the caller's unpack indexes into. The leaves are read out of the value's
-         * SROA locals; a fresh array literal goes through the same path, because the
-         * literal binds to leaves before the return is compiled.
+         * and the caller's unpack indexes into. Two shapes reach here, and both end as
+         * one operand per leaf: a value-form local pushes its SROA leaves, and a fresh
+         * array literal compiles element by element through the same walk the call
+         * site uses (`pushSroaArrayLiteralOperands`).
          *
          * Requires `Feature.MultiValue`, which `Resolver` turns on when it resolves
          * this return type (`enableMultiValueOnce`), so a module that returns one of