@neocompose/cli 0.81.1 → 0.81.2

package/dist/test-worker.mjs

@@ -2339,6 +2339,16 @@ function neoScriptRegistryEntryType(typeName) {
   }
   return REGISTRY_ENTRY_TYPES[typeName] ?? null;
 }
+function typeArgumentArityMessage(typeName, expected, provided) {
+  return `Type '${typeName}' expects ${expected} type argument${expected === 1 ? "" : "s"}, but ${provided} ${provided === 1 ? "was" : "were"} provided.`;
+}
+function genericParameterArgumentsMessage(name) {
+  return `Generic parameter '${name}' cannot receive type arguments.`;
+}
+var NEOSCRIPT_DELEGATE_MAX_PARAMETERS = 16;
+function delegateArityMessage(provided) {
+  return `Type 'NeoDelegate' expects a return type followed by up to ${NEOSCRIPT_DELEGATE_MAX_PARAMETERS} parameter types, but ${provided} type arguments were provided.`;
+}
 function neoScriptRegistryReferenceType(entryTypeName) {
   for (const definition of Object.values(REGISTRY_ENTRY_TYPES)) {
     if (definition.entryType === entryTypeName) return definition.refType;
@@ -20010,15 +20020,9 @@ function evalActionListenerInstruction(ins, scope, ctx, options) {
   }
   let destination;
   const target = ins.target.pointer;
-  const currentValue = target.type === "keyOf" /* keyOf */ ? evalKeyOf(
-    target.keyOf,
-    scope,
-    ctx,
-    target.optional === true,
-    (resolved) => {
-      destination = resolved;
-    }
-  ) : evalPointer(target, scope, ctx);
+  const currentValue = target.type === "keyOf" /* keyOf */ ? evalKeyOf(target, scope, ctx, (resolved) => {
+    destination = resolved;
+  }) : evalPointer(target, scope, ctx);
   const current = actionListenersOf(currentValue, () => `'${operator}' target`);
   const identity = nsActionListenerIdentity(listener);
   const present = current.some(
@@ -20089,38 +20093,26 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
         );
       }
       receiver[index] = referenceValueId;
-      setCollectionReferenceProvenance(receiver, index, true, ctx);
+      recordWrittenEntry(receiver, index, true, ctx);
       invalidateEvaluatorIndexes(ctx, receiver);
       return;
     }
-    if (ctx.__unorderedListProjections?.referenceEntryIndexesByArray.has(
-      receiver
-    ) === true) {
-      receiver[index] = value;
-      setCollectionReferenceProvenance(receiver, index, false, ctx);
-      invalidateEvaluatorIndexes(ctx, receiver);
+    if (collectionReferences(receiver, ctx) === 0 /* RowIds */ && replaceEntryRowValue(
+      receiver,
+      receiver[index],
+      value,
+      targetTypeInfo,
+      ctx
+    ))
       return;
-    }
-    const existing2 = receiver[index];
-    if (typeof existing2 === "string") {
-      const row = evalValueById(
-        ctx,
-        existing2,
-        ctx.__runtimeSessionValues,
-        ctx.__valueOverlay
-      );
-      if (row !== null) {
-        replaceRowValue(row, value, receiver, ctx);
-        updateUnorderedListProjectionAfterAssignment(row, value, ctx);
-        return;
-      }
-    }
     receiver[index] = value;
+    recordWrittenEntry(receiver, index, false, ctx);
     invalidateEvaluatorIndexes(ctx, receiver);
     return;
   }
   const object = objectArg(receiver, "Assignment target");
   const stringKey = String(key);
+  const field = target.memberId !== void 0;
   if (referenceValueId !== null) {
     const parentId = findKnownRowIdByValueReference(receiver, ctx);
     if (parentId !== null) {
@@ -20135,26 +20127,41 @@ function applyOverlayAssignment(target, targetTypeInfo, value, scope, ctx, desti
       );
     }
     object[stringKey] = referenceValueId;
+    if (!field) recordWrittenEntry(object, stringKey, true, ctx);
     invalidateEvaluatorIndexes(ctx, receiver);
     return;
   }
-  const existing = object[stringKey];
-  if (typeof existing === "string") {
-    const row = evalValueById(
-      ctx,
-      existing,
-      ctx.__runtimeSessionValues,
-      ctx.__valueOverlay
-    );
-    if (row !== null) {
-      replaceRowValue(row, value, receiver, ctx);
-      updateUnorderedListProjectionAfterAssignment(row, value, ctx);
-      return;
-    }
-  }
+  if (collectionReferences(object, ctx) === 0 /* RowIds */ && replaceEntryRowValue(object, object[stringKey], value, targetTypeInfo, ctx))
+    return;
   object[stringKey] = value;
+  if (!field) recordWrittenEntry(object, stringKey, false, ctx);
   invalidateEvaluatorIndexes(ctx, receiver);
 }
+function replaceEntryRowValue(receiver, existing, value, targetTypeInfo, ctx) {
+  if (typeof existing !== "string") return false;
+  const row = evalValueById(
+    ctx,
+    existing,
+    ctx.__runtimeSessionValues,
+    ctx.__valueOverlay
+  );
+  if (row === null) return false;
+  keepAssignedCollectionValues(value, targetTypeInfo, ctx);
+  replaceRowValue(row, value, receiver, ctx);
+  updateUnorderedListProjectionAfterAssignment(row, value, ctx);
+  return true;
+}
+function keepAssignedCollectionValues(value, targetTypeInfo, ctx) {
+  const cache = unorderedListProjectionCache(ctx);
+  if (Array.isArray(value) && (targetTypeInfo.type === 6 /* List */ || targetTypeInfo.type === 28 /* Set */)) {
+    if (!cache.referenceEntryIndexesByArray.has(value))
+      cache.referenceEntryIndexesByArray.set(value, /* @__PURE__ */ new Set());
+    return;
+  }
+  if (targetTypeInfo.type === 5 /* Dictionary */ && typeof value === "object" && value !== null && !cache.referenceEntryKeysByRecord.has(value)) {
+    cache.referenceEntryKeysByRecord.set(value, /* @__PURE__ */ new Set());
+  }
+}
 function replaceRowValue(row, value, receiver, ctx) {
   const indexes3 = ctx.__indexes;
   if (indexes3 === void 0 || ctx.__runtimeSessionValues?.get(row.id) !== row || !indexes3.indexedRowIds.has(row.id)) {
@@ -20592,9 +20599,11 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     );
   }
   const unorderedEntriesBeforeMutation = unorderedContainerValueId === null || !Array.isArray(targetValue) || ins.mutation === "Add" /* Add */ ? null : [...targetValue];
-  if ((ins.mutation === "Add" /* Add */ || ins.mutation === "Insert" /* Insert */) && !isLookupSet) {
+  const writesEntry = (ins.mutation === "Add" /* Add */ || ins.mutation === "Insert" /* Insert */) && !isLookupSet;
+  let attachedValueId = null;
+  if (writesEntry) {
     const attachedValue = isArrayCollection(targetValue) && ins.mutation !== "Insert" /* Insert */ ? args[0] : args[1];
-    const attachedValueId = findKnownRowIdByValueReference(attachedValue, ctx);
+    attachedValueId = findKnownRowIdByValueReference(attachedValue, ctx);
     const parentId = findKnownRowIdByValueReference(targetValue, ctx);
     if (attachedValueId !== null && parentId !== null) {
       ctx.assertCollectionEntryAttachable?.(
@@ -20631,6 +20640,23 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
     removedIndex,
     ctx
   );
+  if (writesEntry && !(targetValue instanceof RuntimeSet)) {
+    const writtenAsRowId = attachedValueId !== null || unorderedContainerValueId !== null;
+    if (Array.isArray(targetValue))
+      recordWrittenEntry(
+        targetValue,
+        removedIndex ?? targetValue.length - 1,
+        writtenAsRowId,
+        ctx
+      );
+    else
+      recordWrittenEntry(
+        objectArg(targetValue, "Dictionary Add target"),
+        String(args[0]),
+        writtenAsRowId,
+        ctx
+      );
+  }
   if (unorderedEntriesBeforeMutation !== null && Array.isArray(targetValue)) {
     detachRemovedUnorderedScalarEntries(
       unorderedEntriesBeforeMutation,
@@ -20832,9 +20858,10 @@ function runtimeSet(array2, reference, enumEntries, ctx) {
   const existing = sets.get(array2);
   if (existing !== void 0) return existing;
   const set = new RuntimeSet(array2, reference, enumEntries);
+  const references = collectionReferences(array2, ctx);
   for (let index = 0; index < array2.length; index++) {
     const raw = array2[index];
-    const resolves = collectionEntryUsesReferenceResolution(array2, index, ctx);
+    const resolves = isReferenceEntry(references, index);
     const value = resolves ? resolveValueIfId(raw, ctx) : raw;
     const key = runtimeSetKey(value, set, ctx);
     set.add(key, enumEntries ? key : raw, !enumEntries && resolves);
@@ -20843,9 +20870,9 @@ function runtimeSet(array2, reference, enumEntries, ctx) {
   (ctx.__dirtyRuntimeSets ??= /* @__PURE__ */ new Set()).add(set);
   return set;
 }
-function storedSetEntryMatch(raw, entryMember, ctx) {
+function storedSetEntryMatch(raw, reference, entryMember, ctx) {
   const byIdentity = entryMember.kind === 7 /* Class */;
-  const row = byIdentity || typeof raw !== "string" ? null : evalValueById(ctx, raw, ctx.__runtimeSessionValues, ctx.__valueOverlay);
+  const row = byIdentity || !reference || typeof raw !== "string" ? null : evalValueById(ctx, raw, ctx.__runtimeSessionValues, ctx.__valueOverlay);
   const valueId = byIdentity && typeof raw === "string" ? raw : row?.id ?? null;
   const entry = row === null ? { id: "", value: raw } : { id: row.id, value: row.value };
   const key = byIdentity ? valueId ?? referenceIdOf(raw, ctx) : setEntryKey(entryMember, entry);
@@ -20856,8 +20883,14 @@ function storedSetEntries(set, entryMember, ctx) {
   const existing = indexes3.get(set);
   if (existing !== void 0) return existing;
   const entries = /* @__PURE__ */ new Map();
-  for (const raw of set) {
-    const match = storedSetEntryMatch(raw, entryMember, ctx);
+  const references = collectionReferences(set, ctx);
+  for (let index = 0; index < set.length; index++) {
+    const match = storedSetEntryMatch(
+      set[index],
+      isReferenceEntry(references, index),
+      entryMember,
+      ctx
+    );
     if (match !== null && !entries.has(match.key)) {
       entries.set(match.key, match);
     }
@@ -20869,7 +20902,13 @@ function syncStoredSetEntries(set, mutation, removed, entryMember, ctx) {
   const entries = ctx.__setEntryIndexes?.get(set);
   if (entries === void 0) return;
   if (entryMember !== null && mutation === "Add" /* Add */) {
-    const added = storedSetEntryMatch(set[set.length - 1], entryMember, ctx);
+    const index = set.length - 1;
+    const added = storedSetEntryMatch(
+      set[index],
+      isReferenceEntry(collectionReferences(set, ctx), index),
+      entryMember,
+      ctx
+    );
     if (added !== null) entries.set(added.key, added);
     return;
   }
@@ -20935,6 +20974,7 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
       return null;
     case "Remove" /* Remove */:
       if (Array.isArray(targetValue)) {
+        const references = resolveRemovalEntries ? collectionReferences(targetValue, ctx) : recordedReferenceEntries(targetValue, ctx) ?? 1 /* Values */;
         let index = -1;
         for (let candidate = 0; candidate < targetValue.length; candidate += 1) {
           const entry = targetValue[candidate];
@@ -20945,9 +20985,8 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
             }
             continue;
           }
-          const referenceEntry = ctx.__unorderedListProjections?.referenceEntryIndexesByArray.get(targetValue)?.has(candidate) === true;
           if (jsEqual(
-            resolveRemovalEntries || referenceEntry ? resolveCollectionEntry(targetValue, entry, candidate, ctx) : entry,
+            typeof entry === "string" && isReferenceEntry(references, candidate) ? resolveValueIfId(entry, ctx) : entry,
             args[0]
           )) {
             index = candidate;
@@ -20980,13 +21019,6 @@ function applyLocalCollectionMutation(targetValue, mutation, args, ctx, unique =
       return null;
   }
 }
-function setCollectionReferenceProvenance(targetValue, index, reference, ctx) {
-  const cache = ctx.__unorderedListProjections;
-  const indexes3 = cache?.referenceEntryIndexesByArray.get(targetValue);
-  if (cache === void 0 || indexes3 === void 0) return;
-  if (reference) indexes3.add(index);
-  else indexes3.delete(index);
-}
 function updateCollectionReferenceProvenance(targetValue, mutation, removedIndex, ctx) {
   if (!Array.isArray(targetValue)) return;
   const cache = ctx.__unorderedListProjections;
@@ -21260,7 +21292,7 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
     case "staticMember" /* staticMember */:
       return evalStaticMember(pointer.memberId, ctx);
     case "keyOf" /* keyOf */:
-      return evalKeyOf(pointer.keyOf, scope, ctx, pointer.optional === true);
+      return evalKeyOf(pointer, scope, ctx);
     case "operation" /* operation */:
       return evalOperation(pointer.operation, scope, ctx);
     case "function" /* function */:
@@ -21910,15 +21942,9 @@ function readActionWithOwner(pointer, scope, ctx) {
     return { action: evalPointer(pointer, scope, ctx), owner: null };
   }
   let owner = null;
-  const action = evalKeyOf(
-    pointer.keyOf,
-    scope,
-    ctx,
-    pointer.optional === true,
-    (destination) => {
-      owner = destination.receiver;
-    }
-  );
+  const action = evalKeyOf(pointer, scope, ctx, (destination) => {
+    owner = destination.receiver;
+  });
   return { action, owner };
 }
 function actionPointerLabel(pointer, ctx) {
@@ -22836,7 +22862,9 @@ function isRuntimeSpriteValue(value) {
   const sliceIndex = value.sliceIndex;
   return typeof sliceIndex === "number" && Number.isInteger(sliceIndex) && sliceIndex >= 0;
 }
-function evalKeyOf(keyOf, scope, ctx, optional2 = false, onDestination) {
+function evalKeyOf(pointer, scope, ctx, onDestination) {
+  const { keyOf } = pointer;
+  const optional2 = pointer.optional === true;
   const receiver = evalPointer(keyOf.pointer, scope, ctx);
   if (optional2 && (receiver === null || receiver === void 0)) {
     return null;
@@ -22897,7 +22925,7 @@ function evalKeyOf(keyOf, scope, ctx, optional2 = false, onDestination) {
     if (dispatched.kind === "ok") return dispatched.value;
     if (Object.prototype.hasOwnProperty.call(receiver, k)) {
       const at2 = receiver[k];
-      return resolveValueIfId(at2, ctx);
+      return typeof at2 === "string" && (pointer.memberId !== void 0 || isReferenceEntry(collectionReferences(receiver, ctx), k)) ? resolveValueIfId(at2, ctx) : at2;
     }
     const expanded = virtualExpandedRecordForReceiver(receiver, ctx);
     if (expanded !== null && Object.prototype.hasOwnProperty.call(expanded, k)) {
@@ -23630,7 +23658,7 @@ function evaluateSystemNative(memberId, receiver, args, ctx, typeArguments) {
           shift,
           accepts
         );
-        return { handled: true, value };
+        return { handled: true, value: referenceEntryList(value, ctx) };
       }
       if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetTiles) {
         const value = index.tiles(
@@ -23640,7 +23668,7 @@ function evaluateSystemNative(memberId, receiver, args, ctx, typeArguments) {
           shift,
           accepts
         );
-        return { handled: true, value };
+        return { handled: true, value: referenceEntryList(value, ctx) };
       }
       const tile = index.tile(
         placement,
@@ -24262,7 +24290,17 @@ function evalDeclaredListIndex(info, scope, ctx) {
     collectionIndexes.set(cacheKey, index);
   }
   if (info.keyPointer === void 0) {
-    return Object.fromEntries(index);
+    const view = Object.fromEntries(index);
+    if (info.unique) {
+      unorderedListProjectionCache(ctx).referenceEntryKeysByRecord.set(
+        view,
+        new Set(index.keys())
+      );
+    } else {
+      for (const bucket of index.values())
+        if (Array.isArray(bucket)) referenceEntryList(bucket, ctx);
+    }
+    return view;
   }
   const key = evalPointer(info.keyPointer, scope, ctx);
   if (typeof key !== "string") {
@@ -24274,7 +24312,12 @@ function evalDeclaredListIndex(info, scope, ctx) {
   if (info.unique) {
     return typeof hit === "string" ? resolveValueIfId(hit, ctx) : null;
   }
-  return Array.isArray(hit) ? [...hit] : [];
+  return referenceEntryList(Array.isArray(hit) ? [...hit] : [], ctx);
+}
+function referenceEntryList(list, ctx) {
+  const indexes3 = unorderedListProjectionCache(ctx).referenceEntryIndexesByArray;
+  if (!indexes3.has(list)) indexes3.set(list, new Set(list.keys()));
+  return list;
 }
 function prepareCollectionCallback(callback, parentScope, ctx, isList, returnContract, onPredicateMatch) {
   const metrics = ctx.__collectionCallbackPreparationMetrics;
@@ -24838,7 +24881,7 @@ function evalFunction(fn, scope, ctx) {
       if (fn.info.reference === true) {
         return referenceIndexOf(c, target, ctx) !== null;
       }
-      const targetReferenceId = typeof target === "string" ? target : findKnownRowIdByValueReference(target, ctx);
+      const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
       let containsResolvedEntry = false;
       iterateCollection(c, ctx, (entry, _key, valueId) => {
         if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
@@ -24859,7 +24902,7 @@ function evalFunction(fn, scope, ctx) {
         const index = referenceIndexOf(collection, target, ctx);
         return index === null ? -1 : numberArg(index, "IndexOf index");
       }
-      const targetReferenceId = typeof target === "string" ? target : findKnownRowIdByValueReference(target, ctx);
+      const targetReferenceId = typeof target === "string" ? null : findKnownRowIdByValueReference(target, ctx);
       let found = -1;
       iterateCollection(collection, ctx, (entry, key, valueId) => {
         if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
@@ -26002,6 +26045,8 @@ function evaluateDeclaredConstructorArguments(info, record4, scope, ctx) {
       );
     }
     const value = byName.get(parameter3.name);
+    if (parameter3.type === 9 /* Lookup */ && Array.isArray(value))
+      return referenceEntryList(value, ctx);
     if (typeof value !== "number") return value;
     if (parameter3.type === 4 /* Float */) return Math.fround(value);
     if (parameter3.type !== 20 /* Decimal */) return value;
@@ -28956,14 +29001,10 @@ function collectionLength(c) {
 }
 function snapshotCollectionMembership(collection, ctx) {
   const membership = [];
-  const valid = forEachRawCollectionEntry(collection, (entry) => {
+  const valid = forEachRawCollectionEntry(collection, ctx, (entry) => {
     membership.push({
       raw: entry.raw,
-      resolveAsReference: collectionEntryUsesReferenceResolution(
-        collection,
-        entry.key,
-        ctx
-      )
+      resolveAsReference: entry.valueId !== null
     });
     return 0 /* Continue */;
   });
@@ -28972,7 +29013,7 @@ function snapshotCollectionMembership(collection, ctx) {
     "NeoScript foreach requires a present collection."
   );
 }
-function forEachRawCollectionEntry(c, callback) {
+function forEachRawCollectionEntry(c, ctx, callback) {
   if (c instanceof RuntimeSet) {
     for (const [key, entry] of c.membership().entries()) {
       if (callback({
@@ -28984,35 +29025,34 @@ function forEachRawCollectionEntry(c, callback) {
     }
     return true;
   }
+  if (typeof c !== "object" || c === null) return false;
+  const references = collectionReferences(c, ctx);
   if (Array.isArray(c)) {
     for (let key = 0; key < c.length; key += 1) {
       const raw = c[key];
       const control = callback({
         raw,
         key,
-        valueId: typeof raw === "string" ? raw : null
+        valueId: typeof raw === "string" && isReferenceEntry(references, key) ? raw : null
       });
       if (control === 1 /* Break */) break;
     }
     return true;
   }
-  if (typeof c === "object" && c !== null) {
-    for (const [key, raw] of Object.entries(c)) {
-      const control = callback({
-        raw,
-        key,
-        valueId: typeof raw === "string" ? raw : null
-      });
-      if (control === 1 /* Break */) break;
-    }
-    return true;
+  for (const [key, raw] of Object.entries(c)) {
+    const control = callback({
+      raw,
+      key,
+      valueId: typeof raw === "string" && isReferenceEntry(references, key) ? raw : null
+    });
+    if (control === 1 /* Break */) break;
   }
-  return false;
+  return true;
 }
 function collectionEntries(c, ctx) {
   const entries = [];
-  forEachRawCollectionEntry(c, ({ raw, key }) => {
-    entries.push(resolveCollectionEntry(c, raw, key, ctx));
+  forEachRawCollectionEntry(c, ctx, ({ raw, valueId }) => {
+    entries.push(valueId === null ? raw : resolveValueIfId(valueId, ctx));
     return 0 /* Continue */;
   });
   return entries;
@@ -29020,7 +29060,7 @@ function collectionEntries(c, ctx) {
 function referenceIndexOf(c, target, ctx) {
   const targetId = target === null || target === void 0 ? null : referenceIdOf(target, ctx);
   let found = null;
-  forEachRawCollectionEntry(c, ({ raw, key }) => {
+  forEachRawCollectionEntry(c, ctx, ({ raw, key }) => {
     if (raw === target || targetId !== null && raw !== null && raw !== void 0 && referenceIdOf(raw, ctx) === targetId) {
       found = key;
       return 1 /* Break */;
@@ -29030,26 +29070,61 @@ function referenceIndexOf(c, target, ctx) {
   return found;
 }
 function iterateCollection(c, ctx, callback) {
-  forEachRawCollectionEntry(c, ({ raw, key, valueId }) => {
-    const effectiveValueId = collectionEntryUsesReferenceResolution(c, key, ctx) ? valueId : null;
-    return callback(
-      resolveCollectionEntry(c, raw, key, ctx),
+  forEachRawCollectionEntry(
+    c,
+    ctx,
+    ({ raw, key, valueId }) => callback(
+      valueId === null ? raw : resolveValueIfId(valueId, ctx),
       key,
-      effectiveValueId
-    );
-  });
+      valueId
+    )
+  );
 }
 function resolveCollectionEntry(collection, raw, key, ctx) {
-  return collectionEntryUsesReferenceResolution(collection, key, ctx) ? resolveValueIfId(raw, ctx) : raw;
+  return typeof raw === "string" && isReferenceEntry(collectionReferences(collection, ctx), key) ? resolveValueIfId(raw, ctx) : raw;
 }
-function collectionEntryUsesReferenceResolution(collection, key, ctx) {
-  if (collection instanceof RuntimeSet && typeof key === "number")
-    return collection.membership()[key]?.reference === true;
-  if (!Array.isArray(collection) || typeof key !== "number") return true;
-  const referenceIndexes = ctx.__unorderedListProjections?.referenceEntryIndexesByArray.get(
-    collection
-  );
-  return referenceIndexes === void 0 || referenceIndexes.has(key);
+function recordedReferenceEntries(collection, ctx) {
+  const cache = ctx.__unorderedListProjections;
+  if (Array.isArray(collection))
+    return cache?.referenceEntryIndexesByArray.get(collection);
+  if (typeof collection === "object" && collection !== null)
+    return cache?.referenceEntryKeysByRecord.get(collection);
+  return void 0;
+}
+function collectionReferences(collection, ctx) {
+  return recordedReferenceEntries(collection, ctx) ?? (findKnownRowIdByValueReference(collection, ctx) === null ? 1 /* Values */ : 0 /* RowIds */);
+}
+function isReferenceEntry(references, key) {
+  if (references === 0 /* RowIds */) return true;
+  if (references === 1 /* Values */) return false;
+  return references.has(key);
+}
+function recordWrittenEntry(collection, key, reference, ctx) {
+  const references = collectionReferences(collection, ctx);
+  if (typeof references !== "object") {
+    if (reference === (references === 0 /* RowIds */)) return;
+    const written = Array.isArray(collection) ? collection[Number(key)] : collection[String(key)];
+    if (!reference && typeof written !== "string") return;
+  }
+  const rowIds = references === 0 /* RowIds */;
+  const cache = unorderedListProjectionCache(ctx);
+  if (Array.isArray(collection)) {
+    let indexes3 = cache.referenceEntryIndexesByArray.get(collection);
+    if (indexes3 === void 0) {
+      indexes3 = new Set(rowIds ? collection.keys() : []);
+      cache.referenceEntryIndexesByArray.set(collection, indexes3);
+    }
+    if (reference) indexes3.add(Number(key));
+    else indexes3.delete(Number(key));
+    return;
+  }
+  let keys = cache.referenceEntryKeysByRecord.get(collection);
+  if (keys === void 0) {
+    keys = new Set(rowIds ? Object.keys(collection) : []);
+    cache.referenceEntryKeysByRecord.set(collection, keys);
+  }
+  if (reference) keys.add(String(key));
+  else keys.delete(String(key));
 }
 
 // ../packages/neoscript-runtime/src/declaration-default-source.ts
@@ -43110,13 +43185,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     const typeArguments = expression.typeArguments?.map(
       (argument2) => this.resolveType(argument2)
     );
-    if (typeArguments !== void 0 && typeArguments.length !== (schemaClass2.typeParameters?.length ?? 0)) {
-      throw new CompileError(
-        `Class '${schemaClass2.name}' expects ${schemaClass2.typeParameters?.length ?? 0} type argument${schemaClass2.typeParameters?.length === 1 ? "" : "s"} but got ${typeArguments.length}.`,
+    if (typeArguments !== void 0) {
+      assertTypeArgumentCount(
+        schemaClass2,
+        typeArguments.length,
         expression.pos
       );
-    }
-    if (typeArguments !== void 0) {
       const target = {
         kind: "named",
         typeId: schemaClass2.id,
@@ -47443,21 +47517,34 @@ function resolveNeoScriptType(type, context, project) {
       const declaringType = declaringTypeRef?.kind === "named" ? project.typeById.get(declaringTypeRef.typeId) : void 0;
       const byName = (candidate) => candidate.name === type.name;
       const typeParameter2 = context.typeParameters?.find(byName) ?? declaringType?.typeParameters?.find(byName);
+      const written = type.typeArguments?.length ?? 0;
       if (typeParameter2?.type.kind === "typeParameter") {
+        if (written > 0)
+          throw new CompileError(
+            genericParameterArgumentsMessage(type.name),
+            type.pos
+          );
         resolved = typeParameter2.type;
         break;
       }
       const builtin = namedPrimitive(type.name);
+      const registryReference = builtin ? null : neoScriptRegistryReferenceType(type.name);
+      if ((builtin || registryReference) && written > 0)
+        throw new CompileError(
+          typeArgumentArityMessage(type.name, 0, written),
+          type.pos
+        );
       if (builtin) {
         resolved = { kind: "primitive", name: builtin };
         break;
       }
-      const registryReference = neoScriptRegistryReferenceType(type.name);
       if (registryReference) {
         resolved = registryReference;
         break;
       }
       if (type.name === "NeoDelegate") {
+        if (written > NEOSCRIPT_DELEGATE_MAX_PARAMETERS + 1)
+          throw new CompileError(delegateArityMessage(written), type.pos);
         const [returnType, ...parameterTypes] = (type.typeArguments ?? []).map(
           (argument2) => resolveNeoScriptType(argument2, context, project)
         );
@@ -47475,6 +47562,7 @@ function resolveNeoScriptType(type, context, project) {
           renamedDialogueTypeMessage(type.name, "value") ?? `Unknown type '${type.name}'`,
           type.pos
         );
+      if (written > 0) assertTypeArgumentCount(named, written, type.pos);
       resolved = {
         kind: "named",
         typeId: named.id,
@@ -47543,6 +47631,14 @@ function assertDirectTypeParameterArguments(target, pos, project) {
   const message = wrappedTypeParameterMessage(target, project);
   if (message !== null) throw new CompileError(message, pos);
 }
+function assertTypeArgumentCount(declaring, count, pos) {
+  const expected = declaring.typeParameters?.length ?? 0;
+  if (count === expected) return;
+  throw new CompileError(
+    typeArgumentArityMessage(declaring.name, expected, count),
+    pos
+  );
+}
 function assertTypeArgumentConstraints(declaring, type, pos, project) {
   declaring.typeParameters?.forEach((parameter3, index) => {
     const argument2 = type.typeArguments?.[index];
@@ -59463,7 +59559,7 @@ var INITIALIZER_KEY_PLACEHOLDER = new RegExp(
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.81.1",
+  cliVersion: "0.81.2",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.81.1",
+  "version": "0.81.2",
   "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.81.1 -->
+<!-- reviewed-through-cli: 0.81.2 -->
 
 # 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.81.1 -->
+<!-- reviewed-through-cli: 0.81.2 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -222,7 +222,10 @@ the class's own parameter, such as `public Bag<T> B = new Bag<T>();`. Such an
 initializer with fields or entries, like `new Bag<T> { N = 3 }`, runs per
 instance, since each instance closes `T` differently. A type
 argument that wraps the parameter, such as `new Bag<List<T>>()`, is rejected.
-Type arguments must satisfy `extends` constraints in bodies too.
+Type arguments must satisfy `extends` constraints in bodies too. A written
+type argument list names every parameter, so `item is Tool<Asset>` is rejected
+when `Tool` declares two. A bare generic name, such as `item is Tool`, stays
+allowed.
 A type argument may be a delegate, such as `Box<NeoDelegate<int, int>>`, but
 not a `NeoAction`, which is never a value.