@neocompose/cli 0.83.0 → 0.84.0

package/dist/test-worker.mjs

@@ -7949,6 +7949,35 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
         ],
         dispatch: 0 /* Synchronous */,
         schemaKey: "TryConvert"
+      },
+      {
+        memberId: "system_a92b0911-8e7e-48ef-a12e-f3c55c33f64b",
+        memberKind: "function",
+        docsText: "The nearest tile grid that owns this tile, or null when no grid owns it or that grid is not a T. A tile in an object's tile layer answers with the object's grid.",
+        returnTypeInfo: {
+          type: 21,
+          required: false,
+          ownerMemberId: "system_a92b0911-8e7e-48ef-a12e-f3c55c33f64b",
+          index: 0
+        },
+        argumentTypes: [],
+        genericParams: [
+          {
+            name: "T",
+            constraint: {
+              type: 7,
+              required: true,
+              classId: "system_b78f7f1d-f63c-4abb-ae65-852e69246534"
+            },
+            defaultType: {
+              type: 7,
+              required: true,
+              classId: "system_b78f7f1d-f63c-4abb-ae65-852e69246534"
+            }
+          }
+        ],
+        dispatch: 0 /* Synchronous */,
+        schemaKey: "GetArea"
       }
     ],
     worldKind: "tile"
@@ -7996,6 +8025,35 @@ var WORLD_SYSTEM_CLASS_DEFINITIONS = [
         docsText: "The object's box collider, or null for none. Any world object can carry one: placed objects, nested children, and sprites alike.",
         schemaClassWorldKind: "objectCollider",
         schemaKey: "Collider"
+      },
+      {
+        memberId: "system_7ad477e2-be5b-4892-b9ba-2a2f2476988d",
+        memberKind: "function",
+        docsText: "The nearest tile grid that owns this value, or null when no grid owns it or that grid is not a T. Nested children answer with their placed root's grid.",
+        returnTypeInfo: {
+          type: 21,
+          required: false,
+          ownerMemberId: "system_7ad477e2-be5b-4892-b9ba-2a2f2476988d",
+          index: 0
+        },
+        argumentTypes: [],
+        genericParams: [
+          {
+            name: "T",
+            constraint: {
+              type: 7,
+              required: true,
+              classId: "system_b78f7f1d-f63c-4abb-ae65-852e69246534"
+            },
+            defaultType: {
+              type: 7,
+              required: true,
+              classId: "system_b78f7f1d-f63c-4abb-ae65-852e69246534"
+            }
+          }
+        ],
+        dispatch: 0 /* Synchronous */,
+        schemaKey: "GetArea"
       }
     ],
     worldKind: "objectBase"
@@ -17999,6 +18057,10 @@ var NEO_OBJECT_GRID_MEMBER_IDS = {
   GetTile: "system_593e6208-e2ca-505e-9933-04b17102b6d2",
   GetTiles: "system_5a41d36a-bcd9-4867-9e46-d743f6e09582"
 };
+var NEO_GET_AREA_MEMBER_IDS = {
+  NeoObjectBase: "system_7ad477e2-be5b-4892-b9ba-2a2f2476988d",
+  NeoTile: "system_a92b0911-8e7e-48ef-a12e-f3c55c33f64b"
+};
 var NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS = /* @__PURE__ */ new Set([
   NEO_CELL_PATTERN_MEMBER_IDS.Contains,
   NEO_CELL_PATTERN_MEMBER_IDS.Cells,
@@ -18008,6 +18070,7 @@ var NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS = /* @__PURE__ */ new Set([
   NEO_CELL_PATTERN_MEMBER_IDS.Union
 ]);
 var NEO_OBJECT_CLASS_ID = "system_f671535d-0eb6-4139-9caf-5c5276febd31";
+var NEO_TILE_GRID_CLASS_ID = "system_b78f7f1d-f63c-4abb-ae65-852e69246534";
 
 // ../packages/neoscript-language/src/tile-conversion.ts
 var NEO_TILE_CONVERT_MEMBER_ID = "system_54ecc5a7-874d-54ed-92f4-38100a4b7465";
@@ -18042,39 +18105,26 @@ function isCenter(offset) {
   return offset.x === 0 && offset.y === 0;
 }
 function evaluateCellPatternNative(memberId, receiver, args, ctx) {
-  if (!NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS.has(memberId)) {
-    return { handled: false };
-  }
-  const pattern = (offsets2) => ({
-    handled: true,
-    value: ctx.constructPattern(offsets2)
-  });
   const offsets = ctx.readPattern(receiver);
   switch (memberId) {
     case NEO_CELL_PATTERN_MEMBER_IDS.Contains: {
       const offset = vector(args[0], "Contains offset");
-      return {
-        handled: true,
-        value: offsets.some(
-          (cell) => cell.x === offset.x && cell.y === offset.y
-        )
-      };
+      return offsets.some((cell) => cell.x === offset.x && cell.y === offset.y);
     }
     case NEO_CELL_PATTERN_MEMBER_IDS.Cells:
-      return {
-        handled: true,
-        value: translated(offsets, vector(args[0], "Cells origin"))
-      };
+      return translated(offsets, vector(args[0], "Cells origin"));
     case NEO_CELL_PATTERN_MEMBER_IDS.WithCenter:
-      if (offsets.some(isCenter)) return { handled: true, value: receiver };
-      return pattern([{ x: 0, y: 0 }, ...offsets]);
+      if (offsets.some(isCenter)) return receiver;
+      return ctx.constructPattern([{ x: 0, y: 0 }, ...offsets]);
     case NEO_CELL_PATTERN_MEMBER_IDS.WithoutCenter:
-      if (!offsets.some(isCenter)) return { handled: true, value: receiver };
-      return pattern(offsets.filter((offset) => !isCenter(offset)));
+      if (!offsets.some(isCenter)) return receiver;
+      return ctx.constructPattern(
+        offsets.filter((offset) => !isCenter(offset))
+      );
     case NEO_CELL_PATTERN_MEMBER_IDS.Translate: {
       const offset = vector(args[0], "Translate offset");
-      if (isCenter(offset)) return { handled: true, value: receiver };
-      return pattern(translated(offsets, offset));
+      if (isCenter(offset)) return receiver;
+      return ctx.constructPattern(translated(offsets, offset));
     }
     case NEO_CELL_PATTERN_MEMBER_IDS.Union: {
       const other = ctx.readPattern(args[0]);
@@ -18088,7 +18138,7 @@ function evaluateCellPatternNative(memberId, receiver, args, ctx) {
           result.push(offset);
         }
       }
-      return pattern(result);
+      return ctx.constructPattern(result);
     }
     default:
       throw new Error(
@@ -24513,6 +24563,21 @@ function evalCollectionMutationInstruction(ins, scope, ctx, options) {
       ctx
     );
   }
+  if (unorderedContainerValueId !== null && Array.isArray(targetValue)) {
+    const cache = unorderedListProjectionCache(ctx);
+    const appended = ins.mutation === "Add" /* Add */ && cache.writtenContainerIds.has(unorderedContainerValueId);
+    releaseWrittenUnorderedEntries(
+      unorderedContainerValueId,
+      unorderedEntriesBeforeMutation ?? [],
+      cache
+    );
+    trackWrittenUnorderedEntries(
+      unorderedContainerValueId,
+      targetValue,
+      appended ? targetValue.length - 1 : 0,
+      cache
+    );
+  }
   invalidateEvaluatorIndexes(ctx, targetValue);
   switch (ins.mutation) {
     case "Insert" /* Insert */:
@@ -25518,10 +25583,8 @@ function evalPointerCore(pointer, scope, ctx, resultUsage = "value") {
       if (member.kind === 13 /* Function */) {
         const systemResult = evaluateSystemNative(
           member.id,
-          innerThis,
-          args,
-          ctx,
-          typeArguments
+          { receiver: innerThis, args, typeArguments },
+          ctx
         );
         if (systemResult.handled) return systemResult.value;
         const hosted = ctx.unavailableNativeHandler?.({
@@ -25863,8 +25926,11 @@ function invokeDelegateValue(value, args, ctx, callSiteId, ownerReceiver, result
       if (member.kind === 13 /* Function */) {
         const systemResult = evaluateSystemNative(
           member.id,
-          receiver,
-          args,
+          {
+            receiver,
+            args,
+            typeArguments: calleeTypeArguments(void 0, member, ctx)
+          },
           ctx
         );
         if (systemResult.handled) return systemResult.value;
@@ -27373,6 +27439,8 @@ function createUnorderedListProjectionCache() {
   return {
     byContainerId: /* @__PURE__ */ new Map(),
     containerIdByArray: /* @__PURE__ */ new WeakMap(),
+    writtenContainerIds: /* @__PURE__ */ new Set(),
+    writtenEntryParents: /* @__PURE__ */ new Map(),
     scalarEntryIds: /* @__PURE__ */ new Set(),
     referenceEntryIndexesByArray: /* @__PURE__ */ new WeakMap(),
     referenceEntryKeysByRecord: /* @__PURE__ */ new WeakMap()
@@ -27433,9 +27501,27 @@ function invalidateUnorderedListProjection(containerValueId, ctx) {
   const projection = cache.byContainerId.get(containerValueId);
   if (projection === void 0) return;
   detachRemovedUnorderedScalarEntries(projection, [], ctx);
+  releaseWrittenUnorderedEntries(containerValueId, projection, cache);
   cache.byContainerId.delete(containerValueId);
+  cache.writtenContainerIds.delete(containerValueId);
   cache.containerIdByArray.delete(projection);
 }
+function trackWrittenUnorderedEntries(containerValueId, projection, start, cache, references = cache.referenceEntryIndexesByArray.get(projection)) {
+  cache.writtenContainerIds.add(containerValueId);
+  for (let index = start; index < projection.length; index++) {
+    const entry = projection[index];
+    if (typeof entry === "string" && references?.has(index) !== true) {
+      cache.writtenEntryParents.set(entry, containerValueId);
+    }
+  }
+}
+function releaseWrittenUnorderedEntries(containerValueId, entries, cache) {
+  for (const entry of entries) {
+    if (typeof entry === "string" && cache.writtenEntryParents.get(entry) === containerValueId) {
+      cache.writtenEntryParents.delete(entry);
+    }
+  }
+}
 function updateUnorderedListProjectionAfterAssignment(row, value, ctx) {
   invalidateUnorderedListProjection(row.id, ctx);
   const member = memberForValueRow(row, ctx);
@@ -27454,6 +27540,7 @@ function updateUnorderedListProjectionAfterAssignment(row, value, ctx) {
   }
   cache.byContainerId.set(row.id, projection);
   cache.containerIdByArray.set(projection, row.id);
+  trackWrittenUnorderedEntries(row.id, projection, 0, cache, referenceIndexes);
 }
 function evaluatorUnorderedListEntryIds(containerValueId, ctx) {
   ctx.containerDependencies?.add(containerValueId);
@@ -27610,7 +27697,8 @@ function resolveMemberForValueRow(row, ctx, visited) {
   ctx.onUnattributableValueRead?.(
     ownershipChainRead("member-owner-resolution", row.id)
   );
-  for (const link of evaluatorParentLinks(indexes4, row.id)) {
+  for (const link of evaluatorParentEdges(row, ctx, indexes4)) {
+    if ("memberId" in link) return evalMemberById(ctx.vm, link.memberId);
     const parent = evalValueById(
       ctx,
       link.parentId,
@@ -27633,6 +27721,93 @@ function resolveMemberForValueRow(row, ctx, visited) {
   }
   return null;
 }
+function* evaluatorParentEdges(row, ctx, indexes4) {
+  const cache = ctx.__unorderedListProjections;
+  const writtenParentId = cache?.writtenEntryParents.get(row.id);
+  if (writtenParentId !== void 0) {
+    yield { parentId: writtenParentId, key: "" };
+  }
+  const written = cache?.writtenContainerIds;
+  for (const link of indexes4.parentLinksByChildId.get(row.id) ?? []) {
+    if (written?.has(link.parentId) !== true) yield link;
+  }
+  const database = ctx.vm.databaseVM;
+  const documentContainerId = database?.evaluatorIndexes?.valueById.get(
+    row.id
+  )?.containerId;
+  const rewritten = indexes4.shadowedBaseRowIds.has(row.id);
+  const stale = (parentId) => written?.has(parentId) === true || indexes4.shadowedBaseRowIds.has(parentId) || row.containerId !== parentId && (documentContainerId === parentId || rewritten && database?.valueById(row.id)?.containerId === parentId);
+  const placement = database?.storedValuePlacementForValueId?.(row.id);
+  const placedParentId = placement?.parentValueId;
+  if (placement !== null && placement !== void 0 && typeof placedParentId === "string" && !stale(placedParentId)) {
+    yield { parentId: placedParentId, memberId: placement.memberId };
+  }
+  for (const link of indexes4.baseParentLinksByChildId?.get(row.id) ?? []) {
+    if (!stale(link.parentId)) yield link;
+  }
+}
+function currentUnorderedContainerId(row, ctx) {
+  const cache = ctx.__unorderedListProjections;
+  const writtenParentId = cache?.writtenEntryParents.get(row.id);
+  if (writtenParentId !== void 0) return writtenParentId;
+  const containerId = row.containerId;
+  if (typeof containerId !== "string") return void 0;
+  const released = cache?.writtenContainerIds.has(containerId) === true;
+  return released ? void 0 : containerId;
+}
+function firstOwnerEdge(row, ctx) {
+  const indexes4 = evaluatorIndexes(ctx);
+  const edge = evaluatorParentEdges(row, ctx, indexes4).next().value;
+  if (edge !== void 0) return edge;
+  const rows = ctx.vm.databaseVM?.virtualInstanceRowsForValue(row.id);
+  if (rows === void 0 || rows.length === 0) return void 0;
+  ensureVirtualExpansionIndexed(rows, ctx, indexes4);
+  return evaluatorParentEdges(row, ctx, indexes4).next().value;
+}
+function untrackedValueById(id, ctx) {
+  if (ctx.__removedValueIds?.has(id)) return null;
+  const local = ctx.__runtimeSessionValues?.get(id) ?? ctx.__valueOverlay?.get(id);
+  if (local !== void 0) return local;
+  const database = ctx.vm.databaseVM;
+  if (database !== void 0) return database.valueById(id);
+  return ctx.vm.values.find((value) => value.id === id) ?? null;
+}
+function placingMemberBinding(row, ctx) {
+  const direct = evaluatorIndexes(ctx).memberByValueId.get(row.id);
+  if (direct !== void 0) return direct;
+  const root = rootMemberForValueRow(row, ctx);
+  if (root !== null) return root;
+  const staticRoot = activeStaticBindingRoot(row.id, ctx);
+  if (staticRoot !== null) return staticRoot.member;
+  const placement = ctx.vm.databaseVM?.storedValuePlacementForValueId?.(row.id);
+  if (placement !== null && placement !== void 0) {
+    if (placement.parentValueId === null) {
+      return evalMemberById(ctx.vm, placement.memberId);
+    }
+  }
+  const syntheticMemberId = memberIdFromSyntheticDefaultValueId(row.id);
+  return syntheticMemberId === null ? null : evalMemberById(ctx.vm, syntheticMemberId);
+}
+function placingMember(row, ctx, ownerEdge, depth = 0) {
+  const bound = placingMemberBinding(row, ctx);
+  if (bound !== null) return bound;
+  const edge = ownerEdge ?? firstOwnerEdge(row, ctx);
+  if (edge === void 0) return null;
+  if ("memberId" in edge) return evalMemberById(ctx.vm, edge.memberId);
+  if (depth >= MAX_AREA_DEPTH) return null;
+  const parent = untrackedValueById(edge.parentId, ctx);
+  if (parent === null) return null;
+  const parentMember = parent.classId === void 0 ? placingMember(parent, ctx, void 0, depth + 1) : null;
+  if (parentMember !== null && isMemberWithEntries(parentMember)) {
+    return evalMemberById(ctx.vm, parentMember.entryMemberId);
+  }
+  const classId = parent.classId ?? (parentMember !== null && isClassTypedMember(parentMember) ? parentMember.classId : void 0);
+  return classId === void 0 ? null : memberForCustomSchemaValue(classId, edge.key, ctx);
+}
+function placedClassId(row, ctx, ownerEdge) {
+  const member = placingMember(row, ctx, ownerEdge);
+  return member !== null && isClassTypedMember(member) ? member.classId : void 0;
+}
 function worldGridQueryIndexForContext(context) {
   const ctx = withEvaluationRuntime(context, []);
   const vm = ctx.vm;
@@ -27849,51 +28024,156 @@ function gridQueryClassFilter(typeArgument, ctx) {
     );
   }
   const classId = typeArgument.classId;
-  if (classId === NEO_OBJECT_CLASS_ID || classId === NEO_TILE_CLASS_ID) {
+  if (classId === NEO_OBJECT_CLASS_ID || classId === NEO_TILE_CLASS_ID || classId === NEO_TILE_GRID_CLASS_ID) {
     return void 0;
   }
   const schema = evaluatorSchemaIndex(ctx);
   return (candidate) => schema.classIsOrExtends(candidate, classId);
 }
-function evaluateSystemNative(memberId, receiver, args, ctx, typeArguments) {
-  try {
-    if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetCell || memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetObjects || memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetTile || memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetTiles) {
-      const receiverRow = trackedRowForValueReference(receiver, ctx);
-      if (receiverRow === null) {
-        throw new NSGetterRuntimeError(
-          "Grid queries require a placed NeoObject receiver."
+function gridQueryPlacement(receiver, ctx) {
+  const receiverRow = trackedRowForValueReference(receiver, ctx);
+  if (receiverRow === null) {
+    throw new NSGetterRuntimeError(
+      "Grid queries require a placed NeoObject receiver."
+    );
+  }
+  const index = worldGridQueryIndexForContext(ctx);
+  return {
+    index,
+    placement: index.placement(receiverRow.id, ctx.worldQueryDependencies)
+  };
+}
+function gridQueryArguments(call, ctx) {
+  return {
+    offsets: readCellPattern(call.args[0], ctx),
+    shift: readGridQueryOffset(call.args[1]),
+    accepts: gridQueryClassFilter(call.typeArguments?.[0], ctx)
+  };
+}
+function cellPatternNative(memberId) {
+  return (call, ctx) => evaluateCellPatternNative(memberId, call.receiver, call.args, {
+    readPattern: (value) => readCellPattern(value, ctx),
+    constructPattern: (offsets) => constructDeclaredClassValue(
+      {
+        schemaClassInfo: {
+          type: 7 /* Class */,
+          required: true,
+          classId: NEO_CELL_PATTERN_CLASS_ID
+        },
+        constructorId: NEO_CELL_PATTERN_CONSTRUCTOR_ID,
+        args: [
+          {
+            name: "offsets",
+            valuePointer: {
+              type: "value" /* value */,
+              value: {
+                typeInfo: {
+                  type: 6 /* List */,
+                  required: true,
+                  entryTypeInfo: {
+                    type: 15 /* Vector2Int */,
+                    required: true
+                  }
+                },
+                value: offsets
+              }
+            }
+          }
+        ],
+        fields: []
+      },
+      createTopLevelScope(ctx),
+      ctx
+    )
+  });
+}
+var MAX_AREA_DEPTH = 256;
+var getAreaNative = (call, ctx) => {
+  const receiver = trackedRowForValueReference(call.receiver, ctx);
+  let row = receiver === null ? null : evalValueById(
+    ctx,
+    receiver.id,
+    ctx.__runtimeSessionValues,
+    ctx.__valueOverlay
+  );
+  const schema = evaluatorSchemaIndex(ctx);
+  for (let depth = 0; row !== null && depth < MAX_AREA_DEPTH; depth++) {
+    let edge;
+    if (!Array.isArray(row.value)) {
+      let classId = row.classId ?? void 0;
+      if (classId === void 0) {
+        edge = firstOwnerEdge(row, ctx);
+        classId = placedClassId(row, ctx, edge);
+      }
+      if (classId !== void 0 && schema.classIsOrExtends(classId, NEO_TILE_GRID_CLASS_ID)) {
+        const accepts = gridQueryClassFilter(call.typeArguments?.[0], ctx);
+        return accepts === void 0 || accepts(classId) ? readRowValue(row, ctx) : null;
+      }
+    }
+    const parentId = (edge ?? firstOwnerEdge(row, ctx))?.parentId;
+    if (parentId === void 0) {
+      if (placingMemberBinding(row, ctx) === null) {
+        ctx.onUnattributableValueRead?.(
+          ownershipChainRead("owned-value-parents", row.id)
         );
       }
-      const index = worldGridQueryIndexForContext(ctx);
-      const placement = index.placement(
-        receiverRow.id,
-        ctx.worldQueryDependencies
-      );
-      if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetCell)
-        return { handled: true, value: { ...placement.cell } };
-      const offsets = readCellPattern(args[0], ctx);
-      const shift = readGridQueryOffset(args[1]);
-      const accepts = gridQueryClassFilter(typeArguments?.[0], ctx);
-      if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetObjects) {
-        const value = index.objects(
+      return null;
+    }
+    row = currentUnorderedContainerId(row, ctx) === parentId ? untrackedValueById(parentId, ctx) : evalValueById(
+      ctx,
+      parentId,
+      ctx.__runtimeSessionValues,
+      ctx.__valueOverlay
+    );
+  }
+  return null;
+};
+var SYSTEM_NATIVE_HANDLERS = new Map([
+  [
+    NEO_OBJECT_GRID_MEMBER_IDS.GetCell,
+    (call, ctx) => ({
+      ...gridQueryPlacement(call.receiver, ctx).placement.cell
+    })
+  ],
+  [
+    NEO_OBJECT_GRID_MEMBER_IDS.GetObjects,
+    (call, ctx) => {
+      const { index, placement } = gridQueryPlacement(call.receiver, ctx);
+      const { offsets, shift, accepts } = gridQueryArguments(call, ctx);
+      return referenceEntryList(
+        index.objects(
           placement,
           offsets,
           ctx.worldQueryDependencies,
           shift,
           accepts
-        );
-        return { handled: true, value: referenceEntryList(value, ctx) };
-      }
-      if (memberId === NEO_OBJECT_GRID_MEMBER_IDS.GetTiles) {
-        const value = index.tiles(
+        ),
+        ctx
+      );
+    }
+  ],
+  [
+    NEO_OBJECT_GRID_MEMBER_IDS.GetTiles,
+    (call, ctx) => {
+      const { index, placement } = gridQueryPlacement(call.receiver, ctx);
+      const { offsets, shift, accepts } = gridQueryArguments(call, ctx);
+      return referenceEntryList(
+        index.tiles(
           placement,
           offsets,
           ctx.worldQueryDependencies,
           shift,
           accepts
-        );
-        return { handled: true, value: referenceEntryList(value, ctx) };
-      }
+        ),
+        ctx
+      );
+    }
+  ],
+  [
+    NEO_OBJECT_GRID_MEMBER_IDS.GetTile,
+    (call, ctx) => {
+      const { index, placement } = gridQueryPlacement(call.receiver, ctx);
+      const { offsets, shift, accepts } = gridQueryArguments(call, ctx);
       const tile = index.tile(
         placement,
         offsets,
@@ -27901,7 +28181,7 @@ function evaluateSystemNative(memberId, receiver, args, ctx, typeArguments) {
         shift,
         accepts
       );
-      if (tile === null) return { handled: true, value: null };
+      if (tile === null) return null;
       const row = evalValueById(
         ctx,
         tile.placementValueId,
@@ -27913,43 +28193,20 @@ function evaluateSystemNative(memberId, receiver, args, ctx, typeArguments) {
           `Tile placement '${tile.placementValueId}' is missing.`
         );
       }
-      return { handled: true, value: readRowValue(row, ctx) };
+      return readRowValue(row, ctx);
     }
-    return evaluateCellPatternNative(memberId, receiver, args, {
-      readPattern: (value) => readCellPattern(value, ctx),
-      constructPattern: (offsets) => constructDeclaredClassValue(
-        {
-          schemaClassInfo: {
-            type: 7 /* Class */,
-            required: true,
-            classId: NEO_CELL_PATTERN_CLASS_ID
-          },
-          constructorId: NEO_CELL_PATTERN_CONSTRUCTOR_ID,
-          args: [
-            {
-              name: "offsets",
-              valuePointer: {
-                type: "value" /* value */,
-                value: {
-                  typeInfo: {
-                    type: 6 /* List */,
-                    required: true,
-                    entryTypeInfo: {
-                      type: 15 /* Vector2Int */,
-                      required: true
-                    }
-                  },
-                  value: offsets
-                }
-              }
-            }
-          ],
-          fields: []
-        },
-        createTopLevelScope(ctx),
-        ctx
-      )
-    });
+  ],
+  [NEO_GET_AREA_MEMBER_IDS.NeoObjectBase, getAreaNative],
+  [NEO_GET_AREA_MEMBER_IDS.NeoTile, getAreaNative],
+  ...[...NEO_CELL_PATTERN_PURE_NATIVE_MEMBER_IDS].map(
+    (id) => [id, cellPatternNative(id)]
+  )
+]);
+function evaluateSystemNative(memberId, call, ctx) {
+  const handler = SYSTEM_NATIVE_HANDLERS.get(memberId);
+  if (handler === void 0) return { handled: false };
+  try {
+    return { handled: true, value: handler(call, ctx) };
   } catch (error) {
     if (error instanceof RangeError || error instanceof TypeError || error instanceof WorldGridQueryError) {
       throw new NSGetterRuntimeError(error.message, { cause: error });
@@ -32195,10 +32452,11 @@ function currentOwnedValueAttachments(valueId, ctx) {
     ctx.__runtimeSessionValues,
     ctx.__valueOverlay
   );
-  if (typeof row?.containerId === "string") {
+  const containerId = row === null ? void 0 : currentUnorderedContainerId(row, ctx);
+  if (containerId !== void 0) {
     add({
-      identity: `value:${row.containerId}:unordered-entry:${valueId}`,
-      label: row.containerId
+      identity: `value:${containerId}:unordered-entry:${valueId}`,
+      label: containerId
     });
   }
   const activeStaticRoot = activeStaticBindingRoot(valueId, ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.83.0",
+  "version": "0.84.0",
   "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.83.0 -->
+<!-- reviewed-through-cli: 0.84.0 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/animation-and-world-authoring.md

@@ -65,6 +65,13 @@ cell two rows up without building a translated pattern. These queries track
 empty cells as well as hits, so a getter updates when a new neighbor appears.
 Calling them on an unplaced object is an error.
 
+`this.GetArea()` returns the nearest `NeoTileGrid` that owns the object or
+tile, or null when no grid owns it. It works on any `NeoObjectBase` or
+`NeoTile`: a sprite child, an object held in another object's field, or a tile
+in a nested layer link answers with its placed root's grid. A type argument
+filters the answer, so `this.GetArea<FarmGrid>()` is null in any other grid.
+It sees spawns, moves, and removals made earlier in the same evaluation.
+
 `WithCenter`, `WithoutCenter`, `Translate`, and `Union` return patterns.
 `Union` removes duplicate offsets while preserving first occurrence order.
 Box, Cross, and Line include the origin by default. Use `excluding: .Center`

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.83.0 -->
+<!-- reviewed-through-cli: 0.84.0 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale