@neocompose/cli 0.84.2 → 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 });
@@ -21257,6 +21262,7 @@ function createdSessionValuesSince(ctx, checkpoint) {
   return created;
 }
 function exportInitializerCollections(created, writes, ctx) {
+  const inPlace = (value) => value instanceof RuntimeSet ? exportRuntimeSetValue(value, ctx) : value;
   const assignedValues = /* @__PURE__ */ new Set();
   const mutatedIds = /* @__PURE__ */ new Set();
   for (const write of writes) {
@@ -21264,83 +21270,134 @@ function exportInitializerCollections(created, writes, ctx) {
     if (destination !== void 0 && "containerValueId" in destination)
       mutatedIds.add(destination.containerValueId);
     if (write.kind === "assign" && write.valueId === void 0 && typeof write.value === "object" && write.value !== null) {
-      assignedValues.add(write.value);
+      assignedValues.add(inPlace(write.value));
     }
   }
   const candidates = /* @__PURE__ */ new Set();
+  const inlineFieldsByRowId = /* @__PURE__ */ new Map();
   for (const row of created) {
-    if (assignedValues.has(row.value) || row.classId === void 0 && mutatedIds.has(row.id) || Array.isArray(row.value) && row.value.length > 0 && ctx.__unorderedListProjections?.byContainerId.has(row.id)) {
+    const inlineFields = inlineCollectionFields(row, ctx);
+    if (inlineFields !== null) inlineFieldsByRowId.set(row.id, inlineFields);
+    if (inlineFields !== null || assignedValues.has(inPlace(row.value)) || row.classId === void 0 && mutatedIds.has(row.id) || Array.isArray(row.value) && row.value.length > 0 && ctx.__unorderedListProjections?.byContainerId.has(row.id)) {
       candidates.add(row.id);
     }
   }
   if (candidates.size === 0) return created;
   invalidateEvaluatorIndexes(ctx, null);
   const extra = [];
-  const exported = created.map((row) => {
-    if (!candidates.has(row.id)) return row;
-    const member = memberForValueRow(row, ctx);
-    if (member === null) return row;
-    if (!isMemberWithEntries(member)) return row;
-    if (isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */) {
-      return { ...row, value: [] };
-    }
-    if (!assignedValues.has(row.value) && !mutatedIds.has(row.id)) return row;
-    const values = [];
+  const encode = (member, value, genericEnv, collectionOwnerId) => {
+    const rows = [];
     const declarations = /* @__PURE__ */ new Map();
-    const genericEnv = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
-    overlayConcreteGenericEntries(
-      genericEnv,
-      envFromStamp(row.genericBindings)
-    );
-    const materialized = materializeConstructorArgumentValue({
+    const root = materializeConstructorArgumentValue({
       member,
-      value: row.value,
+      value,
       genericEnv,
       ctx,
-      createdValues: values,
+      createdValues: rows,
       createdById: /* @__PURE__ */ new Map(),
       storageKeyDeclarations: declarations,
-      collectionEntriesAreReferences: assignedValues.has(row.value) ? false : void 0,
-      collectionOwnerId: row.id
+      collectionEntriesAreReferences: assignedValues.has(value) ? false : void 0,
+      collectionOwnerId
     });
-    const encoded = { ...row, value: materialized.value };
-    const children = values.filter((value) => value !== materialized);
-    declarations.delete(materialized.id);
-    const groupId = constructorGroupForRow(row.id, ctx);
-    retargetConstructorGroupDependencies(
-      materialized.id,
-      groupId ?? row.id,
-      ctx
-    );
+    const children = rows.filter((row) => row !== root);
+    return { root, children, declarations };
+  };
+  const adopt = (owner, rootId, rows, declarations) => {
+    const groupId = constructorGroupForRow(owner.id, ctx);
+    retargetConstructorGroupDependencies(rootId, groupId ?? owner.id, ctx);
     if (groupId !== null) {
       const state = ctx.__executionState;
       const group = state?.constructorGroups.get(groupId);
-      for (const child of children) {
-        retargetConstructorGroupDependencies(child.id, groupId, ctx);
-        group?.add(child.id);
-        state?.constructorGroupByRowId.set(child.id, groupId);
+      for (const row of rows) {
+        retargetConstructorGroupDependencies(row.id, groupId, ctx);
+        group?.add(row.id);
+        state?.constructorGroupByRowId.set(row.id, groupId);
       }
     }
-    stampCreatedValuesMapKey(children, row.mapKey);
+    stampCreatedValuesMapKey(rows, owner.mapKey);
     applyDeclaredStorageKeyOverrides({
-      createdValues: [encoded, ...children],
+      createdValues: [owner, ...rows],
       declarationByValueId: declarations
     });
-    for (const child of children) {
-      if (!isLiteralValueContent(child)) {
+    for (const row of rows) {
+      if (!isLiteralValueContent(row)) {
         throw new NSGetterRuntimeError(
           "Initializer collection produced an unevaluated row."
         );
       }
-      extra.push(child);
+      extra.push(row);
     }
     for (const [id, declaration] of declarations) {
       ctx.__createdStorageKeyDeclarations?.set(id, declaration);
     }
+  };
+  const exported = created.map((row) => {
+    if (!candidates.has(row.id)) return row;
+    const inlineFields = inlineFieldsByRowId.get(row.id);
+    if (inlineFields !== void 0) {
+      const record4 = { ...inlineFields.record };
+      const encoded2 = { ...row, value: record4 };
+      for (const [key, member2] of inlineFields.members) {
+        const { root: root2, children: children2, declarations: declarations2 } = encode(
+          member2,
+          inPlace(record4[key]),
+          inlineFields.genericEnv
+        );
+        record4[key] = root2.id;
+        adopt(encoded2, root2.id, [root2, ...children2], declarations2);
+      }
+      return encoded2;
+    }
+    const member = memberForValueRow(row, ctx);
+    if (member === null) return row;
+    if (!isMemberWithEntries(member)) return row;
+    if (isMemberEntryCollectionBase(member) && listKindOf(member) === 1 /* Unordered */) {
+      return { ...row, value: [] };
+    }
+    const value = inPlace(row.value);
+    if (!assignedValues.has(value) && !mutatedIds.has(row.id)) return row;
+    const { root, children, declarations } = encode(
+      member,
+      value,
+      rowGenericEnv(row, ctx),
+      row.id
+    );
+    const encoded = { ...row, value: root.value };
+    declarations.delete(root.id);
+    adopt(encoded, root.id, children, declarations);
     return encoded;
   });
   return [...exported, ...extra];
 }
+function inlineCollectionFields(row, ctx) {
+  if (typeof row.classId !== "string") return null;
+  if (!isPlainRecord(row.value)) return null;
+  let fields = null;
+  for (const key in row.value) {
+    const value = row.value[key];
+    if (typeof value !== "object" || value === null) continue;
+    const rawMember = memberForCustomSchemaValue(row.classId, key, ctx);
+    if (rawMember === null) continue;
+    fields ??= {
+      record: row.value,
+      members: /* @__PURE__ */ new Map(),
+      genericEnv: rowGenericEnv(row, ctx)
+    };
+    const member = substituteMember(
+      rawMember,
+      fields.genericEnv,
+      ctx.vm.members,
+      cachedResolvedMember(rawMember, ctx)
+    );
+    if (isMemberWithEntries(member)) fields.members.set(key, member);
+  }
+  return fields === null || fields.members.size === 0 ? null : fields;
+}
+function rowGenericEnv(row, ctx) {
+  const genericEnv = runtimeGenericEnvForValueRow(row, ctx, /* @__PURE__ */ new Set());
+  overlayConcreteGenericEntries(genericEnv, envFromStamp(row.genericBindings));
+  return genericEnv;
+}
 function prepareSessionValueExport(ctx, checkpoint, writes) {
   const created = createdSessionValuesSince(ctx, checkpoint);
   if (created.length === 0) return;
@@ -21388,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(
@@ -21398,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);
@@ -22272,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
     );
@@ -22306,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."
@@ -22650,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;
@@ -22688,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);
@@ -24472,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)) {
@@ -24479,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;
@@ -24498,7 +24586,8 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       ctx,
       isLookupSet,
       false,
-      ins.reference === true
+      ins.reference === true,
+      decimalEntries
     );
     updateCollectionReferenceProvenance(
       targetValue,
@@ -24576,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,
@@ -24852,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];
@@ -24985,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) {
@@ -25037,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];
@@ -25047,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;
           }
@@ -25537,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;
     }
@@ -27205,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;
@@ -28638,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"
@@ -28726,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);
@@ -29168,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") {
@@ -29220,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);
@@ -29275,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;
@@ -29396,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(
@@ -29429,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 */;
         }
@@ -29444,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 */;
         }
@@ -29660,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."
@@ -30874,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,
@@ -32875,6 +33032,7 @@ function clonedConstructorProvenance(source) {
 }
 function cloneConstructorLiteralValue(value) {
   if (typeof value !== "object" || value === null) return value;
+  if (value instanceof NSSlotReference) return value.targetId;
   if (Array.isArray(value)) {
     return value.map((entry) => cloneConstructorLiteralValue(entry));
   }
@@ -37136,7 +37294,7 @@ var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
           const typeInfo = parameterTypes.get(parameterId);
           return [
             parameterId,
-            typeInfo !== void 0 && isAggregateTypeInfo(typeInfo) && typeof argument2 === "string" ? rewriteId(argument2) : argument2
+            typeInfo !== void 0 && (isAggregateTypeInfo(typeInfo) || typeInfo.type === 29 /* Reference */) && typeof argument2 === "string" ? rewriteId(argument2) : argument2
           ];
         }
       )
@@ -37172,6 +37330,41 @@ var MaterializedValueGraphContext = class _MaterializedValueGraphContext {
       ids.push(edge.targetValueId);
     return ids;
   }
+  /** The targets a row's Reference creation data names (P112 §1.1). */
+  referenceArgumentIds(row) {
+    if (!isLiteralValueContent(row)) return [];
+    const args = row.constructorArgs;
+    if (args === void 0 || args === null) return [];
+    const ids = [];
+    for (const parameterId of this.referenceParameterIds(row)) {
+      const argument2 = args[parameterId];
+      if (typeof argument2 === "string") ids.push(argument2);
+    }
+    return ids;
+  }
+  /** Creation data with each Reference argument's target remapped (P112 §1.1). */
+  remapReferenceArguments(row, remap, contextualMember) {
+    const args = row.constructorArgs;
+    if (args === void 0 || args === null) return args;
+    let remapped;
+    for (const parameterId of this.referenceParameterIds(
+      row,
+      contextualMember
+    )) {
+      const argument2 = args[parameterId];
+      if (typeof argument2 !== "string") continue;
+      const target = remap(argument2);
+      if (target !== argument2) (remapped ??= { ...args })[parameterId] = target;
+    }
+    return remapped ?? args;
+  }
+  *referenceParameterIds(row, contextualMember) {
+    for (const [parameterId, typeInfo] of this.constructorParameterTypes(
+      row,
+      contextualMember
+    ))
+      if (typeInfo.type === 29 /* Reference */) yield parameterId;
+  }
   slotEntries(row) {
     const value = row.value;
     switch (this.referenceSlots(row.id, void 0, value)) {
@@ -38193,7 +38386,11 @@ function resolveVirtualInstanceGraph(args) {
         }
       }
     }
-    const virtualRow = rewriteExpandedRow(indexed, expansion);
+    const virtualRow = rewriteExpandedRow(
+      indexed,
+      expansion,
+      materializedGraph
+    );
     const location = {
       id: effectiveId2,
       instanceRootId: args.instanceRoot.id,
@@ -39447,7 +39644,7 @@ function indexExpansion(args) {
     membersById
   };
 }
-function rewriteExpandedRow(node, expansion) {
+function rewriteExpandedRow(node, expansion, graph) {
   const rewrite = (id) => expansion.nodesByExpandedId.get(id)?.virtualId ?? id;
   const row = cloneRow(node.expandedRow);
   row.id = node.virtualId;
@@ -39469,6 +39666,12 @@ function rewriteExpandedRow(node, expansion) {
   if (node.member.kind === 9 /* Lookup */) {
     row.value = remapLookupSelection(row.value, rewrite);
   }
+  if (isLiteralValueContent(row) && row.constructorArgs !== void 0)
+    row.constructorArgs = graph.remapReferenceArguments(
+      row,
+      rewrite,
+      node.member
+    );
   if (typeof row.containerId === "string") {
     row.containerId = rewrite(row.containerId);
   }
@@ -49971,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)}.`
@@ -49989,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)
@@ -50119,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.`
@@ -50982,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" }
@@ -51011,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" }
@@ -51243,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 = {
@@ -64110,13 +64328,29 @@ function memberSavedForStorage(ctx, memberId, contextSaved, declarationClassId)
     if (isWritableConstraint(classStorage)) return true;
     if (classStorage === 1 /* Immutable */) return false;
   }
-  const effective = ctx.storageResolver.effectiveStorages(memberId);
+  let effective = ctx.storageResolver.effectiveStorages(memberId);
+  const visited = /* @__PURE__ */ new Set([memberId]);
+  let currentId = memberId;
+  let baseId = member?.extendsMemberId;
+  while (effective.size === 0 && baseId !== void 0 && !visited.has(baseId)) {
+    if (!isResolvedAbstract(ctx, currentId) && !isResolvedAbstract(ctx, baseId))
+      break;
+    visited.add(baseId);
+    effective = ctx.storageResolver.effectiveStorages(baseId);
+    currentId = baseId;
+    baseId = ctx.exportData.members[baseId]?.extendsMemberId;
+  }
   const hasWritable = effective.has(2 /* Save */) || effective.has(3 /* Session */);
   const hasStatic = effective.has(1 /* Immutable */);
   if (hasWritable && !hasStatic) return true;
   if (hasStatic && !hasWritable) return false;
   return contextSaved;
 }
+function isResolvedAbstract(ctx, memberId) {
+  return isAbstractMember(
+    resolveMemberById(ctx, memberId, `members.${memberId}`)
+  );
+}
 function classAllowedStorage(ctx, classId) {
   return ctx.storageResolver.allowedStorage(classId);
 }
@@ -64998,7 +65232,7 @@ function typeInfoConstructedSuffix(ctx, typeInfo, saved, genericEnv, genericBind
     const argType = csharpTypeInfoValueType(
       ctx,
       argInfo,
-      saved,
+      true,
       genericEnv,
       genericBindingSaved
     );