@neocompose/cli 0.84.3 → 0.84.4

package/dist/test-worker.mjs

@@ -3302,14 +3302,14 @@ function isNSFunctionContains(value) {
   if (v?.type !== "contains" /* contains */) return false;
   const info = v.info;
   if (typeof info !== "object" || info === null) return false;
-  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference);
+  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference) && (info.float === void 0 || info.float === true) && (info.decimal === void 0 || info.decimal === true);
 }
 function isNSFunctionIndexOf(value) {
   const v = value;
   if (v?.type !== "indexOf" /* indexOf */) return false;
   const info = v.info;
   if (typeof info !== "object" || info === null) return false;
-  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference);
+  return isNSPointer(info.collectionPointer) && isNSPointer(info.valuePointer) && isReferenceFlag(info.reference) && (info.float === void 0 || info.float === true) && (info.decimal === void 0 || info.decimal === true);
 }
 var NS_STRING_OPS = [
   "toLower",
@@ -3483,7 +3483,7 @@ function isNSFunctionCollectionQuery(value) {
     case "Reverse":
       return true;
     case "ToSet":
-      return info.reference === void 0 || info.reference === true;
+      return (info.reference === void 0 || info.reference === true) && (info.decimalEntries === void 0 || info.decimalEntries === true);
     default:
       return false;
   }
@@ -17029,16 +17029,18 @@ var UncompiledInitializerRuntimeError = class extends NSGetterRuntimeError {
 
 // ../packages/neoscript-runtime/src/neoscript/runtime-set.ts
 var RuntimeSet = class {
-  constructor(source, reference, enumEntries, slotReferences = null) {
+  constructor(source, reference, enumEntries, slotReferences = null, decimalEntries = false) {
     this.source = source;
     this.reference = reference;
     this.enumEntries = enumEntries;
     this.slotReferences = slotReferences;
+    this.decimalEntries = decimalEntries;
   }
   source;
   reference;
   enumEntries;
   slotReferences;
+  decimalEntries;
   entries = /* @__PURE__ */ new Map();
   validations = /* @__PURE__ */ new Map();
   snapshot;
@@ -17048,6 +17050,9 @@ var RuntimeSet = class {
   has(key) {
     return this.entries.has(key);
   }
+  *values() {
+    for (const entry of this.entries.values()) yield entry.raw;
+  }
   add(key, raw, reference) {
     if (this.entries.has(key)) return;
     this.entries.set(key, { raw, reference });
@@ -21440,7 +21445,14 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
   for (let index = 0; index < argumentValues.length; index += 1) {
     const parameter3 = parameters[index];
     if (parameter3 === void 0) continue;
-    scope.setLocal(parameter3.id, argumentValues[index]);
+    scope.setLocal(
+      parameter3.id,
+      coerceAssignmentValue(
+        argumentValues[index],
+        parameter3.typeInfo,
+        "getter argument"
+      )
+    );
   }
   try {
     const result = evalBody(
@@ -21450,9 +21462,11 @@ function evaluateNSGetterWithEffects(getter, ctx, argumentValues = [], options =
       evaluationOptions(runtimeCtx, false)
     );
     if (result.kind === "return") {
-      if (getter.typeInfo.type === 20 /* Decimal */ && typeof result.value === "number") {
-        result.value = coerceDecimalOperand(result.value, "return");
-      }
+      result.value = coerceAssignmentValue(
+        result.value,
+        getter.typeInfo,
+        "return"
+      );
       if (ownsInvocationState) {
         flushRuntimeSets(runtimeCtx);
         result.value = exportRuntimeSetValue(result.value, runtimeCtx);
@@ -22324,7 +22338,11 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
     const parameter3 = action.parameters[index + 2];
     const runtimeTypeInfo = runtimeArgumentTypes[index];
     const value2 = asDeclaredRuntimeSet(
-      restoreExportedReferences(filledArgs[index], runtimeTypeInfo, ctx),
+      coerceAssignmentValue(
+        restoreExportedReferences(filledArgs[index], runtimeTypeInfo, ctx),
+        runtimeTypeInfo,
+        "function argument"
+      ),
       runtimeTypeInfo,
       ctx
     );
@@ -22358,9 +22376,7 @@ function executeCompiledFunction(action, ctx, args, allowFallthroughReturn, runt
     }
     return null;
   }
-  if (runtimeReturnType.type === 20 /* Decimal */ && typeof value === "number") {
-    value = coerceDecimalOperand(value, "function return");
-  }
+  value = coerceAssignmentValue(value, runtimeReturnType, "function return");
   if (!runtimeValueMatchesType(value, runtimeReturnType, ctx)) {
     throw new NSGetterRuntimeError(
       "NSFunction returned a value that does not match its compiled return type."
@@ -22702,9 +22718,11 @@ function evalInstructions(instructions, scope, ctx, options) {
         }
         case "variable" /* variable */: {
           let value = evalPointer(ins.variable.pointer, scope, ctx);
-          if (ins.variable.typeInfo.type === 20 /* Decimal */ && typeof value === "number") {
-            value = coerceDecimalOperand(value, "variable initialization");
-          }
+          value = coerceAssignmentValue(
+            value,
+            ins.variable.typeInfo,
+            "variable initialization"
+          );
           value = asDeclaredRuntimeSet(value, ins.variable.typeInfo, ctx);
           scope.setLocal(ins.variable.id, value);
           break;
@@ -22740,9 +22758,11 @@ function evalInstructions(instructions, scope, ctx, options) {
         }
         case "assign" /* assign */: {
           let value = evalPointer(ins.pointer, scope, ctx);
-          if (ins.target.typeInfo.type === 20 /* Decimal */ && typeof value === "number") {
-            value = coerceDecimalOperand(value, "assignment");
-          }
+          value = coerceAssignmentValue(
+            value,
+            ins.target.typeInfo,
+            "assignment"
+          );
           if (ins.target.pointer.type === "variable" /* variable */) {
             assertVariableBindingWritable(scope, ins.target.pointer.variableId);
             scope.setLocal(ins.target.pointer.variableId, value);
@@ -24524,6 +24544,21 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     );
   }
   const args = ins.args.map((arg) => evalPointer(arg, scope, ctx));
+  const decimalEntries = "entryTypeInfo" in ins.target.typeInfo && ins.target.typeInfo.entryTypeInfo.type === 20 /* Decimal */;
+  let entryArgumentIndex = null;
+  const dictionary = ins.target.typeInfo.type === 5 /* Dictionary */;
+  if (ins.mutation === "Add" /* Add */)
+    entryArgumentIndex = dictionary ? 1 : 0;
+  if (ins.mutation === "Insert" /* Insert */) entryArgumentIndex = 1;
+  if (ins.mutation === "Remove" /* Remove */ && !dictionary)
+    entryArgumentIndex = 0;
+  if (entryArgumentIndex !== null && "entryTypeInfo" in ins.target.typeInfo) {
+    args[entryArgumentIndex] = coerceAssignmentValue(
+      args[entryArgumentIndex],
+      ins.target.typeInfo.entryTypeInfo,
+      "collection mutation entry"
+    );
+  }
   const setEntryMember = mutatesLocalVariable ? null : storedSetEntryMember(targetValue, ctx);
   const isLookupSet = setEntryMember === null && ins.target.typeInfo.type === 9 /* Lookup */;
   if (isLookupSet && Array.isArray(targetValue)) {
@@ -24531,7 +24566,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       targetValue,
       ins.reference === true,
       ins.target.typeInfo.type === 9 /* Lookup */ && (ins.target.typeInfo.entryTypeInfo.type === 8 /* Enum */ || ins.target.typeInfo.entryTypeInfo.type === 18 /* DialogueLookup */),
-      ctx
+      ctx,
+      decimalEntries
     );
   }
   const setMatch = setEntryMember !== null && Array.isArray(targetValue) && (ins.mutation === "Add" /* Add */ || ins.mutation === "Remove" /* Remove */) ? findStoredSetEntry(targetValue, args[0], setEntryMember, ctx) : null;
@@ -24550,7 +24586,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       ctx,
       isLookupSet,
       false,
-      ins.reference === true
+      ins.reference === true,
+      decimalEntries
     );
     updateCollectionReferenceProvenance(
       targetValue,
@@ -24628,7 +24665,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     ctx,
     isLookupSet,
     ins.reference !== true && ins.mutation === "Remove" /* Remove */ && isArrayCollection(targetValue) && setEntryMember === null && !isLookupSet && findKnownRowIdByValueReference(args[0], ctx) === null,
-    ins.reference === true
+    ins.reference === true,
+    setEntryMember === null && decimalEntries
   );
   updateCollectionReferenceProvenance(
     targetValue,
@@ -24904,21 +24942,28 @@ function asDeclaredRuntimeSet(value, type, ctx) {
     value,
     entry === 7 /* Class */ || entry === 22 /* Interface */ || entry === 6 /* List */ || entry === 5 /* Dictionary */ || entry === 9 /* Lookup */,
     entry === 8 /* Enum */ || entry === 18 /* DialogueLookup */,
-    ctx
+    ctx,
+    entry === 20 /* Decimal */
   );
 }
 function runtimeSetKey(value, set, ctx) {
   if (set.slotReferences !== null) return slotReferenceKey(value);
   if (set.enumEntries && Array.isArray(value) && value.length === 1)
     value = value[0];
-  return toSetEntryKey(value, null, set.reference, ctx);
+  return toSetEntryKey(value, null, set.reference, ctx, set.decimalEntries);
 }
-function runtimeSet(array2, reference, enumEntries, ctx) {
+function runtimeSet(array2, reference, enumEntries, ctx, decimalEntries = false) {
   const sets = ctx.__runtimeSets ??= /* @__PURE__ */ new WeakMap();
   ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set();
   const existing = sets.get(array2);
   if (existing !== void 0) return existing;
-  const set = new RuntimeSet(array2, reference, enumEntries);
+  const set = new RuntimeSet(
+    array2,
+    reference,
+    enumEntries,
+    null,
+    decimalEntries
+  );
   const references = collectionReferences(array2, ctx);
   for (let index = 0; index < array2.length; index++) {
     const raw = array2[index];
@@ -25037,7 +25082,7 @@ function removableEntryRowIds(targetValue, mutation, args, ctx) {
   }
   return rowIds;
 }
-function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false, resolveRemovalEntries = false, reference = false) {
+function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique = false, resolveRemovalEntries = false, reference = false, decimal = false) {
   if (targetValue instanceof RuntimeSet) {
     (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(targetValue);
     switch (mutation) {
@@ -25089,6 +25134,7 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
     case "Remove" /* Remove */:
       if (Array.isArray(targetValue)) {
         const references = resolveRemovalEntries ? collectionReferences(targetValue, ctx) : recordedReferenceEntries(targetValue, ctx) ?? 1 /* Values */;
+        const targetKey = decimal ? decimalCollectionKey(args[0]) : args[0];
         let index = -1;
         for (let candidate = 0; candidate < targetValue.length; candidate += 1) {
           const entry = targetValue[candidate];
@@ -25099,10 +25145,8 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
             }
             continue;
           }
-          if (jsEqual(
-            typeof entry === "string" && isReferenceEntry(references, candidate) ? resolveValueIfId(entry, ctx) : entry,
-            args[0]
-          )) {
+          const value = typeof entry === "string" && isReferenceEntry(references, candidate) ? resolveValueIfId(entry, ctx) : entry;
+          if (jsEqual(decimal ? decimalCollectionKey(value) : value, targetKey)) {
             index = candidate;
             break;
           }
@@ -25589,12 +25633,22 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
     case "function" /* function */:
       return evalFunction(pointer.function, scope, ctx);
     case "listLiteral" /* listLiteral */:
-      return pointer.entries.map((e) => evalPointer(e, scope, ctx));
+      return pointer.entries.map(
+        (entry) => coerceAssignmentValue(
+          evalPointer(entry, scope, ctx),
+          pointer.typeInfo.entryTypeInfo,
+          "list entry"
+        )
+      );
     case "dictLiteral" /* dictLiteral */: {
       const out = {};
       for (const e of pointer.entries) {
         const k = evalPointer(e.key, scope, ctx);
-        out[String(k)] = evalPointer(e.value, scope, ctx);
+        out[String(k)] = coerceAssignmentValue(
+          evalPointer(e.value, scope, ctx),
+          pointer.typeInfo.entryTypeInfo,
+          "dictionary entry"
+        );
       }
       return out;
     }
@@ -27257,9 +27311,9 @@ function readRecordKey(receiver, k, memberId, ctx) {
     if (receiver === ctx.thisValue && typeof ctx.thisValueRowId === "string") {
       return ctx.thisValueRowId;
     }
-    const rowId = findKnownRowIdByValueReference(receiver, ctx);
-    if (rowId) return rowId;
-    throw new NSGetterRuntimeError("Class value has no backing row id.");
+    const row = trackedRowForValueReference(receiver, ctx);
+    if (row !== null && classIdForValueRow(row, ctx) !== void 0)
+      return row.id;
   }
   const assetMember = resolveAssetRuntimeMember(receiver, k, ctx);
   if (assetMember.kind === "ok") return assetMember.value;
@@ -28690,7 +28744,11 @@ function evalDecimalMathOp(info, fn, scope, ctx) {
   }
 }
 function evalListRepeat(info, scope, ctx) {
-  const value = evalPointer(info.valuePointer, scope, ctx);
+  const value = coerceAssignmentValue(
+    evalPointer(info.valuePointer, scope, ctx),
+    info.entryTypeInfo,
+    "List.Repeat entry"
+  );
   const count = numberArg(
     evalPointer(info.countPointer, scope, ctx),
     "List.Repeat count"
@@ -28778,13 +28836,18 @@ function jsEqual(a, b) {
     return a instanceof NSSlotReference && b instanceof NSSlotReference && a.targetId === b.targetId;
   }
   if (a === b) return true;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-      if (!jsEqual(a[i], b[i])) return false;
+  if (Array.isArray(a) || a instanceof RuntimeSet) {
+    if (!Array.isArray(b) && !(b instanceof RuntimeSet)) return false;
+    const aSize = a instanceof RuntimeSet ? a.size : a.length;
+    const bSize = b instanceof RuntimeSet ? b.size : b.length;
+    if (aSize !== bSize) return false;
+    const other = b.values();
+    for (const entry of a.values()) {
+      if (!jsEqual(entry, other.next().value)) return false;
     }
     return true;
   }
+  if (b instanceof RuntimeSet) return false;
   if (typeof a === "object" && typeof b === "object" && a !== null && b !== null && !Array.isArray(a) && !Array.isArray(b)) {
     const aKeys = Object.keys(a);
     const bKeys = Object.keys(b);
@@ -29220,7 +29283,8 @@ function evalCollectionQuery(info, scope, ctx) {
       output,
       info.reference === true,
       info.enumEntries === true,
-      ctx
+      ctx,
+      info.decimalEntries === true
     ) : output;
   };
   if (info.op === "OrderBy" || info.op === "OrderByDescending") {
@@ -29272,7 +29336,8 @@ function evalCollectionQuery(info, scope, ctx) {
           entry,
           valueId,
           info.reference === true,
-          ctx
+          ctx,
+          info.decimalEntries === true
         );
         if (seenSetKeys.has(setKey)) return 0 /* Continue */;
         seenSetKeys.add(setKey);
@@ -29327,10 +29392,15 @@ function evalCollectionQuery(info, scope, ctx) {
   }
   return finish();
 }
-function toSetEntryKey(entry, valueId, reference, ctx) {
+function toSetEntryKey(entry, valueId, reference, ctx, decimal = false) {
   if (reference) return valueId ?? referenceIdOf(entry, ctx) ?? entry;
+  if (decimal) return decimalCollectionKey(entry);
   return typeof entry === "object" && entry !== null ? canonicalJsonStringify(entry) : entry;
 }
+function decimalCollectionKey(value) {
+  if (value === null) return null;
+  return decimalKey(coerceDecimalOperand(value, "decimal collection entry"));
+}
 function compareCollectionKeys(left, right, keyType) {
   if (left === null) return right === null ? 0 : -1;
   if (right === null) return 1;
@@ -29448,7 +29518,11 @@ function evalFunction(fn, scope, ctx) {
     }
     case "contains" /* contains */: {
       let c = evalPointer(fn.info.collectionPointer, scope, ctx);
-      const target = evalPointer(fn.info.valuePointer, scope, ctx);
+      let target = evalPointer(fn.info.valuePointer, scope, ctx);
+      if (fn.info.float === true && typeof target === "number")
+        target = Math.fround(target);
+      if (fn.info.decimal === true && target !== null)
+        target = coerceDecimalOperand(target, "collection search");
       if (typeof c === "string") {
         if (typeof target !== "string") {
           throw new NSGetterRuntimeError(
@@ -29481,9 +29555,13 @@ function evalFunction(fn, scope, ctx) {
         return referenceIndexOf(c, target, ctx) !== null;
       }
       const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
+      const targetKey = fn.info.decimal ? decimalCollectionKey(target) : target;
       let containsResolvedEntry = false;
       iterateCollection(c, ctx, (entry, _key, valueId) => {
-        if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
+        if (valueId !== null && valueId === targetReferenceId || jsEqual(
+          fn.info.decimal ? decimalCollectionKey(entry) : entry,
+          targetKey
+        )) {
           containsResolvedEntry = true;
           return 1 /* Break */;
         }
@@ -29496,15 +29574,21 @@ function evalFunction(fn, scope, ctx) {
         evalPointer(fn.info.collectionPointer, scope, ctx),
         "IndexOf receiver"
       );
-      const target = evalPointer(fn.info.valuePointer, scope, ctx);
+      let target = evalPointer(fn.info.valuePointer, scope, ctx);
+      if (fn.info.float === true && typeof target === "number")
+        target = Math.fround(target);
       if (fn.info.reference === true) {
         const index = referenceIndexOf(collection, target, ctx);
         return index === null ? -1 : numberArg(index, "IndexOf index");
       }
       const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
+      const targetKey = fn.info.decimal ? decimalCollectionKey(target) : target;
       let found = -1;
       iterateCollection(collection, ctx, (entry, key, valueId) => {
-        if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
+        if (valueId !== null && valueId === targetReferenceId || jsEqual(
+          fn.info.decimal ? decimalCollectionKey(entry) : entry,
+          targetKey
+        )) {
           found = numberArg(key, "IndexOf index");
           return 1 /* Break */;
         }
@@ -29712,7 +29796,19 @@ function evalFunction(fn, scope, ctx) {
         );
         iterateCollection(c, ctx, callback);
       }
-      if (found !== sentinel) return found;
+      if (found !== sentinel) {
+        if (typeof found === "string") {
+          if (c instanceof RuntimeSet) {
+            if (c.enumEntries) return [found];
+          } else {
+            const row = trackedRowForValueReference(c, ctx);
+            const member = row === null ? null : memberForValueRow(row, ctx);
+            if (member?.kind === 8 /* Enum */ || member?.kind === 18 /* DialogueLookup */)
+              return [found];
+          }
+        }
+        return found;
+      }
       if (fn.type === "first" /* first */) {
         throw new NSGetterRuntimeError(
           innerFn ? "First() found no matching entry. Use FirstOrDefault() and handle null if no match is expected." : "First() called on an empty collection. Check that it has entries, or use FirstOrDefault() and handle null."
@@ -30926,10 +31022,19 @@ function constructionInitEvaluator(ctx, createdValues, argumentScopes, construct
     }
     return null;
   };
+  const defaultScopeMemberId = (memberId) => walkExtendsMemberChain(
+    memberId,
+    ctx.vm.members,
+    (declaration) => declaration.defaultValue === void 0 ? void 0 : declaration.id,
+    {
+      memberById: (id) => indexes4.schemaIndex.member(id) ?? null,
+      maxHops: ctx.vm.members.length
+    }
+  );
   return (member, init, sourceValueId, genericEnv = instanceEnv) => {
     const memberId = Reflect.get(member, "id");
     const effectiveMemberId = typeof memberId === "string" ? memberId : null;
-    const scopeMemberId = indexes4.initializerScopeMemberIds.get(init) ?? (typeof sourceValueId !== "string" ? void 0 : indexes4.initializerScopeMemberIdsByValueId.get(sourceValueId)) ?? effectiveMemberId;
+    const scopeMemberId = indexes4.initializerScopeMemberIds.get(init) ?? (typeof sourceValueId !== "string" ? void 0 : indexes4.initializerScopeMemberIdsByValueId.get(sourceValueId)) ?? (sourceValueId === void 0 && effectiveMemberId !== null ? defaultScopeMemberId(effectiveMemberId) : void 0) ?? effectiveMemberId;
     const compiled = ensureInitializerCompiled({
       init,
       member,
@@ -50069,7 +50174,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         scope
       )
     );
-    const schemaClassInfo = toWireType(targetType, this.project);
+    const schemaClassInfo = this.constructorWireType(targetType, expression);
     if (schemaClassInfo.type !== 7 /* Class */) {
       throw new Error(
         `NeoScript constructor ${className} has non-Class return type ${this.describe(signature.returnType)}.`
@@ -50087,6 +50192,16 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       writability: "session" /* Session */
     };
   }
+  /** Constructor storage arguments stay distinct from their expression read types. */
+  constructorWireType(target, expression) {
+    const typeArguments = expression.typeArguments?.map(
+      (argument2) => resolveStoredReferenceTarget(argument2, this.context, this.project)
+    );
+    return toWireType(
+      typeArguments === void 0 ? target : { ...target, typeArguments },
+      this.project
+    );
+  }
   constructorTargetType(schemaClass2, expression, expected) {
     const typeArguments = expression.typeArguments?.map(
       (argument2) => this.resolveType(argument2)
@@ -50217,7 +50332,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       scope
     );
     const classType = targetType;
-    const schemaClassInfo = toWireType(classType, this.project);
+    const schemaClassInfo = this.constructorWireType(classType, expression);
     if (schemaClassInfo.type !== 7 /* Class */) {
       throw new Error(
         `NeoScript declared constructor ${className} projected a non-Class wire type.`
@@ -51080,6 +51195,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         {
           collectionPointer: receiver.pointer,
           valuePointer: value.pointer,
+          ...isPrimitive(expectedValueType, "float") ? { float: true } : {},
+          ...isPrimitive(expectedValueType, "decimal") ? { decimal: true } : {},
           ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
         },
         { kind: "primitive", name: "int" }
@@ -51109,6 +51226,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         {
           collectionPointer: receiver.pointer,
           valuePointer: value.pointer,
+          ...isPrimitive(expectedValueType, "float") ? { float: true } : {},
+          ...isPrimitive(expectedValueType, "decimal") ? { decimal: true } : {},
           ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
         },
         { kind: "primitive", name: "bool" }
@@ -51341,6 +51460,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         info = {
           ...base,
           op: name,
+          ...isPrimitive(collection.valueType, "decimal") ? { decimalEntries: true } : {},
           ...hasReferenceEquality(collection.valueType, this.project) ? { reference: true } : {}
         };
         resultType = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.84.3",
+  "version": "0.84.4",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.84.3 -->
+<!-- reviewed-through-cli: 0.84.4 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/cli-development.md

@@ -129,7 +129,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.84.3 -->
+<!-- reviewed-through-cli: 0.84.4 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

package/skills/neocompose-cli/references/commands-and-sync.md

@@ -335,6 +335,9 @@ Generated animation clip targets and reference lookup factories retain construct
 generic arguments, including supported forwarded bindings. Clip getters use the
 declared target type when the owner is a derived class. Export reports an error
 when a clip target does not match the owner or one of its constructed base types.
+Inherited collection interface getters preserve supported detached temporaries.
+Constructed entries such as `Frame<T>` use the interface's generic argument
+family for both their collection type and value converters.
 New instances that reuse existing member-localized text retain its shared ID
 and translations in the export.
 

package/skills/neocompose-cli/references/declarations-and-construction.md

@@ -425,6 +425,10 @@ value-level target metadata.
 
 ## Computed initializers and declared constructors
 
+Inherited member initializers read parameters from the constructor that declared
+them, including when export materialization clones their bodies. A storage-only
+override keeps that original constructor scope.
+
 Use an expression initializer when a member default must be evaluated during
 construction rather than stored as a closed literal. It is replayed for omitted
 members in push, web, and SDK contexts. A stored override remains pinned until

package/skills/neocompose-cli/references/neoscript.md

@@ -224,7 +224,8 @@ unconstrained generic `T` compares by value.
 Calling `Equals(other)` on a non-null generic value dynamically uses the
 runtime Class's one-argument `Equals` Function or NSFunction when it returns
 `bool`, including the effective override. Values without that member fall back
-to value equality.
+to value equality. For local sets, that fallback compares their current entries
+in insertion order, regardless of prior reads or mutations.
 
 Object initializers are available in method bodies and `.spec.neo` tests:
 
@@ -387,6 +388,11 @@ may be null. The receiver stays unchanged.
 return "banana".Replace("a", "o"); // "bonono"
 ```
 
+Integer inputs assigned to `float` round to float32. This also applies to
+function arguments and returns, collection entries, and `List.Repeat` with a
+float entry type. `Contains` and `IndexOf` on float collections also convert
+integer search arguments. Nullable assignments preserve `null`.
+
 ## Collection builtins
 
 Lists expose their size as either `items.Count` or `items.Count()`. Use
@@ -399,8 +405,9 @@ Use `Any()` or `Any((item) => predicate)` to check for a match, and
 `All((item) => predicate)` to check every entry. Both short-circuit; an empty
 collection has `Any() == false` and `All(...) == true`.
 
-`Last`, `LastOrDefault`, `Single`, and `SingleOrDefault` accept zero arguments
-or one predicate. `Last` throws when no entry matches. `Single` throws unless
+`First`, `FirstOrDefault`, `Last`, `LastOrDefault`, `Single`, and `SingleOrDefault` accept zero arguments
+or one predicate. `First` and `Last` throw when no entry matches. Enum sets
+return enum values, including when a predicate selects the entry. `Single` throws unless
 exactly one matches; `SingleOrDefault` still throws for multiple matches.
 The `OrDefault` forms return nullable entries and use `null` for no match.
 
@@ -711,3 +718,7 @@ and may appear in any order. Use the existing nested positional override for a
 virtual owner; changing its listeners alone must not add a value override.
 Omitting a field inherits its listeners. An empty array suppresses inherited
 listeners and disappears when there is no inherited wiring to suppress.
+
+Decimal collection membership compares numeric values: `1.0` and `1.00` are
+equal for `ToSet`, `Contains`, `IndexOf`, `Add`, and `Remove`. Decimal scale
+is retained for display; string entries such as `"1.0"` and `"1.00"` stay distinct.

package/skills/neocompose-cli/references/values-identities-and-references.md

@@ -190,6 +190,13 @@ EligibleIngredients = root.Assets.Crafting.FurnaceRecipes
   .ToSet()
 ```
 
+`Box<Reference<Item>>` keeps its reference storage type through push and pull,
+including explicit `new Box<Reference<Item>>()` calls. Its `Item` targets stay
+shared; reading a class reference still produces the class value. A derived
+construction in a base-typed slot retains reference bindings forwarded through
+the inheritance chain, such as `Base<Reference<Item>>` holding
+`new Derived<Reference<Item>>()`.
+
 Writing `Reference(recipe.Ingredient)` inside the callback is also valid.
 `Reference(value)` preserves an evaluated class value and its identity; it does
 not clone it or turn it into a separate wrapper object. An optional generic
@@ -276,6 +283,10 @@ that instance. Leaving the emitted construction unchanged creates no redundant
 value rows. A nullable member with no default remains bare; an explicit null
 default emits `= null`.
 
+Changing a construction to another overload or shared argument rebuilds the
+instance even when the argument values compare equal. Owned inline arguments
+still compare by contents; unchanged shared arguments keep their identities.
+
 Spelling an unchanged child default, such as `FPS = 8`, stays a no-op after
 push even when sibling fields own stored rows. Adding a different child default
 preserves those siblings' row identities; it does not transfer their ownership.
@@ -399,3 +410,8 @@ is an error; remove the declaration to request deletion.
 New schema getters referenced by NeoFlow interpolation need no `@id`. Export and
 `neo dev` assign the same identity to the declaration and its references, including
 inherited getters. Repeated exports and the next push reuse the export identity ledger.
+
+Dictionary string keys are data. An entry named `"Id"` reads its value through
+`dictionary["Id"]`; class `.Id` continues to return the class instance identity.
+
+You can remove a constructor and replace every call to it in the same edit. Push prepares the new calls together with the schema change and removes argument rows owned by the old constructions.