@neocompose/cli 0.76.1 → 0.76.3

package/dist/test-worker.mjs

@@ -879,6 +879,351 @@ var require_ignore = __commonJS({
 // src/test-worker.ts
 import { parentPort } from "node:worker_threads";
 
+// ../node_modules/uuid/dist-node/regex.js
+var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+
+// ../node_modules/uuid/dist-node/validate.js
+function validate(uuid) {
+  return typeof uuid === "string" && regex_default.test(uuid);
+}
+var validate_default = validate;
+
+// ../node_modules/uuid/dist-node/parse.js
+function parse(uuid) {
+  if (!validate_default(uuid)) {
+    throw TypeError("Invalid UUID");
+  }
+  let v;
+  return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, v >>> 16 & 255, v >>> 8 & 255, v & 255, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v / 4294967296 & 255, v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255);
+}
+var parse_default = parse;
+
+// ../node_modules/uuid/dist-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// ../node_modules/uuid/dist-node/rng.js
+var rnds8 = new Uint8Array(16);
+function rng() {
+  return crypto.getRandomValues(rnds8);
+}
+
+// ../node_modules/uuid/dist-node/v35.js
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str));
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; ++i) {
+    bytes[i] = str.charCodeAt(i);
+  }
+  return bytes;
+}
+var DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+var URL2 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+function v35(version, hash, value, namespace, buf, offset) {
+  const valueBytes = typeof value === "string" ? stringToBytes(value) : value;
+  const namespaceBytes = typeof namespace === "string" ? parse_default(namespace) : namespace;
+  if (typeof namespace === "string") {
+    namespace = parse_default(namespace);
+  }
+  if (namespace?.length !== 16) {
+    throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
+  }
+  let bytes = new Uint8Array(16 + valueBytes.length);
+  bytes.set(namespaceBytes);
+  bytes.set(valueBytes, namespaceBytes.length);
+  bytes = hash(bytes);
+  bytes[6] = bytes[6] & 15 | version;
+  bytes[8] = bytes[8] & 63 | 128;
+  if (buf) {
+    offset ??= 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = bytes[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(bytes);
+}
+
+// ../node_modules/uuid/dist-node/v4.js
+function v4(options, buf, offset) {
+  if (!buf && !options && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return _v4(options, buf, offset);
+}
+function _v4(options, buf, offset) {
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// ../node_modules/uuid/dist-node/sha1.js
+import { createHash } from "node:crypto";
+function sha1(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === "string") {
+    bytes = Buffer.from(bytes, "utf8");
+  }
+  return createHash("sha1").update(bytes).digest();
+}
+var sha1_default = sha1;
+
+// ../node_modules/uuid/dist-node/v5.js
+function v5(value, namespace, buf, offset) {
+  return v35(80, sha1_default, value, namespace, buf, offset);
+}
+v5.DNS = DNS;
+v5.URL = URL2;
+var v5_default = v5;
+
+// ../packages/models/src/core/world-system-kinds.generated.ts
+var NeoWorldSystemClassKind = {
+  CellPattern: "cellPattern",
+  TileGrid: "tileGrid",
+  SortingLayer: "sortingLayer",
+  TileLayer: "tileLayer",
+  ObjectLayer: "objectLayer",
+  Tile: "tile",
+  ObjectBase: "objectBase",
+  ObjectCollider: "objectCollider",
+  SortingGroup: "sortingGroup",
+  LayerGroupBase: "layerGroupBase",
+  SpriteObject: "spriteObject",
+  PlacementTile: "placementTile",
+  TileLayerLink: "tileLayerLink",
+  ObjectLayerLink: "objectLayerLink",
+  Object: "object",
+  SmartTile: "smartTile",
+  SmartTileRule: "smartTileRule",
+  SmartTileNeighbor: "smartTileNeighbor",
+  AnimationFrameBase: "animationFrameBase",
+  AnimationClip: "animationClip",
+  AnimationFrame: "animationFrame",
+  AnimationSegmentFrame: "animationSegmentFrame",
+  AnimationSegment: "animationSegment",
+  SpriteAnimationSegment: "spriteAnimationSegment",
+  AnimationChildOverride: "animationChildOverride",
+  AnimationTrack: "animationTrack",
+  AnimationChildTrack: "animationChildTrack",
+  AnimationSegmentTrack: "animationSegmentTrack",
+  SpriteAnimationSegmentTrack: "spriteAnimationSegmentTrack",
+  Variant: "variant",
+  VariantFolder: "variantFolder",
+  LookupVariant: "lookupVariant",
+  LookupVariantFolder: "lookupVariantFolder"
+};
+var NEO_WORLD_SYSTEM_CLASS_KIND_VALUES = new Set(
+  Object.values(NeoWorldSystemClassKind)
+);
+function isNeoWorldSystemClassKind(value) {
+  if (typeof value !== "string") return false;
+  return NEO_WORLD_SYSTEM_CLASS_KIND_VALUES.has(value);
+}
+
+// ../packages/models/src/core/core-types.ts
+var SystemDisallowedOperation = {
+  /**
+   * Blocks project-author edits to the record's schema/configuration.
+   */
+  EditRecord: "editRecord",
+  /**
+   * Blocks project-author deletion of the record.
+   */
+  DeleteRecord: "deleteRecord",
+  /**
+   * Removes the record from normal creation/selection affordances.
+   */
+  SelectRecord: "selectRecord",
+  /**
+   * Blocks replacing the value row attached to a member as a whole.
+   */
+  ReplaceValue: "replaceValue"
+};
+var SystemProtectionKind = {
+  WorldAuthoring: "worldAuthoring",
+  DialogueMemorySchema: "dialogueMemorySchema",
+  DialogueMemoryContainer: "dialogueMemoryContainer",
+  DialoguePriorityDefault: "dialoguePriorityDefault",
+  PolicyImmutable: "policyImmutable",
+  PolicyDeleteBlocked: "policyDeleteBlocked",
+  ScriptRuntime: "scriptRuntime"
+};
+function isWithId(value) {
+  return typeof value?.id === "string";
+}
+function isIWithTimestamps(value) {
+  const v = value;
+  if (v === null || v === void 0) {
+    return false;
+  }
+  return isEpochMillis(v.createdAt) && isEpochMillis(v.updatedAt);
+}
+function isEpochMillis(value) {
+  if (typeof value !== "number") return false;
+  return Number.isFinite(value);
+}
+function isSystemProtectionKind(value) {
+  return value === SystemProtectionKind.WorldAuthoring || value === SystemProtectionKind.DialogueMemorySchema || value === SystemProtectionKind.DialogueMemoryContainer || value === SystemProtectionKind.DialoguePriorityDefault || value === SystemProtectionKind.PolicyImmutable || value === SystemProtectionKind.PolicyDeleteBlocked || value === SystemProtectionKind.ScriptRuntime;
+}
+function isSystemMetadata(value) {
+  const v = value;
+  if (typeof v !== "object") return false;
+  if (v === null) return false;
+  if (!isSystemProtectionKind(v.kind)) return false;
+  if (v.worldKind !== void 0 && v.worldKind !== null) {
+    return isNeoWorldSystemClassKind(v.worldKind);
+  }
+  return true;
+}
+function isWithName(value) {
+  return typeof value?.name === "string";
+}
+
+// ../packages/models/src/core/auth-ownership-types.ts
+var ActorKind = {
+  /**
+   * `better-auth` user identities.
+   */
+  user: "user",
+  /**
+   * `better-auth` organization identities.
+   */
+  organization: "organization",
+  /**
+   * Used for denoting records created by a system.
+   */
+  system: "system"
+};
+function isActorIdentifier(value) {
+  if (typeof value !== "object") return false;
+  if (value === null) return false;
+  const candidate = value;
+  if (!isActorKind(candidate.kind)) return false;
+  return typeof candidate.id === "string" && candidate.id.trim().length > 0;
+}
+function isActorKind(value) {
+  return value === ActorKind.user || value === ActorKind.organization || value === ActorKind.system;
+}
+
+// ../packages/models/src/core/structural-narrow.ts
+function isObject(value) {
+  if (typeof value !== "object") return false;
+  return value !== null;
+}
+function hasField(value, field) {
+  if (!isObject(value)) return false;
+  return field in value;
+}
+function getOptionalString(value, field) {
+  if (!hasField(value, field)) return void 0;
+  const v = value[field];
+  if (typeof v !== "string") return void 0;
+  return v;
+}
+function getField(value, field) {
+  if (!hasField(value, field)) return void 0;
+  return value[field];
+}
+function isOptionalNullableType(value, isType) {
+  if (value === null || value === void 0) return true;
+  return isType(value);
+}
+function isNullableType(value, isType) {
+  if (value === null) return true;
+  return isType(value);
+}
+function isRequiredType(value, isType) {
+  if (value === null || value === void 0) return false;
+  return isType(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isFiniteNumberGreaterThanOrEqualToZero(value) {
+  if (!isNumber(value)) return false;
+  if (!Number.isFinite(value)) return false;
+  return value >= 0;
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isOptionalNullableString(value) {
+  return isOptionalNullableType(value, isString);
+}
+function isNullableFiniteNumberGreaterThanOrEqualToZero(value) {
+  return isNullableType(value, isFiniteNumberGreaterThanOrEqualToZero);
+}
+function setOwnField(record4, key, value) {
+  Object.defineProperty(record4, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+}
+
+// ../packages/models/src/common/collections.ts
+function indexById(records2) {
+  const indexed = /* @__PURE__ */ new Map();
+  for (const record4 of records2) indexed.set(record4.id, record4);
+  return indexed;
+}
+function setsEqual(left, right) {
+  if (left === right) return true;
+  if (left.size !== right.size) return false;
+  for (const value of left) {
+    if (!right.has(value)) return false;
+  }
+  return true;
+}
+async function forEachConcurrently(items, limit, work) {
+  const queue = items[Symbol.iterator]();
+  await Promise.all(
+    Array.from({ length: limit }, async () => {
+      for (let next = queue.next(); next.done !== true; next = queue.next()) {
+        await work(next.value);
+      }
+    })
+  );
+}
+
+// ../packages/models/src/docs-text.ts
+var DOCS_TEXT_MAX_UTF8_BYTES = 16384;
+var textEncoder = new TextEncoder();
+function isValidDocsText(value) {
+  if (value === void 0) return true;
+  if (typeof value !== "string") return false;
+  return textEncoder.encode(value).byteLength <= DOCS_TEXT_MAX_UTF8_BYTES;
+}
+
 // ../packages/models/src/members/member-storage.ts
 function isMemberStorageKind(value) {
   return value === 0 /* Inherit */ || value === 1 /* Immutable */ || value === 2 /* Save */ || value === 3 /* Session */ || value === 4 /* Writable */ || value === 5 /* User */;
@@ -923,6 +1268,198 @@ function createWritableAncestorLookup(memberById) {
   return lookup;
 }
 
+// ../packages/models/src/classes/classes.ts
+function isAbstractClass(value) {
+  return value?.modifier === 1 /* Abstract */;
+}
+function isGenericParamConstraint(value) {
+  const v = value;
+  if (!v || typeof v !== "object") return false;
+  if (v.kind === void 0 || v.kind === 0 /* Class */) {
+    if (typeof v.classId !== "string") return false;
+    if (v.classId.length === 0) return false;
+    if (v.enumId !== void 0) return false;
+    const argumentsValue = v.classArguments;
+    return argumentsValue === void 0 || isGenericBindingsRecord(argumentsValue);
+  }
+  if (v.kind === 1 /* Enum */) {
+    if (typeof v.enumId !== "string") return false;
+    if (v.enumId.length === 0) return false;
+    return v.classId === void 0;
+  }
+  return false;
+}
+function isClassGenericConstraint(value) {
+  return value.kind === void 0 || value.kind === 0 /* Class */;
+}
+function isEnumGenericConstraint(value) {
+  return value.kind === 1 /* Enum */;
+}
+function isGenericParamDeclaration(value) {
+  const v = value;
+  if (!v || typeof v !== "object") return false;
+  if (typeof v.id !== "string") return false;
+  if (v.id.length === 0) return false;
+  if (typeof v.name !== "string") return false;
+  if (v.name.length === 0) return false;
+  if (v.constraint === void 0) return true;
+  return isGenericParamConstraint(v.constraint);
+}
+function isGenericBinding(value) {
+  const v = value;
+  if (!v || typeof v !== "object") return false;
+  if (Object.hasOwn(v, "defaultValue")) return false;
+  if (v.kind === void 0 || v.kind === 0 /* Generic */) {
+    if (typeof v.genericParamId !== "string") return false;
+    if (v.genericParamId.length === 0) return false;
+    return v.memberId === void 0;
+  }
+  if (v.kind === 1 /* Member */) {
+    if (typeof v.memberId !== "string") return false;
+    if (v.memberId.length === 0) return false;
+    return v.genericParamId === void 0;
+  }
+  return false;
+}
+function isForwardedGenericBinding(value) {
+  return value.kind === void 0 || value.kind === 0 /* Generic */;
+}
+function isMemberGenericBinding(value) {
+  return value.kind === 1 /* Member */;
+}
+function isGenericBindingsRecord(value) {
+  if (value === null) return false;
+  if (typeof value !== "object") return false;
+  if (Array.isArray(value)) return false;
+  return Object.values(value).every(isGenericBinding);
+}
+var RETIRED_CONSTRUCTOR_PROJECTIONS_FIELD = "constructorProjections";
+function hasRetiredConstructorProjectionsTombstone(value) {
+  return value !== null && typeof value === "object" && Object.hasOwn(value, RETIRED_CONSTRUCTOR_PROJECTIONS_FIELD);
+}
+function isNeoSchemaClassBase(value) {
+  if (hasRetiredConstructorProjectionsTombstone(value)) {
+    return false;
+  }
+  const v = value;
+  return typeof v?.name === "string" && isValidDocsText(v.docsText) && isClassSchema(v?.schema) && isOptionalSchemaKeyOrder(v?.schemaKeyOrder) && (v.implementsInterfaceIds === void 0 || Array.isArray(v.implementsInterfaceIds) && v.implementsInterfaceIds.every(
+    (interfaceId) => typeof interfaceId === "string" && interfaceId.length > 0
+  )) && (v.uiVisibility === void 0 || v.uiVisibility === 0 /* Visible */ || v.uiVisibility === 1 /* Hidden */) && (v.modifier === void 0 || v.modifier === 0 /* Open */ || v.modifier === 1 /* Abstract */ || v.modifier === 2 /* Sealed */) && (v.allowedStorage === void 0 || isClassAllowedStorage(v.allowedStorage)) && (v.allowedStorageKeys === void 0 || Array.isArray(v.allowedStorageKeys) && v.allowedStorageKeys.every((key) => typeof key === "string")) && (v.genericParams === void 0 || Array.isArray(v.genericParams) && v.genericParams.every(isGenericParamDeclaration)) && (v.extendsGenericBindings === void 0 || isGenericBindingsRecord(v.extendsGenericBindings)) && (v.constructorIds === void 0 || Array.isArray(v.constructorIds) && v.constructorIds.every(
+    (constructorId) => typeof constructorId === "string" && constructorId.length > 0
+  ) && new Set(v.constructorIds).size === v.constructorIds.length) && (v.requiredConstructorId === void 0 || typeof v.requiredConstructorId === "string" && v.requiredConstructorId.length > 0 && (v.constructorIds ?? []).length === 0) && (v.targetMemberId === void 0 || typeof v.targetMemberId === "string" && v.targetMemberId.length > 0) && (v.system === void 0 || isSystemMetadata(v.system));
+}
+function resolveAllowedStorage(classId, classes, draft) {
+  const visited = /* @__PURE__ */ new Set();
+  const lookup = (id) => draft && draft.id === id ? draft : classes.find((candidate) => candidate.id === id);
+  let current = lookup(classId);
+  while (current) {
+    if (visited.has(current.id)) return null;
+    visited.add(current.id);
+    if (current.allowedStorage != null) return current.allowedStorage;
+    if (!current.extendsClassId) return null;
+    current = lookup(current.extendsClassId);
+  }
+  return null;
+}
+function classInheritsWorldKind(classId, expectedKind, classesById) {
+  let current = classesById.get(classId);
+  for (let remaining = classesById.size; current !== void 0 && remaining > 0; remaining--) {
+    if (current.system?.worldKind === expectedKind) return true;
+    current = current.extendsClassId ? classesById.get(current.extendsClassId) : void 0;
+  }
+  return false;
+}
+function resolveWorldSystemClassKind(classId, classes, draft) {
+  const visited = /* @__PURE__ */ new Set();
+  const lookup = (id) => draft && draft.id === id ? draft : classes.find((candidate) => candidate.id === id);
+  let current = lookup(classId);
+  while (current) {
+    if (visited.has(current.id)) return null;
+    visited.add(current.id);
+    if (current.system?.worldKind != null) return current.system.worldKind;
+    if (!current.extendsClassId) return null;
+    current = lookup(current.extendsClassId);
+  }
+  return null;
+}
+function indexWorldSystemClassKinds(classes, classesById = indexById(classes)) {
+  const kinds = /* @__PURE__ */ new Map();
+  for (const schemaClass2 of classes) {
+    if (schemaClass2.system?.worldKind != null) {
+      kinds.set(schemaClass2.id, schemaClass2.system.worldKind);
+    } else if (schemaClass2.extendsClassId === void 0) {
+      kinds.set(schemaClass2.id, null);
+    }
+  }
+  const resolving = /* @__PURE__ */ new Set();
+  for (const schemaClass2 of classes) {
+    if (kinds.has(schemaClass2.id)) continue;
+    const path = [];
+    let current = schemaClass2;
+    let resolved = null;
+    while (current !== void 0) {
+      if (kinds.has(current.id)) {
+        resolved = kinds.get(current.id) ?? null;
+        break;
+      }
+      if (resolving.has(current.id)) {
+        resolved = null;
+        break;
+      }
+      resolving.add(current.id);
+      path.push(current);
+      current = current.extendsClassId === void 0 ? void 0 : classesById.get(current.extendsClassId);
+    }
+    for (const candidate of path) {
+      resolving.delete(candidate.id);
+      kinds.set(candidate.id, resolved);
+    }
+  }
+  return kinds;
+}
+function dedupeSchemaKeyOrder(order) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const schemaKey of order) {
+    if (seen.has(schemaKey)) continue;
+    seen.add(schemaKey);
+    result.push(schemaKey);
+  }
+  return result;
+}
+function getClassSchemaKeyOrder(schemaClass2) {
+  const schemaKeys = Object.keys(schemaClass2.schema);
+  if (schemaClass2.schemaKeyOrder === void 0) return schemaKeys;
+  const orderedKeys2 = dedupeSchemaKeyOrder(schemaClass2.schemaKeyOrder);
+  const seen = new Set(orderedKeys2);
+  for (const schemaKey of schemaKeys) {
+    if (seen.has(schemaKey)) continue;
+    seen.add(schemaKey);
+    orderedKeys2.push(schemaKey);
+  }
+  return orderedKeys2;
+}
+function isClassSchema(value) {
+  if (value === null) return false;
+  if (typeof value !== "object") return false;
+  if (Array.isArray(value)) return false;
+  return Object.values(value).every(
+    (schemaValue) => typeof schemaValue === "string"
+  );
+}
+function isOptionalSchemaKeyOrder(value) {
+  if (value === void 0) return true;
+  if (!Array.isArray(value)) return false;
+  return value.every((key) => typeof key === "string");
+}
+function isNeoSchemaClassProps(value) {
+  const v = value;
+  return isNeoSchemaClassBase(value) && typeof v?.id === "string" && isEpochMillis(v?.createdAt) && isEpochMillis(v?.updatedAt) && typeof v?.projectId === "string";
+}
+function isNeoSchemaClass(value) {
+  return isNeoSchemaClassProps(value);
+}
+
 // ../packages/models/src/members/member-kind-enum.ts
 var MemberKind = /* @__PURE__ */ ((MemberKind8) => {
   MemberKind8[MemberKind8["Null"] = 0] = "Null";
@@ -1125,128 +1662,6 @@ function memberKindSupportsDistribution(kind) {
   return memberKindSupportsStorage(kind);
 }
 
-// ../node_modules/uuid/dist-node/regex.js
-var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
-
-// ../node_modules/uuid/dist-node/validate.js
-function validate(uuid) {
-  return typeof uuid === "string" && regex_default.test(uuid);
-}
-var validate_default = validate;
-
-// ../node_modules/uuid/dist-node/parse.js
-function parse(uuid) {
-  if (!validate_default(uuid)) {
-    throw TypeError("Invalid UUID");
-  }
-  let v;
-  return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, v >>> 16 & 255, v >>> 8 & 255, v & 255, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 255, (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255, v / 4294967296 & 255, v >>> 24 & 255, v >>> 16 & 255, v >>> 8 & 255, v & 255);
-}
-var parse_default = parse;
-
-// ../node_modules/uuid/dist-node/stringify.js
-var byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-// ../node_modules/uuid/dist-node/rng.js
-var rnds8 = new Uint8Array(16);
-function rng() {
-  return crypto.getRandomValues(rnds8);
-}
-
-// ../node_modules/uuid/dist-node/v35.js
-function stringToBytes(str) {
-  str = unescape(encodeURIComponent(str));
-  const bytes = new Uint8Array(str.length);
-  for (let i = 0; i < str.length; ++i) {
-    bytes[i] = str.charCodeAt(i);
-  }
-  return bytes;
-}
-var DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
-var URL2 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
-function v35(version, hash, value, namespace, buf, offset) {
-  const valueBytes = typeof value === "string" ? stringToBytes(value) : value;
-  const namespaceBytes = typeof namespace === "string" ? parse_default(namespace) : namespace;
-  if (typeof namespace === "string") {
-    namespace = parse_default(namespace);
-  }
-  if (namespace?.length !== 16) {
-    throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
-  }
-  let bytes = new Uint8Array(16 + valueBytes.length);
-  bytes.set(namespaceBytes);
-  bytes.set(valueBytes, namespaceBytes.length);
-  bytes = hash(bytes);
-  bytes[6] = bytes[6] & 15 | version;
-  bytes[8] = bytes[8] & 63 | 128;
-  if (buf) {
-    offset ??= 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = bytes[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(bytes);
-}
-
-// ../node_modules/uuid/dist-node/v4.js
-function v4(options, buf, offset) {
-  if (!buf && !options && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return _v4(options, buf, offset);
-}
-function _v4(options, buf, offset) {
-  options = options || {};
-  const rnds = options.random ?? options.rng?.() ?? rng();
-  if (rnds.length < 16) {
-    throw new Error("Random bytes length must be >= 16");
-  }
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    if (offset < 0 || offset + 16 > buf.length) {
-      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
-    }
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
-var v4_default = v4;
-
-// ../node_modules/uuid/dist-node/sha1.js
-import { createHash } from "node:crypto";
-function sha1(bytes) {
-  if (Array.isArray(bytes)) {
-    bytes = Buffer.from(bytes);
-  } else if (typeof bytes === "string") {
-    bytes = Buffer.from(bytes, "utf8");
-  }
-  return createHash("sha1").update(bytes).digest();
-}
-var sha1_default = sha1;
-
-// ../node_modules/uuid/dist-node/v5.js
-function v5(value, namespace, buf, offset) {
-  return v35(80, sha1_default, value, namespace, buf, offset);
-}
-v5.DNS = DNS;
-v5.URL = URL2;
-var v5_default = v5;
-
 // ../packages/models/src/project/project-root-members.ts
 var PROJECT_ROOTS = [
   {
@@ -1295,178 +1710,6 @@ function projectRootMembersInDisplayOrder(project) {
   }));
 }
 
-// ../packages/models/src/core/structural-narrow.ts
-function isObject(value) {
-  if (typeof value !== "object") return false;
-  return value !== null;
-}
-function hasField(value, field) {
-  if (!isObject(value)) return false;
-  return field in value;
-}
-function getOptionalString(value, field) {
-  if (!hasField(value, field)) return void 0;
-  const v = value[field];
-  if (typeof v !== "string") return void 0;
-  return v;
-}
-function getField(value, field) {
-  if (!hasField(value, field)) return void 0;
-  return value[field];
-}
-function isOptionalNullableType(value, isType) {
-  if (value === null || value === void 0) return true;
-  return isType(value);
-}
-function isNullableType(value, isType) {
-  if (value === null) return true;
-  return isType(value);
-}
-function isRequiredType(value, isType) {
-  if (value === null || value === void 0) return false;
-  return isType(value);
-}
-function isString(value) {
-  return typeof value === "string";
-}
-function isNumber(value) {
-  return typeof value === "number";
-}
-function isFiniteNumberGreaterThanOrEqualToZero(value) {
-  if (!isNumber(value)) return false;
-  if (!Number.isFinite(value)) return false;
-  return value >= 0;
-}
-function isBoolean(value) {
-  return typeof value === "boolean";
-}
-function isOptionalNullableString(value) {
-  return isOptionalNullableType(value, isString);
-}
-function isNullableFiniteNumberGreaterThanOrEqualToZero(value) {
-  return isNullableType(value, isFiniteNumberGreaterThanOrEqualToZero);
-}
-function setOwnField(record4, key, value) {
-  Object.defineProperty(record4, key, {
-    value,
-    enumerable: true,
-    configurable: true,
-    writable: true
-  });
-}
-
-// ../packages/models/src/core/world-system-kinds.generated.ts
-var NeoWorldSystemClassKind = {
-  CellPattern: "cellPattern",
-  TileGrid: "tileGrid",
-  SortingLayer: "sortingLayer",
-  TileLayer: "tileLayer",
-  ObjectLayer: "objectLayer",
-  Tile: "tile",
-  ObjectBase: "objectBase",
-  ObjectCollider: "objectCollider",
-  SortingGroup: "sortingGroup",
-  LayerGroupBase: "layerGroupBase",
-  SpriteObject: "spriteObject",
-  PlacementTile: "placementTile",
-  TileLayerLink: "tileLayerLink",
-  ObjectLayerLink: "objectLayerLink",
-  Object: "object",
-  SmartTile: "smartTile",
-  SmartTileRule: "smartTileRule",
-  SmartTileNeighbor: "smartTileNeighbor",
-  AnimationFrameBase: "animationFrameBase",
-  AnimationClip: "animationClip",
-  AnimationFrame: "animationFrame",
-  AnimationSegmentFrame: "animationSegmentFrame",
-  AnimationSegment: "animationSegment",
-  SpriteAnimationSegment: "spriteAnimationSegment",
-  AnimationChildOverride: "animationChildOverride",
-  AnimationTrack: "animationTrack",
-  AnimationChildTrack: "animationChildTrack",
-  AnimationSegmentTrack: "animationSegmentTrack",
-  SpriteAnimationSegmentTrack: "spriteAnimationSegmentTrack",
-  Variant: "variant",
-  VariantFolder: "variantFolder",
-  LookupVariant: "lookupVariant",
-  LookupVariantFolder: "lookupVariantFolder"
-};
-var NEO_WORLD_SYSTEM_CLASS_KIND_VALUES = new Set(
-  Object.values(NeoWorldSystemClassKind)
-);
-function isNeoWorldSystemClassKind(value) {
-  if (typeof value !== "string") return false;
-  return NEO_WORLD_SYSTEM_CLASS_KIND_VALUES.has(value);
-}
-
-// ../packages/models/src/core/core-types.ts
-var SystemDisallowedOperation = {
-  /**
-   * Blocks project-author edits to the record's schema/configuration.
-   */
-  EditRecord: "editRecord",
-  /**
-   * Blocks project-author deletion of the record.
-   */
-  DeleteRecord: "deleteRecord",
-  /**
-   * Removes the record from normal creation/selection affordances.
-   */
-  SelectRecord: "selectRecord",
-  /**
-   * Blocks replacing the value row attached to a member as a whole.
-   */
-  ReplaceValue: "replaceValue"
-};
-var SystemProtectionKind = {
-  WorldAuthoring: "worldAuthoring",
-  DialogueMemorySchema: "dialogueMemorySchema",
-  DialogueMemoryContainer: "dialogueMemoryContainer",
-  DialoguePriorityDefault: "dialoguePriorityDefault",
-  PolicyImmutable: "policyImmutable",
-  PolicyDeleteBlocked: "policyDeleteBlocked",
-  ScriptRuntime: "scriptRuntime"
-};
-function isWithId(value) {
-  return typeof value?.id === "string";
-}
-function isIWithTimestamps(value) {
-  const v = value;
-  if (v === null || v === void 0) {
-    return false;
-  }
-  return isEpochMillis(v.createdAt) && isEpochMillis(v.updatedAt);
-}
-function isEpochMillis(value) {
-  if (typeof value !== "number") return false;
-  return Number.isFinite(value);
-}
-function isSystemProtectionKind(value) {
-  return value === SystemProtectionKind.WorldAuthoring || value === SystemProtectionKind.DialogueMemorySchema || value === SystemProtectionKind.DialogueMemoryContainer || value === SystemProtectionKind.DialoguePriorityDefault || value === SystemProtectionKind.PolicyImmutable || value === SystemProtectionKind.PolicyDeleteBlocked || value === SystemProtectionKind.ScriptRuntime;
-}
-function isSystemMetadata(value) {
-  const v = value;
-  if (typeof v !== "object") return false;
-  if (v === null) return false;
-  if (!isSystemProtectionKind(v.kind)) return false;
-  if (v.worldKind !== void 0 && v.worldKind !== null) {
-    return isNeoWorldSystemClassKind(v.worldKind);
-  }
-  return true;
-}
-function isWithName(value) {
-  return typeof value?.name === "string";
-}
-
-// ../packages/models/src/docs-text.ts
-var DOCS_TEXT_MAX_UTF8_BYTES = 16384;
-var textEncoder = new TextEncoder();
-function isValidDocsText(value) {
-  if (value === void 0) return true;
-  if (typeof value !== "string") return false;
-  return textEncoder.encode(value).byteLength <= DOCS_TEXT_MAX_UTF8_BYTES;
-}
-
 // ../packages/models/src/members/float32.ts
 function isFloat32(value) {
   return typeof value === "number" && Number.isFinite(value) && Math.fround(value) === value;
@@ -1936,6 +2179,7 @@ var NEOSCRIPT_OPERATORS = [
 var STRING_TYPE2 = { kind: "primitive", name: "string" };
 var INT_TYPE2 = { kind: "primitive", name: "int" };
 var FLOAT_TYPE = { kind: "primitive", name: "float" };
+var DECIMAL_TYPE = { kind: "primitive", name: "decimal" };
 var BOOL_TYPE2 = { kind: "primitive", name: "bool" };
 var IMAGE_REF_TYPE = {
   kind: "primitive",
@@ -1945,6 +2189,7 @@ var SPRITE_INFO_TYPE = {
   kind: "primitive",
   name: "SpriteInfo"
 };
+var VECTOR2_TYPE = { kind: "primitive", name: "Vector2" };
 var FLOAT_OPTIONAL_TYPE = {
   kind: "primitive",
   name: "float",
@@ -2123,6 +2368,156 @@ var NEOSCRIPT_GLOBALS = [
     "Returns whether a dialogue pointer has been visited."
   )
 ];
+function scalarMethod(receiver, name, returnType, parameters, documentation) {
+  return {
+    id: `builtin:${receiver}:${name}`,
+    name,
+    kind: "method",
+    type: returnType,
+    returnType,
+    parameters,
+    documentation
+  };
+}
+var NEOSCRIPT_SCALAR_METHODS = {
+  string: [
+    scalarMethod(
+      "string",
+      "Contains",
+      BOOL_TYPE2,
+      [parameter("substring", STRING_TYPE2)],
+      "Returns true when the string contains the substring."
+    ),
+    scalarMethod(
+      "string",
+      "Replace",
+      STRING_TYPE2,
+      [parameter("search", STRING_TYPE2), parameter("replacement", STRING_TYPE2)],
+      "Returns a new string with every non-overlapping occurrence replaced using ordinal, case-sensitive matching. An empty search throws an error."
+    ),
+    scalarMethod(
+      "string",
+      "ToLower",
+      STRING_TYPE2,
+      [],
+      "Returns the string converted to lowercase."
+    ),
+    scalarMethod(
+      "string",
+      "ToUpper",
+      STRING_TYPE2,
+      [],
+      "Returns the string converted to uppercase."
+    ),
+    scalarMethod(
+      "string",
+      "Trim",
+      STRING_TYPE2,
+      [],
+      "Returns the string without leading and trailing whitespace."
+    ),
+    scalarMethod(
+      "string",
+      "StartsWith",
+      BOOL_TYPE2,
+      [parameter("prefix", STRING_TYPE2)],
+      "Returns true when the string starts with the prefix."
+    ),
+    scalarMethod(
+      "string",
+      "EndsWith",
+      BOOL_TYPE2,
+      [parameter("suffix", STRING_TYPE2)],
+      "Returns true when the string ends with the suffix."
+    )
+  ],
+  decimal: [
+    scalarMethod(
+      "decimal",
+      "ToFloat",
+      FLOAT_TYPE,
+      [],
+      "Returns the nearest float to this decimal."
+    ),
+    scalarMethod(
+      "decimal",
+      "Round",
+      DECIMAL_TYPE,
+      [parameter("digits", INT_TYPE2)],
+      "Returns this decimal rounded half-to-even to the given number of fractional digits."
+    ),
+    scalarMethod(
+      "decimal",
+      "Divide",
+      DECIMAL_TYPE,
+      [parameter("divisor", DECIMAL_TYPE), parameter("digits", INT_TYPE2)],
+      "Returns this decimal divided by the divisor, rounded half-to-even to the given number of fractional digits."
+    )
+  ],
+  float: [
+    scalarMethod(
+      "float",
+      "ToDecimal",
+      DECIMAL_TYPE,
+      [parameter("digits", INT_TYPE2)],
+      "Returns this float as a decimal with the given number of fractional digits."
+    )
+  ],
+  ImageRef: [
+    scalarMethod(
+      "ImageRef",
+      "Slice",
+      SPRITE_INFO_TYPE,
+      [parameter("index", INT_TYPE2)],
+      "Returns the sprite at the given slice index of this image."
+    )
+  ]
+};
+var NEOSCRIPT_CLASS_ID_MEMBER = "Id";
+var NEOSCRIPT_ON_CHANGED_MEMBER = "OnChanged";
+var NEOSCRIPT_CLASS_ID_SYMBOL = property(
+  "class",
+  NEOSCRIPT_CLASS_ID_MEMBER,
+  STRING_TYPE2,
+  "The stable id of this class value."
+);
+function neoScriptScalarMethod(receiver, name) {
+  return NEOSCRIPT_SCALAR_METHODS[receiver]?.find(
+    (method2) => method2.name === name
+  );
+}
+var NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS = {
+  SpriteInfo: [
+    property("SpriteInfo", "FileName", STRING_TYPE2, "Asset file name."),
+    property("SpriteInfo", "Name", STRING_TYPE2, "Sprite name."),
+    property("SpriteInfo", "Size", VECTOR2_TYPE, "Sprite size."),
+    property("SpriteInfo", "Pivot", VECTOR2_TYPE, "Sprite pivot."),
+    property(
+      "SpriteInfo",
+      "Slices",
+      { kind: "list", elementType: SPRITE_INFO_TYPE, readOnly: true },
+      "All slices in the source asset."
+    )
+  ],
+  AudioClipInfo: [
+    property("AudioClipInfo", "FileId", STRING_TYPE2, "Asset file id."),
+    property("AudioClipInfo", "Name", STRING_TYPE2, "Audio clip name."),
+    property(
+      "AudioClipInfo",
+      "DurationSeconds",
+      FLOAT_OPTIONAL_TYPE,
+      "Audio duration in seconds when known."
+    )
+  ],
+  NeoDialogueReference: [
+    property("NeoDialogueReference", "id", STRING_TYPE2, "Dialogue id.")
+  ]
+};
+function neoScriptPrimitiveDerivedMember(receiver, name) {
+  return NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS[receiver]?.find(
+    (member) => member.name === name
+  );
+}
 function property(owner, name, type, documentation, writable = false) {
   return {
     id: `builtin:${owner}:property:${name}`,
@@ -2187,53 +2582,21 @@ var NEOSCRIPT_BUILTIN_TYPE_SYMBOLS = [
       // `FileId` and `SliceIndex` come from the field table above — they are
       // the writable, addressable fields, not derived properties (D11).
       ...structuredLeafFieldProperties("SpriteInfo"),
-      property("SpriteInfo", "FileName", STRING_TYPE2, "Asset file name."),
-      property("SpriteInfo", "Name", STRING_TYPE2, "Sprite name."),
-      property(
-        "SpriteInfo",
-        "Size",
-        { kind: "named", typeId: "builtin:Vector2" },
-        "Sprite size."
-      ),
-      property(
-        "SpriteInfo",
-        "Pivot",
-        { kind: "named", typeId: "builtin:Vector2" },
-        "Sprite pivot."
-      ),
-      property(
-        "SpriteInfo",
-        "Slices",
-        {
-          kind: "list",
-          elementType: { kind: "named", typeId: "builtin:SpriteInfo" },
-          readOnly: true
-        },
-        "All slices in the source asset."
-      )
+      ...NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS.SpriteInfo
     ]
   },
   {
     id: "builtin:AudioClipInfo",
     name: "AudioClipInfo",
     kind: "builtin",
-    members: [
-      property("AudioClipInfo", "FileId", STRING_TYPE2, "Asset file id."),
-      property("AudioClipInfo", "Name", STRING_TYPE2, "Audio clip name."),
-      property(
-        "AudioClipInfo",
-        "DurationSeconds",
-        FLOAT_OPTIONAL_TYPE,
-        "Audio duration in seconds when known."
-      )
-    ]
+    members: NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS.AudioClipInfo
   },
   {
     id: "builtin:NeoDialogueReference",
     name: "NeoDialogueReference",
     kind: "builtin",
     members: [
-      property("NeoDialogueReference", "id", STRING_TYPE2, "Dialogue id."),
+      ...NEOSCRIPT_PRIMITIVE_DERIVED_MEMBERS.NeoDialogueReference,
       ...neoScriptDialogueReferenceMethods("builtin:NeoDialogueReference")
     ]
   },
@@ -3776,223 +4139,6 @@ function typeInfosInvariantlyEqual(left, right) {
   return true;
 }
 
-// ../packages/models/src/common/collections.ts
-function indexById(records2) {
-  const indexed = /* @__PURE__ */ new Map();
-  for (const record4 of records2) indexed.set(record4.id, record4);
-  return indexed;
-}
-function setsEqual(left, right) {
-  if (left === right) return true;
-  if (left.size !== right.size) return false;
-  for (const value of left) {
-    if (!right.has(value)) return false;
-  }
-  return true;
-}
-async function forEachConcurrently(items, limit, work) {
-  const queue = items[Symbol.iterator]();
-  await Promise.all(
-    Array.from({ length: limit }, async () => {
-      for (let next = queue.next(); next.done !== true; next = queue.next()) {
-        await work(next.value);
-      }
-    })
-  );
-}
-
-// ../packages/models/src/classes/classes.ts
-function isAbstractClass(value) {
-  return value?.modifier === 1 /* Abstract */;
-}
-function isGenericParamConstraint(value) {
-  const v = value;
-  if (!v || typeof v !== "object") return false;
-  if (v.kind === void 0 || v.kind === 0 /* Class */) {
-    if (typeof v.classId !== "string") return false;
-    if (v.classId.length === 0) return false;
-    if (v.enumId !== void 0) return false;
-    const argumentsValue = v.classArguments;
-    return argumentsValue === void 0 || isGenericBindingsRecord(argumentsValue);
-  }
-  if (v.kind === 1 /* Enum */) {
-    if (typeof v.enumId !== "string") return false;
-    if (v.enumId.length === 0) return false;
-    return v.classId === void 0;
-  }
-  return false;
-}
-function isClassGenericConstraint(value) {
-  return value.kind === void 0 || value.kind === 0 /* Class */;
-}
-function isEnumGenericConstraint(value) {
-  return value.kind === 1 /* Enum */;
-}
-function isGenericParamDeclaration(value) {
-  const v = value;
-  if (!v || typeof v !== "object") return false;
-  if (typeof v.id !== "string") return false;
-  if (v.id.length === 0) return false;
-  if (typeof v.name !== "string") return false;
-  if (v.name.length === 0) return false;
-  if (v.constraint === void 0) return true;
-  return isGenericParamConstraint(v.constraint);
-}
-function isGenericBinding(value) {
-  const v = value;
-  if (!v || typeof v !== "object") return false;
-  if (Object.hasOwn(v, "defaultValue")) return false;
-  if (v.kind === void 0 || v.kind === 0 /* Generic */) {
-    if (typeof v.genericParamId !== "string") return false;
-    if (v.genericParamId.length === 0) return false;
-    return v.memberId === void 0;
-  }
-  if (v.kind === 1 /* Member */) {
-    if (typeof v.memberId !== "string") return false;
-    if (v.memberId.length === 0) return false;
-    return v.genericParamId === void 0;
-  }
-  return false;
-}
-function isForwardedGenericBinding(value) {
-  return value.kind === void 0 || value.kind === 0 /* Generic */;
-}
-function isMemberGenericBinding(value) {
-  return value.kind === 1 /* Member */;
-}
-function isGenericBindingsRecord(value) {
-  if (value === null) return false;
-  if (typeof value !== "object") return false;
-  if (Array.isArray(value)) return false;
-  return Object.values(value).every(isGenericBinding);
-}
-var RETIRED_CONSTRUCTOR_PROJECTIONS_FIELD = "constructorProjections";
-function hasRetiredConstructorProjectionsTombstone(value) {
-  return value !== null && typeof value === "object" && Object.hasOwn(value, RETIRED_CONSTRUCTOR_PROJECTIONS_FIELD);
-}
-function isNeoSchemaClassBase(value) {
-  if (hasRetiredConstructorProjectionsTombstone(value)) {
-    return false;
-  }
-  const v = value;
-  return typeof v?.name === "string" && isValidDocsText(v.docsText) && isClassSchema(v?.schema) && isOptionalSchemaKeyOrder(v?.schemaKeyOrder) && (v.implementsInterfaceIds === void 0 || Array.isArray(v.implementsInterfaceIds) && v.implementsInterfaceIds.every(
-    (interfaceId) => typeof interfaceId === "string" && interfaceId.length > 0
-  )) && (v.uiVisibility === void 0 || v.uiVisibility === 0 /* Visible */ || v.uiVisibility === 1 /* Hidden */) && (v.modifier === void 0 || v.modifier === 0 /* Open */ || v.modifier === 1 /* Abstract */ || v.modifier === 2 /* Sealed */) && (v.allowedStorage === void 0 || isClassAllowedStorage(v.allowedStorage)) && (v.allowedStorageKeys === void 0 || Array.isArray(v.allowedStorageKeys) && v.allowedStorageKeys.every((key) => typeof key === "string")) && (v.genericParams === void 0 || Array.isArray(v.genericParams) && v.genericParams.every(isGenericParamDeclaration)) && (v.extendsGenericBindings === void 0 || isGenericBindingsRecord(v.extendsGenericBindings)) && (v.constructorIds === void 0 || Array.isArray(v.constructorIds) && v.constructorIds.every(
-    (constructorId) => typeof constructorId === "string" && constructorId.length > 0
-  ) && new Set(v.constructorIds).size === v.constructorIds.length) && (v.requiredConstructorId === void 0 || typeof v.requiredConstructorId === "string" && v.requiredConstructorId.length > 0 && (v.constructorIds ?? []).length === 0) && (v.targetMemberId === void 0 || typeof v.targetMemberId === "string" && v.targetMemberId.length > 0) && (v.system === void 0 || isSystemMetadata(v.system));
-}
-function resolveAllowedStorage(classId, classes, draft) {
-  const visited = /* @__PURE__ */ new Set();
-  const lookup = (id) => draft && draft.id === id ? draft : classes.find((candidate) => candidate.id === id);
-  let current = lookup(classId);
-  while (current) {
-    if (visited.has(current.id)) return null;
-    visited.add(current.id);
-    if (current.allowedStorage != null) return current.allowedStorage;
-    if (!current.extendsClassId) return null;
-    current = lookup(current.extendsClassId);
-  }
-  return null;
-}
-function classInheritsWorldKind(classId, expectedKind, classesById) {
-  let current = classesById.get(classId);
-  for (let remaining = classesById.size; current !== void 0 && remaining > 0; remaining--) {
-    if (current.system?.worldKind === expectedKind) return true;
-    current = current.extendsClassId ? classesById.get(current.extendsClassId) : void 0;
-  }
-  return false;
-}
-function resolveWorldSystemClassKind(classId, classes, draft) {
-  const visited = /* @__PURE__ */ new Set();
-  const lookup = (id) => draft && draft.id === id ? draft : classes.find((candidate) => candidate.id === id);
-  let current = lookup(classId);
-  while (current) {
-    if (visited.has(current.id)) return null;
-    visited.add(current.id);
-    if (current.system?.worldKind != null) return current.system.worldKind;
-    if (!current.extendsClassId) return null;
-    current = lookup(current.extendsClassId);
-  }
-  return null;
-}
-function indexWorldSystemClassKinds(classes, classesById = indexById(classes)) {
-  const kinds = /* @__PURE__ */ new Map();
-  for (const schemaClass2 of classes) {
-    if (schemaClass2.system?.worldKind != null) {
-      kinds.set(schemaClass2.id, schemaClass2.system.worldKind);
-    } else if (schemaClass2.extendsClassId === void 0) {
-      kinds.set(schemaClass2.id, null);
-    }
-  }
-  const resolving = /* @__PURE__ */ new Set();
-  for (const schemaClass2 of classes) {
-    if (kinds.has(schemaClass2.id)) continue;
-    const path = [];
-    let current = schemaClass2;
-    let resolved = null;
-    while (current !== void 0) {
-      if (kinds.has(current.id)) {
-        resolved = kinds.get(current.id) ?? null;
-        break;
-      }
-      if (resolving.has(current.id)) {
-        resolved = null;
-        break;
-      }
-      resolving.add(current.id);
-      path.push(current);
-      current = current.extendsClassId === void 0 ? void 0 : classesById.get(current.extendsClassId);
-    }
-    for (const candidate of path) {
-      resolving.delete(candidate.id);
-      kinds.set(candidate.id, resolved);
-    }
-  }
-  return kinds;
-}
-function dedupeSchemaKeyOrder(order) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  for (const schemaKey of order) {
-    if (seen.has(schemaKey)) continue;
-    seen.add(schemaKey);
-    result.push(schemaKey);
-  }
-  return result;
-}
-function getClassSchemaKeyOrder(schemaClass2) {
-  const schemaKeys = Object.keys(schemaClass2.schema);
-  if (schemaClass2.schemaKeyOrder === void 0) return schemaKeys;
-  const orderedKeys2 = dedupeSchemaKeyOrder(schemaClass2.schemaKeyOrder);
-  const seen = new Set(orderedKeys2);
-  for (const schemaKey of schemaKeys) {
-    if (seen.has(schemaKey)) continue;
-    seen.add(schemaKey);
-    orderedKeys2.push(schemaKey);
-  }
-  return orderedKeys2;
-}
-function isClassSchema(value) {
-  if (value === null) return false;
-  if (typeof value !== "object") return false;
-  if (Array.isArray(value)) return false;
-  return Object.values(value).every(
-    (schemaValue) => typeof schemaValue === "string"
-  );
-}
-function isOptionalSchemaKeyOrder(value) {
-  if (value === void 0) return true;
-  if (!Array.isArray(value)) return false;
-  return value.every((key) => typeof key === "string");
-}
-function isNeoSchemaClassProps(value) {
-  const v = value;
-  return isNeoSchemaClassBase(value) && typeof v?.id === "string" && isEpochMillis(v?.createdAt) && isEpochMillis(v?.updatedAt) && typeof v?.projectId === "string";
-}
-function isNeoSchemaClass(value) {
-  return isNeoSchemaClassProps(value);
-}
-
 // ../packages/models/src/members/structured-leaf-fields.ts
 var STRUCTURED_LEAF_FIELDS = {
   [11 /* Sprite */]: [
@@ -6288,32 +6434,6 @@ function referencedValueIdCandidates(value) {
   return [];
 }
 
-// ../packages/models/src/core/auth-ownership-types.ts
-var ActorKind = {
-  /**
-   * `better-auth` user identities.
-   */
-  user: "user",
-  /**
-   * `better-auth` organization identities.
-   */
-  organization: "organization",
-  /**
-   * Used for denoting records created by a system.
-   */
-  system: "system"
-};
-function isActorIdentifier(value) {
-  if (typeof value !== "object") return false;
-  if (value === null) return false;
-  const candidate = value;
-  if (!isActorKind(candidate.kind)) return false;
-  return typeof candidate.id === "string" && candidate.id.trim().length > 0;
-}
-function isActorKind(value) {
-  return value === ActorKind.user || value === ActorKind.organization || value === ActorKind.system;
-}
-
 // ../packages/models/src/members/member-change-listeners.ts
 function editChangeListenerSet(explicit, inherited, edit, options = { inheritedComplete: true }) {
   if (edit.kind === "reset") {
@@ -8534,6 +8654,16 @@ function firstUnboundParamId(env) {
   }
   return null;
 }
+function findGenericParamDeclaration(genericParamId, classes) {
+  for (const schemaClass2 of classes) {
+    for (const param of schemaClass2.genericParams ?? []) {
+      if (param.id === genericParamId) {
+        return { param, declaringClass: schemaClass2 };
+      }
+    }
+  }
+  return null;
+}
 function referencedGenericParams(member, members, seen = /* @__PURE__ */ new Set()) {
   const result = /* @__PURE__ */ new Set();
   collectReferencedGenericParams(member, members, seen, result);
@@ -8765,6 +8895,88 @@ function substituteNestedTypeInfo(typeInfo, env, members) {
     );
   });
 }
+function substituteInheritedCallableTypeInfo(typeInfo, env, classes, members) {
+  return mapGenericTypeInfo(typeInfo, (generic) => {
+    const entry = env.get(generic.genericParamId);
+    if (entry === void 0) return generic;
+    if (entry.kind === "unbound") {
+      const forwarded = forwardedParamTypeInfo(entry.paramId, classes);
+      return forwarded === null ? generic : { ...forwarded, required: generic.required };
+    }
+    const bound = openBindingTypeInfo(
+      callableBindingMember(entry.memberId, generic.genericParamId, members),
+      env,
+      classes,
+      members
+    );
+    return { ...bound, required: bound.required && generic.required };
+  });
+}
+function forwardedParamTypeInfo(genericParamId, classes) {
+  const declaration = findGenericParamDeclaration(genericParamId, classes);
+  if (declaration === null) return null;
+  return {
+    type: 21 /* Generic */,
+    required: true,
+    ownerClassId: declaration.declaringClass.id,
+    genericParamId
+  };
+}
+function openBindingTypeInfo(member, env, classes, members) {
+  const resolved = resolveMember(member, members);
+  const nested = (memberId) => openBindingTypeInfo(
+    callableBindingMember(memberId, resolved.name, members),
+    env,
+    classes,
+    members
+  );
+  const param = (genericParamId) => {
+    const entry = env.get(genericParamId);
+    if (entry?.kind === "member") return nested(entry.memberId);
+    if (entry?.kind === "unbound") {
+      return forwardedParamTypeInfo(entry.paramId, classes);
+    }
+    return null;
+  };
+  if (isMemberGenericBase(resolved)) {
+    return param(resolved.genericParamId) ?? genericBindingTypeInfo(resolved, env, members);
+  }
+  const required = isRequiredMember(resolved);
+  if (isMemberClassBase(resolved)) {
+    const typeArguments = {};
+    for (const [parameterId, argument2] of Object.entries(
+      resolved.classArguments ?? {}
+    )) {
+      const argumentType = isForwardedGenericBinding(argument2) ? param(argument2.genericParamId) : nested(argument2.memberId);
+      if (argumentType === null) {
+        return genericBindingTypeInfo(resolved, env, members);
+      }
+      typeArguments[parameterId] = argumentType;
+    }
+    return {
+      type: 7 /* Class */,
+      required,
+      classId: resolved.classId,
+      ...Object.keys(typeArguments).length === 0 ? {} : { typeArguments }
+    };
+  }
+  if (isMemberListBase(resolved)) {
+    return {
+      type: 6 /* List */,
+      required,
+      entryTypeInfo: nested(resolved.entryMemberId)
+    };
+  }
+  if (isMemberDictionaryBase(resolved)) {
+    return {
+      type: 5 /* Dictionary */,
+      required,
+      entryTypeInfo: nested(resolved.entryMemberId),
+      ...resolved.keyEnumId == null ? {} : { keyEnumId: resolved.keyEnumId }
+    };
+  }
+  return genericBindingTypeInfo(resolved, env, members);
+}
 function callableBindingMember(memberId, slotName, members) {
   const binding = memberIndexFor(members).get(memberId);
   if (binding === void 0) {
@@ -9366,13 +9578,16 @@ function constructionMembers(classId, context) {
 }
 function createMemberDefaultConstructionChecker(document2) {
   const context = contextFor(document2);
-  return (member, genericEnv = /* @__PURE__ */ new Map()) => {
+  return (member, genericEnv = /* @__PURE__ */ new Map(), readValueIds) => {
     const previousEnv = context.env;
+    const previousReads = context.readValueIds;
     context.env = genericEnv;
+    context.readValueIds = readValueIds;
     try {
       return defaultSettlesConstruction(member, context, /* @__PURE__ */ new Set());
     } finally {
       context.env = previousEnv;
+      context.readValueIds = previousReads;
     }
   };
 }
@@ -9483,6 +9698,7 @@ function valueSettlesConstruction(member, body, context, path, storedRow = false
 }
 function suppliedValueSettlesConstruction(member, value, context, path) {
   if (typeof value === "string") {
+    context.readValueIds?.add(value);
     let row;
     if (context.document.valueById !== void 0) {
       row = context.document.valueById(value);
@@ -10548,74 +10764,84 @@ function recordStorageKeyDeclaration(sink, valueId, member) {
   if (declaration === STORAGE_KEY_INHERIT) return;
   sink.set(valueId, declaration);
 }
-function createDefaultValueResolutionCache() {
+function createDefaultSchemaResolutionCache() {
   return {
     memberByIdIndex: null,
     instanceEnvironmentByKey: /* @__PURE__ */ new Map(),
-    materializationPlanByClassAndEnvironment: /* @__PURE__ */ new Map(),
     resolvedMemberById: /* @__PURE__ */ new Map(),
     storedSchemaByClassId: /* @__PURE__ */ new Map(),
-    validatedInitializerContainers: /* @__PURE__ */ new WeakSet(),
+    validatedInitializerContainers: /* @__PURE__ */ new WeakSet()
+  };
+}
+function createDefaultValueResolutionCache(schema = createDefaultSchemaResolutionCache()) {
+  return {
+    schema,
+    materializationPlanByClassAndEnvironment: /* @__PURE__ */ new Map(),
     memberDefaultConstructionChecker: null
   };
 }
 function withIndexedDefaultValueDocument(document2, options = {}) {
   const cache = options.cache ?? createDefaultValueResolutionCache();
-  if (cache.memberByIdIndex === null && options.memberById === void 0 && document2.memberById === void 0) {
-    cache.memberByIdIndex = new Map(
+  const schemaCache = cache.schema;
+  if (schemaCache.memberByIdIndex === null && options.memberById === void 0 && document2.memberById === void 0) {
+    schemaCache.memberByIdIndex = new Map(
       document2.members.map((member) => [member.id, member])
     );
   }
   const indexed = {
     ...document2,
-    memberById: (id) => options.memberById?.(id) ?? document2.memberById?.(id) ?? cache.memberByIdIndex?.get(id) ?? null,
+    memberById: (id) => options.memberById?.(id) ?? document2.memberById?.(id) ?? schemaCache.memberByIdIndex?.get(id) ?? null,
     resolvedMember: (member) => {
       const memberId = "id" in member ? member.id : void 0;
       if (typeof memberId !== "string") {
         return resolveMember(member, document2.members);
       }
-      const cached = cache.resolvedMemberById.get(memberId);
+      const cached = schemaCache.resolvedMemberById.get(memberId);
       if (cached !== void 0) return cached;
       const resolved = resolveMember(member, document2.members);
-      cache.resolvedMemberById.set(memberId, resolved);
+      schemaCache.resolvedMemberById.set(memberId, resolved);
       return resolved;
     },
     storedInstanceSchema: (classId) => {
-      const cached = cache.storedSchemaByClassId.get(classId);
+      const cached = schemaCache.storedSchemaByClassId.get(classId);
       if (cached !== void 0) return cached;
       const schema = resolvedClassSchema(
         classId,
         document2.classes,
         document2.members
       ).surface;
-      cache.storedSchemaByClassId.set(classId, schema);
+      schemaCache.storedSchemaByClassId.set(classId, schema);
       return schema;
     },
     instanceEnv: (classId, classArguments2) => {
       const key = `${classId}:${JSON.stringify(classArguments2 ?? null)}`;
-      const cached = cache.instanceEnvironmentByKey.get(key);
+      const cached = schemaCache.instanceEnvironmentByKey.get(key);
       if (cached !== void 0) return cached;
       const environment = resolveInstanceEnv(
         classId,
         classArguments2,
         document2.classes
       );
-      cache.instanceEnvironmentByKey.set(key, environment);
+      schemaCache.instanceEnvironmentByKey.set(key, environment);
       return environment;
     },
     isInitValueContent: (value) => {
       if (typeof value !== "object" || value === null) return false;
-      if (cache.validatedInitializerContainers.has(value)) return true;
+      if (schemaCache.validatedInitializerContainers.has(value)) return true;
       if (!isInitValueContent(value)) return false;
-      cache.validatedInitializerContainers.add(value);
+      schemaCache.validatedInitializerContainers.add(value);
       return true;
     },
-    memberDefaultSettlesConstruction: (member, environment) => {
+    memberDefaultSettlesConstruction: (member, environment, readValueIds) => {
       cache.memberDefaultConstructionChecker ??= createMemberDefaultConstructionChecker({
         ...indexed,
         constructors: document2.constructors ?? []
       });
-      return cache.memberDefaultConstructionChecker(member, environment);
+      return cache.memberDefaultConstructionChecker(
+        member,
+        environment,
+        readValueIds
+      );
     },
     createValueRow: options.createValueRow ?? document2.createValueRow
   };
@@ -10667,12 +10893,20 @@ function buildDefaultClassMaterializationPlan(document2, classId, instanceEnv) {
     ...document2,
     constructors: document2.constructors ?? []
   });
-  return storedSchemaOf(document2, classId).flatMap(
+  const reads = {
+    valueIds: /* @__PURE__ */ new Set(),
+    containerIds: /* @__PURE__ */ new Set()
+  };
+  const entries = storedSchemaOf(document2, classId).flatMap(
     (entry) => {
       if (entry.memberId === null) return [];
       const childMember = findMemberInDocument(document2, entry.memberId);
       if (!memberKindOwnsStoredValue(childMember.kind)) return [];
-      if (instanceEnv.size === 0 && isConstantMember(document2, resolvedInDocument(document2, childMember)))
+      if (instanceEnv.size === 0 && isConstantMember(
+        document2,
+        resolvedInDocument(document2, childMember),
+        reads
+      ))
         return [];
       const member = substituteMember(
         childMember,
@@ -10684,14 +10918,19 @@ function buildDefaultClassMaterializationPlan(document2, classId, instanceEnv) {
         {
           schemaKey: entry.schemaKey,
           member,
-          defaultSettlesConstruction: settlesConstruction(member, instanceEnv),
+          defaultSettlesConstruction: settlesConstruction(
+            member,
+            instanceEnv,
+            reads.valueIds
+          ),
           directScalarBody: directScalarDefaultBody(document2, member)
         }
       ];
     }
   );
+  return { entries, reads };
 }
-function isConstantMember(document2, resolved) {
+function isConstantMember(document2, resolved, reads) {
   if (isStaticMember(resolved)) return false;
   const fixedness = fixednessOf(resolved, 0 /* Writable */);
   if (fixedness === 0 /* Writable */) return false;
@@ -10704,7 +10943,8 @@ function isConstantMember(document2, resolved) {
       document: document2,
       rows: /* @__PURE__ */ new Set(),
       declarations: /* @__PURE__ */ new Set(),
-      classes: /* @__PURE__ */ new Set()
+      classes: /* @__PURE__ */ new Set(),
+      reads
     },
     resolved,
     declared,
@@ -10778,6 +11018,8 @@ function declarationVaries(walk, member, body, rowId, scope) {
     return owned !== Object.keys(value).length;
   }
   if (isMemberListBase(member)) {
+    if (rowId !== null && listKindOf(member) === 1 /* Unordered */)
+      walk.reads?.containerIds.add(rowId);
     const entryIds = listKindOf(member) !== 1 /* Unordered */ ? value : rowId === null ? [] : document2.unorderedListEntryIds?.(rowId) ?? (walk.membership ??= buildUnorderedListMembershipIndex(
       document2.values
     )).get(rowId) ?? [];
@@ -10810,6 +11052,7 @@ function rowVaries(walk, member, valueId, scope) {
   const key = scopeKey(valueId, scope);
   if (walk.rows.has(key)) return false;
   walk.rows.add(key);
+  walk.reads?.valueIds.add(valueId);
   const { document: document2 } = walk;
   const row = document2.valueById?.(valueId) ?? (walk.rowById ??= new Map(
     document2.values.map((value) => [value.id, value])
@@ -11113,6 +11356,7 @@ function buildDefaultMemberValueCore(args, resolvedMember) {
       effectiveClassId,
       childEnv
     );
+    args.document.recordPlanReads?.(materializationPlan.reads);
     const record4 = member.payload === 1 /* Partial */ ? {} : cloneDefaultClassRecord({
       document: args.document,
       projectId: args.projectId,
@@ -11306,7 +11550,7 @@ function completeDefaultClassRecord(args) {
     member: resolvedChildMember,
     defaultSettlesConstruction: defaultSettlesConstruction2,
     directScalarBody
-  } of args.member.payload === 1 /* Partial */ ? [] : args.materializationPlan) {
+  } of args.member.payload === 1 /* Partial */ ? [] : args.materializationPlan.entries) {
     if (storageKeyReferencesParentClass(
       normalizeStorageKeyDeclaration(resolvedChildMember.storageKey)
     )) {
@@ -11626,6 +11870,7 @@ function cloneDefaultValueForMemberCore(args, sourceValue) {
       effectiveClassId,
       childEnv
     );
+    args.document.recordPlanReads?.(materializationPlan.reads);
     const anchorsParentClassPartition = sourceValue.constructorArgs == null && completeDefaultClassRecord({
       ...args,
       member,
@@ -12510,6 +12755,230 @@ var EffectiveStorageResolver = class {
   }
 };
 
+// ../packages/models/src/interfaces/interface-graph.ts
+var CircularInterfaceExtensionError = class extends Error {
+  constructor(interfaceId, chain) {
+    super(
+      `Circular interface extension detected at "${interfaceId}"; chain: ${chain.join(" -> ")}`
+    );
+    this.interfaceId = interfaceId;
+    this.chain = chain;
+    this.name = "CircularInterfaceExtensionError";
+  }
+  interfaceId;
+  chain;
+};
+function resolveInterfaceClosure(interfaceId, interfaces) {
+  const byId = new Map(
+    interfaces.map((neoInterface) => [neoInterface.id, neoInterface])
+  );
+  const result = [];
+  const emitted = /* @__PURE__ */ new Set();
+  const visiting = [];
+  const visitingSet = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (visitingSet.has(id)) {
+      throw new CircularInterfaceExtensionError(id, [...visiting, id]);
+    }
+    if (emitted.has(id)) return;
+    const neoInterface = byId.get(id);
+    if (!neoInterface) return;
+    visiting.push(id);
+    visitingSet.add(id);
+    result.push(neoInterface);
+    emitted.add(id);
+    for (const parentId of neoInterface.extendsInterfaceIds ?? []) {
+      visit(parentId);
+    }
+    visiting.pop();
+    visitingSet.delete(id);
+  };
+  visit(interfaceId);
+  return result;
+}
+function resolveImplementedInterfaces(classId, classes, interfaces) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const schemaClass2 of resolveInheritanceChain(classId, classes)) {
+    for (const interfaceId of schemaClass2.implementsInterfaceIds ?? []) {
+      for (const neoInterface of resolveInterfaceClosure(
+        interfaceId,
+        interfaces
+      )) {
+        if (seen.has(neoInterface.id)) continue;
+        seen.add(neoInterface.id);
+        result.push(neoInterface);
+      }
+    }
+  }
+  return result;
+}
+function classImplementsInterface(classId, interfaceId, classes, interfaces) {
+  return resolveImplementedInterfaces(classId, classes, interfaces).some(
+    (neoInterface) => neoInterface.id === interfaceId
+  );
+}
+
+// ../packages/manifest/src/value-comparison.ts
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../packages/neoscript-runtime/src/values/canonical-json.ts
+function canonicalJsonStringify(value) {
+  return JSON.stringify(toCanonicalJsonValue(value));
+}
+function toCanonicalJsonValue(value) {
+  if (value === null) return null;
+  if (value === void 0) return void 0;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("Cannot canonicalize a non-finite number.");
+    }
+    return value;
+  }
+  if (typeof value === "bigint") {
+    throw new Error("Cannot canonicalize bigint values.");
+  }
+  if (typeof value === "symbol") {
+    throw new Error("Cannot canonicalize symbol values.");
+  }
+  if (typeof value === "function") {
+    throw new Error("Cannot canonicalize function values.");
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      const canonicalItem = toCanonicalJsonValue(item);
+      if (canonicalItem === void 0) return null;
+      return canonicalItem;
+    });
+  }
+  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+  const canonicalObject = {};
+  for (const [key, entryValue] of entries) {
+    const canonicalValue = toCanonicalJsonValue(entryValue);
+    if (canonicalValue === void 0) continue;
+    canonicalObject[key] = canonicalValue;
+  }
+  return canonicalObject;
+}
+
+// ../src/database/compiled-construction-types.ts
+function compiledConstructionTypeMembers(members, bodies, projectId) {
+  const created = [];
+  let existingIds;
+  const byType = /* @__PURE__ */ new Map();
+  const key = (type) => canonicalJsonStringify(type);
+  const intern = (type) => {
+    const signature = key(type);
+    const existing = byType.get(signature);
+    if (existing !== void 0) return existing;
+    if (type.type === 21 /* Generic */ || type.type === NS_TYPE_UNKNOWN)
+      return null;
+    const id = v5_default(
+      `neo:compiled-construction-type:${projectId}:${signature}`,
+      v5_default.URL
+    );
+    existingIds ??= new Set(members.map((member) => member.id));
+    if (existingIds.has(id)) {
+      byType.set(signature, id);
+      return id;
+    }
+    const common = {
+      id,
+      projectId,
+      createdAt: 0,
+      updatedAt: 0,
+      name: "Type argument",
+      kind: type.type,
+      requirement: type.required ? 1 /* Required */ : 0 /* Optional */
+    };
+    const fields = (() => {
+      if (type.type === 6 /* List */ || type.type === 5 /* Dictionary */) {
+        const entryMemberId = intern(type.entryTypeInfo);
+        if (entryMemberId === null) return null;
+        return {
+          entryMemberId,
+          ...type.keyEnumId === void 0 ? {} : { keyKind: 1 /* Enum */, keyEnumId: type.keyEnumId }
+        };
+      } else if (type.type === 7 /* Class */) {
+        const classArguments2 = {};
+        for (const [parameter3, argument2] of Object.entries(
+          type.typeArguments ?? {}
+        )) {
+          const memberId = intern(argument2);
+          if (memberId === null) return null;
+          classArguments2[parameter3] = {
+            kind: 1 /* Member */,
+            memberId
+          };
+        }
+        return {
+          classId: type.classId,
+          ...Object.keys(classArguments2).length === 0 ? {} : { classArguments: classArguments2 }
+        };
+      } else if (type.type === 8 /* Enum */) {
+        return { enumId: type.enumId };
+      } else if (type.type === 25 /* NSDelegate */) {
+        return {
+          returnTypeInfo: type.returnTypeInfo,
+          argumentTypes: type.argumentTypes
+        };
+      } else if (type.type === 26 /* NSAction */) {
+        return { argumentTypes: type.argumentTypes };
+      } else if (type.type === 22 /* Interface */ || type.type === 9 /* Lookup */ || type.type === 18 /* DialogueLookup */) {
+        return null;
+      } else {
+        return {};
+      }
+    })();
+    if (fields === null) return null;
+    created.push({ ...common, ...fields });
+    existingIds.add(id);
+    byType.set(signature, id);
+    return id;
+  };
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (value === null || typeof value !== "object" || visited.has(value))
+      return;
+    visited.add(value);
+    const argumentsValue = getField(
+      getField(value, "schemaClassInfo"),
+      "typeArguments"
+    );
+    if (argumentsValue !== null && typeof argumentsValue === "object") {
+      for (const type of Object.values(argumentsValue))
+        if (isNSTypeInfo(type)) intern(type);
+    }
+    for (const child of Object.values(value)) visit(child);
+  };
+  for (const body of bodies) visit(body);
+  return created;
+}
+function withCompiledConstructionTypes(document2, body) {
+  const members = document2.members;
+  const projectId = getField(document2.project, "id");
+  if (!Array.isArray(members)) {
+    throw new Error("Construction type descriptors require a member array.");
+  }
+  if (!members.every(
+    (member) => typeof getField(member, "id") === "string"
+  )) {
+    throw new Error(
+      "Construction type descriptors require an ID on every member record."
+    );
+  }
+  if (typeof projectId !== "string") {
+    throw new Error("Construction type descriptors require a project ID.");
+  }
+  const created = compiledConstructionTypeMembers(members, [body], projectId);
+  return created.length === 0 ? document2 : { ...document2, members: [...members, ...created] };
+}
+
 // ../packages/neoscript-runtime/src/neoscript/debug.ts
 function snapshotNeoScriptFrames(state) {
   const frames = state.frames.slice(-64).reverse().map((frame) => Object.freeze({ ...frame }));
@@ -13475,8 +13944,7 @@ var PendingInitializerDependency = class extends NSGetterRuntimeError {
 var OWNERSHIP_CHAIN_PREFIXES = [
   "generic-parent-resolution:",
   "member-owner-resolution:",
-  "owned-value-parents:",
-  "declaration-owner-resolution:"
+  "owned-value-parents:"
 ];
 var CONTAINER_ENTRIES_PREFIX = "container-entries:";
 function ownershipChainRead(kind, rowId) {
@@ -13485,10 +13953,6 @@ function ownershipChainRead(kind, rowId) {
 function containerEntriesRead(containerId) {
   return `${CONTAINER_ENTRIES_PREFIX}${containerId}`;
 }
-var OWNERSHIP_CHAIN_READ = ownershipChainRead(
-  "member-owner-resolution",
-  "*"
-);
 function classifyUnattributableRead(reason) {
   for (const prefix of OWNERSHIP_CHAIN_PREFIXES) {
     if (reason.startsWith(prefix)) {
@@ -13519,12 +13983,13 @@ function valueIdsWithSourceChains(targetValueIds, valuesById) {
   }
   return result;
 }
-function initializerOwnerContext(document2, valueId, rootOwners, valuesById) {
+function initializerOwnerContext(document2, valueId, rootOwners, valuesById, recordValueRead) {
   const visited = /* @__PURE__ */ new Set();
   let currentId = valueId;
   let lexicalRoot = rootOwners.get(valueId);
   while (currentId !== null && !visited.has(currentId)) {
     visited.add(currentId);
+    recordValueRead?.(currentId);
     const sourceValueId = valuesById.get(currentId)?.sourceValueId;
     if (typeof sourceValueId !== "string") break;
     currentId = sourceValueId;
@@ -14720,9 +15185,8 @@ var InitializerReadSet = class {
   /**
    * The unattributable reads by scope, for a fork of the same document to
    * re-attribute; see {@link classifyUnattributableRead}. Ownership-chain
-   * reads collapse to one flag: their inputs are already in `valueIds`.
+   * reads need no record: their inputs are already in `valueIds`.
    */
-  hasOwnershipChainRead = false;
   containerEntryReadIds = /* @__PURE__ */ new Set();
   corpusReadReasons = /* @__PURE__ */ new Set();
   recordUnattributableValueRead = (reason) => {
@@ -14730,7 +15194,6 @@ var InitializerReadSet = class {
     const read = classifyUnattributableRead(reason);
     switch (read.scope) {
       case "ownership-chain" /* OwnershipChain */:
-        this.hasOwnershipChainRead = true;
         return;
       case "container" /* Container */:
         this.containerEntryReadIds.add(read.containerId);
@@ -14775,17 +15238,61 @@ function getWorldGridQueryIndex(source) {
     building.delete(source.cacheKey);
   }
 }
+function readsAny(reads, ids) {
+  for (const id of ids) if (reads.has(id)) return true;
+  return false;
+}
 var WorldGridQueryIndex = class {
-  constructor(grids, placements, geometryReads, metrics) {
+  constructor(grids, placements, geometryReads, kinds, placedRecordIds, metrics) {
     this.grids = grids;
     this.placements = placements;
     this.geometryReads = geometryReads;
+    this.kinds = kinds;
+    this.placedRecordIds = placedRecordIds;
     this.metrics = metrics;
   }
   grids;
   placements;
   geometryReads;
+  kinds;
+  placedRecordIds;
   metrics;
+  /**
+   * Whether edits to these rows can change the index. Ownership-chain reads
+   * need no flag: every ancestor they visit is in `geometryReads.valueIds`.
+   * Discovery checks every row's effective class without recording a read,
+   * so a changed row it could now index as a grid counts as well. A record it
+   * classed by placement keeps that placement through its own writes, so only
+   * its stamp can change.
+   */
+  readsValues(valueIds, classIdOf, stampOf) {
+    const reads = this.geometryReads;
+    if (reads.corpusReadReasons.size > 0) return true;
+    for (const id of valueIds) {
+      if (reads.valueIds.has(id)) return true;
+      const classId = this.placedRecordIds.has(id) ? stampOf(id) : classIdOf(id);
+      if (classId !== null && this.kinds.get(classId) === NeoWorldSystemClassKind.TileGrid)
+        return true;
+    }
+    return false;
+  }
+  /** Whether entry changes in these containers can change the index. */
+  readsContainers(containerIds) {
+    const reads = this.geometryReads;
+    for (const id of containerIds) {
+      if (reads.containerIds.has(id)) return true;
+      if (reads.containerEntryReadIds.has(id)) return true;
+    }
+    return false;
+  }
+  /** Whether edits to these localized texts can change the index. */
+  readsLocalizedTexts(textIds) {
+    return readsAny(this.geometryReads.localizedTextIds, textIds);
+  }
+  /** Whether edits to these variants can change the index. */
+  readsVariants(variantIds) {
+    return readsAny(this.geometryReads.variantIds, variantIds);
+  }
   placement(valueId, reads) {
     reads?.add({ kind: "placement", valueId });
     const matches = this.placements.get(valueId) ?? [];
@@ -14949,8 +15456,13 @@ function buildIndex(source) {
     occupiedCells += 1;
   };
   const discoveryReads = new InitializerReadSet();
+  const placedRecordIds = /* @__PURE__ */ new Set();
   for (const root of source.rows) {
-    const grid = typeof root.classId !== "string" ? source.readRow(root.id, discoveryReads) : root;
+    let grid = root;
+    if (typeof root.classId !== "string") {
+      if (record(root.value) !== null) placedRecordIds.add(root.id);
+      grid = source.readRow(root.id, discoveryReads);
+    }
     if (typeof grid?.classId !== "string" || kinds.get(grid.classId) !== NeoWorldSystemClassKind.TileGrid)
       continue;
     const effectiveGrid = readRow(root.id);
@@ -15043,11 +15555,18 @@ function buildIndex(source) {
       }
     }
   }
-  return new WorldGridQueryIndex(grids, placements, reads, {
-    rowsScanned: source.rows.length,
-    placementsIndexed,
-    occupiedCells
-  });
+  return new WorldGridQueryIndex(
+    grids,
+    placements,
+    reads,
+    kinds,
+    placedRecordIds,
+    {
+      rowsScanned: source.rows.length,
+      placementsIndexed,
+      occupiedCells
+    }
+  );
 }
 function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -15495,70 +16014,6 @@ function floatFromDecimalString(value) {
   return Number(value);
 }
 
-// ../packages/models/src/interfaces/interface-graph.ts
-var CircularInterfaceExtensionError = class extends Error {
-  constructor(interfaceId, chain) {
-    super(
-      `Circular interface extension detected at "${interfaceId}"; chain: ${chain.join(" -> ")}`
-    );
-    this.interfaceId = interfaceId;
-    this.chain = chain;
-    this.name = "CircularInterfaceExtensionError";
-  }
-  interfaceId;
-  chain;
-};
-function resolveInterfaceClosure(interfaceId, interfaces) {
-  const byId = new Map(
-    interfaces.map((neoInterface) => [neoInterface.id, neoInterface])
-  );
-  const result = [];
-  const emitted = /* @__PURE__ */ new Set();
-  const visiting = [];
-  const visitingSet = /* @__PURE__ */ new Set();
-  const visit = (id) => {
-    if (visitingSet.has(id)) {
-      throw new CircularInterfaceExtensionError(id, [...visiting, id]);
-    }
-    if (emitted.has(id)) return;
-    const neoInterface = byId.get(id);
-    if (!neoInterface) return;
-    visiting.push(id);
-    visitingSet.add(id);
-    result.push(neoInterface);
-    emitted.add(id);
-    for (const parentId of neoInterface.extendsInterfaceIds ?? []) {
-      visit(parentId);
-    }
-    visiting.pop();
-    visitingSet.delete(id);
-  };
-  visit(interfaceId);
-  return result;
-}
-function resolveImplementedInterfaces(classId, classes, interfaces) {
-  const result = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const schemaClass2 of resolveInheritanceChain(classId, classes)) {
-    for (const interfaceId of schemaClass2.implementsInterfaceIds ?? []) {
-      for (const neoInterface of resolveInterfaceClosure(
-        interfaceId,
-        interfaces
-      )) {
-        if (seen.has(neoInterface.id)) continue;
-        seen.add(neoInterface.id);
-        result.push(neoInterface);
-      }
-    }
-  }
-  return result;
-}
-function classImplementsInterface(classId, interfaceId, classes, interfaces) {
-  return resolveImplementedInterfaces(classId, classes, interfaces).some(
-    (neoInterface) => neoInterface.id === interfaceId
-  );
-}
-
 // ../packages/models/src/members/read-class-member.ts
 function readClassMember(args) {
   const { member, schemaKey } = args;
@@ -16577,8 +17032,8 @@ function evaluatorResolutionCache(ctx) {
     compiledFunctionByMemberId: /* @__PURE__ */ new Map(),
     compiledGetterByMemberId: /* @__PURE__ */ new Map(),
     compiledSetterByMemberId: /* @__PURE__ */ new Map(),
-    defaultValueResolutionCache: createDefaultValueResolutionCache(),
-    validatedConstructorDescriptorByInfo: /* @__PURE__ */ new WeakMap(),
+    defaultSchema: createDefaultSchemaResolutionCache(),
+    valueGenerations: /* @__PURE__ */ new WeakMap(),
     effectiveStorageResolver: void 0
   };
   resolutionCacheByMembers.set(members, {
@@ -16617,6 +17072,24 @@ function cachedInstanceEnv(classId, classArguments2, ctx) {
 function cachedIsInitValueContent(value, ctx) {
   return evaluatorDefaultValueDocument(ctx).isInitValueContent(value);
 }
+function evaluatorValueGeneration(ctx) {
+  const { values, databaseVM } = ctx.vm;
+  const valueGeneration = databaseVM?.valueGeneration;
+  const resolution = evaluatorResolutionCache(ctx);
+  const key = databaseVM ?? values;
+  const entry = resolution.valueGenerations.get(key);
+  if (entry !== void 0 && entry.values === values && entry.valueGeneration === valueGeneration) {
+    return entry;
+  }
+  const generation = {
+    values,
+    valueGeneration,
+    defaults: createDefaultValueResolutionCache(resolution.defaultSchema),
+    constructorDescriptors: /* @__PURE__ */ new WeakMap()
+  };
+  resolution.valueGenerations.set(key, generation);
+  return generation;
+}
 function evaluatorDefaultValueDocument(ctx) {
   if (ctx.__defaultValueDocument !== void 0) {
     return ctx.__defaultValueDocument;
@@ -16637,7 +17110,7 @@ function evaluatorDefaultValueDocument(ctx) {
       projectFiles: ctx.vm.projectFiles ?? [],
       textureTemplates: ctx.vm.textureTemplates ?? []
     },
-    { cache: evaluatorResolutionCache(ctx).defaultValueResolutionCache }
+    { cache: evaluatorValueGeneration(ctx).defaults }
   );
   ctx.__defaultValueDocument = document2;
   return document2;
@@ -19088,8 +19561,12 @@ function bindOmittedConstantSlot(destination, member, value, ctx) {
   if (isMemberClassBase(member) || isMemberListBase(member) || isMemberDictionaryBase(member))
     return false;
   const resolved = resolveMember(member, ctx.vm.members);
-  if (!isConstantMember(constructorDefaultValueDocument(ctx, member), resolved))
-    return false;
+  const decision = constantMemberDecision(
+    constructorDefaultValueDocument(ctx, member),
+    resolved
+  );
+  recordDeclarationReads(ctx, decision.reads);
+  if (!decision.constant) return false;
   const { createdValues } = construction;
   const staged = createdValues.length;
   const row = materializeConstructorArgumentValue({
@@ -21472,6 +21949,17 @@ function ensureVirtualExpansionIndexed(rows, ctx, existingIndexes) {
   indexes3.indexedVirtualRowSets.add(rows);
 }
 var constantDeclarationRoots = /* @__PURE__ */ new WeakMap();
+function recordDeclarationReads(ctx, reads) {
+  for (const id of reads.valueIds) ctx.valueDependencies?.add(id);
+  for (const id of reads.containerIds) ctx.containerDependencies?.add(id);
+}
+function constantMemberDecision(document2, member) {
+  const reads = {
+    valueIds: /* @__PURE__ */ new Set(),
+    containerIds: /* @__PURE__ */ new Set()
+  };
+  return { constant: isConstantMember(document2, member, reads), reads };
+}
 function readDeclarationDefault(member, ctx) {
   if (member?.defaultValue === void 0 || member.defaultValue === null) {
     return { matched: false };
@@ -21486,16 +21974,20 @@ function readDeclarationDefault(member, ctx) {
         constantDeclarationRoots.set(session, shared);
       }
     }
-    const known = shared?.get(member.id);
-    if (typeof known === "string" && session?.has(known) === true) {
+    let known = shared?.get(member.id);
+    if (known !== void 0) recordDeclarationReads(ctx, known.reads);
+    if (known?.root !== void 0 && session?.has(known.root) === true) {
       return {
         matched: true,
-        value: resolveValueIfIdForMember(known, member, ctx)
+        value: resolveValueIfIdForMember(known.root, member, ctx)
       };
     }
     const document2 = constructorDefaultValueDocument(ctx, member);
-    const constant = shared !== void 0 && known !== false && (known !== void 0 || isConstantMember(document2, member));
-    if (shared !== void 0 && !constant) shared.set(member.id, false);
+    if (shared !== void 0 && known === void 0) {
+      known = constantMemberDecision(document2, member);
+      recordDeclarationReads(ctx, known.reads);
+      shared.set(member.id, known);
+    }
     const created = [];
     const closeFrame = pushConstructionFrame(ctx, `${member.name} declaration`);
     try {
@@ -21521,7 +22013,7 @@ function readDeclarationDefault(member, ctx) {
         )
       });
       stageConstructedRows([root, ...created], ctx);
-      if (constant) shared?.set(member.id, root.id);
+      if (known?.constant === true) known.root = root.id;
       return {
         matched: true,
         value: resolveValueIfIdForMember(root.id, member, ctx)
@@ -21845,6 +22337,10 @@ function resolveMemberForValueRow(row, ctx, visited) {
 function worldGridQueryIndexForContext(context) {
   const ctx = withEvaluationRuntime(context, []);
   const vm = ctx.vm;
+  const database = vm.databaseVM;
+  const overlayRevision = ctx.__valueOverlay instanceof LazyValueOverlay ? ctx.__valueOverlay.worldRevision : 0;
+  if (overlayRevision === 0 && database?.worldGridQueryIndex !== void 0)
+    return database.worldGridQueryIndex();
   const readContexts = /* @__PURE__ */ new WeakMap();
   let geometryOverlay;
   const readContext = (reads) => {
@@ -21867,24 +22363,26 @@ function worldGridQueryIndexForContext(context) {
     readContexts.set(reads, next);
     return next;
   };
-  const overlayRevision = ctx.__valueOverlay instanceof LazyValueOverlay ? ctx.__valueOverlay.worldRevision : 0;
+  const recording = (reads, read) => database?.recordVirtualInstanceReads === void 0 ? read() : database.recordVirtualInstanceReads(reads, read);
+  const host = vm.worldQueryCache;
   return getWorldGridQueryIndex({
-    cacheKey: overlayRevision > 0 && ctx.__valueOverlay !== void 0 ? ctx.__valueOverlay : vm.worldQueryCache?.key ?? vm.databaseVM?.evaluatorIndexes ?? vm.values,
+    cacheKey: overlayRevision > 0 && ctx.__valueOverlay !== void 0 ? ctx.__valueOverlay : host?.key ?? vm.databaseVM?.evaluatorIndexes ?? vm.values,
     revision: [
-      ...vm.worldQueryCache?.revision ?? vm.databaseVM?.worldQueryRevision ?? [],
-      vm.values,
-      vm.classes,
-      vm.members,
-      vm.internalRecordRelations,
-      vm.variants,
-      vm.variantFolders,
-      vm.schemaRevision,
+      ...host?.revision ?? [
+        vm.values,
+        vm.classes,
+        vm.members,
+        vm.internalRecordRelations,
+        vm.variants,
+        vm.variantFolders,
+        vm.schemaRevision
+      ],
       ...overlayRevision === 0 ? [] : [ctx.__valueOverlay, overlayRevision]
     ],
     rows: vm.values,
     classes: vm.classes,
     relations: vm.internalRecordRelations ?? [],
-    readRow(id, reads) {
+    readRow: (id, reads) => recording(reads, () => {
       const current = readContext(reads);
       const row = evalValueById(
         current,
@@ -21895,8 +22393,8 @@ function worldGridQueryIndexForContext(context) {
       if (row === null || typeof row.classId === "string") return row;
       const classId = classIdForValueRow(row, current);
       return classId === void 0 ? row : { ...row, classId };
-    },
-    readField(id, key, reads) {
+    }),
+    readField: (id, key, reads) => recording(reads, () => {
       const current = readContext(reads);
       const row = evalValueById(
         current,
@@ -21915,8 +22413,8 @@ function worldGridQueryIndexForContext(context) {
         thisValue: row.value,
         thisValueRowId: row.id
       });
-    },
-    valueId(value, reads) {
+    }),
+    valueId: (value, reads) => recording(reads, () => {
       const current = readContext(reads);
       if (typeof value === "string" && evalValueById(
         current,
@@ -21926,7 +22424,7 @@ function worldGridQueryIndexForContext(context) {
       ) !== null)
         return value;
       return trackedRowForValueReference(value, current)?.id ?? null;
-    }
+    })
   });
 }
 function readSystemNativeField(value, key, ctx) {
@@ -23565,7 +24063,7 @@ function validateClassConstructorDescriptor(info, ctx, requireEveryRequiredField
   }
   const genericSlot = ctx.__constructionGenericSlots?.toReversed().find((slot) => slot.classId === classId) ?? ctx.__storedConstructionReplaySlot;
   const slotArguments = genericSlot?.classId === classId ? genericSlot.classArguments : void 0;
-  const descriptorCache = evaluatorResolutionCache(ctx).validatedConstructorDescriptorByInfo;
+  const descriptorCache = evaluatorValueGeneration(ctx).constructorDescriptors;
   const descriptorCacheKey = `${requireEveryRequiredField}:${ctx.storedConstructionReplay === true}:${JSON.stringify(slotArguments ?? info.schemaClassInfo.typeArguments ?? null)}`;
   const cachedDescriptor = descriptorCache.get(info)?.get(descriptorCacheKey);
   if (cachedDescriptor !== void 0) return cachedDescriptor;
@@ -24183,6 +24681,8 @@ function constructClassValue(info, scope, ctx) {
   }
 }
 function constructorDefaultValueDocument(ctx, syntheticMember) {
+  const database = ctx.vm.databaseVM;
+  const entryIdsOf = database?.unorderedListEntryIds?.bind(database);
   return {
     listenerDefaultCapture: ctx.listenerDefaultCapture,
     beforeValueAllocation: ctx.beforeValueAllocation,
@@ -24195,11 +24695,24 @@ function constructorDefaultValueDocument(ctx, syntheticMember) {
     // immutable base plus its indexes avoids copying and linearly scanning
     // the entire project for every constructor replay.
     values: ctx.vm.values,
-    memberById: ctx.vm.databaseVM?.memberById,
-    valueById: ctx.vm.databaseVM?.defaultValueById ?? ctx.vm.databaseVM?.valueById,
+    memberById: database?.memberById,
+    // The declaration rows a default clones are reads of this evaluation.
+    ...database === void 0 ? {} : {
+      valueById: (id) => {
+        ctx.valueDependencies?.add(id);
+        return database.defaultValueById !== void 0 ? database.defaultValueById(id) : database.valueById(id);
+      }
+    },
+    ...entryIdsOf === void 0 ? {} : {
+      unorderedListEntryIds: (containerId) => {
+        ctx.containerDependencies?.add(containerId);
+        return entryIdsOf(containerId);
+      }
+    },
     resolvedMember: (member) => member === syntheticMember ? syntheticMember : cachedResolvedMember(member, ctx),
     storedInstanceSchema: (nestedClassId) => cachedStoredInstanceSchema(nestedClassId, ctx),
     storedInstanceMaterializationPlan: (nestedClassId, instanceEnv) => cachedStoredInstanceMaterializationPlan(nestedClassId, instanceEnv, ctx),
+    recordPlanReads: (reads) => recordDeclarationReads(ctx, reads),
     instanceEnv: (nestedClassId, classArguments2) => cachedInstanceEnv(nestedClassId, classArguments2, ctx),
     isInitValueContent: (value) => cachedIsInitValueContent(value, ctx),
     createValueRow: (projectId, body) => buildNewValue(
@@ -24849,6 +25362,11 @@ function evaluateInitializerInContext(init, member, ctx, createdValues, argument
         sessionValueExport: "defer"
       }
     );
+  } catch (error) {
+    const ownerId = compileMemberId ?? Reflect.get(member, "id");
+    if (error instanceof NSGetterRuntimeError && sourceValueId === null && typeof ownerId === "string")
+      error.sourceOwnerId ??= ownerId;
+    throw error;
   } finally {
     closeFrame();
   }
@@ -27728,10 +28246,15 @@ function lookupDeclaredTypeInfo(member, collectionTypeInfo) {
 }
 
 // ../packages/neoscript-runtime/src/values/member-declared-type-info.ts
-function resolveMemberDeclaredTypeInfo(member, members) {
-  return resolveMemberDeclaredTypeInfoInternal(member, members, /* @__PURE__ */ new Set());
+function resolveMemberDeclaredTypeInfo(member, members, ownerClass = null) {
+  return resolveMemberDeclaredTypeInfoInternal(
+    member,
+    members,
+    /* @__PURE__ */ new Set(),
+    ownerClass
+  );
 }
-function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
+function resolveMemberDeclaredTypeInfoInternal(member, members, seen, ownerClass) {
   const resolved = resolveMember(member, members);
   const memberId = getField(resolved, "id");
   if (typeof memberId === "string" && seen.has(memberId)) return null;
@@ -27749,7 +28272,8 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
           const argumentType = resolveMemberDeclaredTypeInfoInternal(
             argumentMember,
             members,
-            nextSeen
+            nextSeen,
+            ownerClass
           );
           return argumentType === null ? [] : [[genericParamId, argumentType]];
         }
@@ -27815,7 +28339,8 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
     const entryTypeInfo = resolveMemberDeclaredTypeInfoInternal(
       entry,
       members,
-      nextSeen
+      nextSeen,
+      ownerClass
     );
     if (entryTypeInfo === null) return null;
     return {
@@ -27832,12 +28357,29 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
     if (collection === void 0) return null;
     return lookupDeclaredTypeInfo(
       resolved,
-      resolveMemberDeclaredTypeInfoInternal(collection, members, nextSeen)
+      resolveMemberDeclaredTypeInfoInternal(
+        collection,
+        members,
+        nextSeen,
+        ownerClass
+      )
     );
   }
   if (resolved.kind === 9 /* Lookup */) return null;
   if (!memberKindSupportsStorage(resolved.kind)) return null;
-  if (resolved.kind === 21 /* Generic */) return null;
+  if (isMemberGenericBase(resolved)) {
+    if (ownerClass === null) return null;
+    const declaration = ownerClass.genericParams?.find(
+      (parameter3) => parameter3.id === resolved.genericParamId
+    );
+    if (declaration === void 0) return null;
+    return {
+      type: 21 /* Generic */,
+      required: isRequiredMember(resolved),
+      ownerClassId: ownerClass.id,
+      genericParamId: declaration.id
+    };
+  }
   return {
     type: resolved.kind,
     required: isRequiredMember(resolved)
@@ -29419,11 +29961,8 @@ var Parser = class _Parser {
    * always opens with a type expression, which can be:
    *   - A primitive keyword: int / float / bool / string
    *   - `Dictionary` keyword followed by `<`
-   *   - An identifier (Class or Enum) with `[]` suffix or
-   *     followed by another identifier (the var name).
-   *
-   * We don't fully parse the type here — we just decide whether to commit
-   * to the varDecl path or fall through to an expression statement.
+   *   - Any other type the type grammar parses (`Item[]`, `Box<int>?`,
+   *     `NeoDelegate<int, int>`) followed by the var name and `=`.
    */
   looksLikeVarDecl() {
     const t = this.peek();
@@ -29440,25 +29979,53 @@ var Parser = class _Parser {
       return true;
     }
     if (!isIdentifier(t)) return false;
-    let j = this.i + 1;
-    const tk = (k) => this.tokens[k];
-    while (tk(j)?.kind === "punctuation" && tk(j)?.text === "[" && tk(j + 1)?.kind === "punctuation" && tk(j + 1)?.text === "]") {
-      j += 2;
-    }
-    if (tk(j)?.kind === "operator" && tk(j)?.text === "?") {
-      j += 1;
-    }
-    const name = tk(j);
-    if (name !== void 0 && isIdentifier(name) && tk(j + 1)?.kind === "operator" && tk(j + 1)?.text === "=") {
-      return true;
+    const end = this.typeEnd();
+    const name = this.tokens[end];
+    const equals = this.tokens[end + 1];
+    return end >= 0 && name !== void 0 && isIdentifier(name) && equals?.kind === "operator" && equals.text === "=";
+  }
+  /**
+   * Token index just past the type that starts at the cursor, or -1 when the
+   * type grammar rejects it. The cursor does not move. Editor recovery shares
+   * this with declaration lookahead so both agree on every type form.
+   */
+  typeEnd(options = {}) {
+    const start = this.i;
+    this.probingType = true;
+    try {
+      return this.parseTypeOrFail(options) ? this.i : -1;
+    } catch {
+      return -1;
+    } finally {
+      this.probingType = false;
+      this.i = start;
     }
-    return false;
+  }
+  /**
+   * True while `typeEnd` probes. Lookahead runs at every identifier on editor
+   * paths, so a rejected type returns null instead of constructing an error.
+   */
+  probingType = false;
+  /** A type-grammar failure: null while probing, otherwise a CompileError. */
+  typeFailure(message, token) {
+    if (this.probingType) return null;
+    throw new CompileError(message, at(token));
+  }
+  /** `expect` inside the type grammar: false while probing a mismatch. */
+  expectTypeToken(kind, text) {
+    if (this.probingType && !tokenMatches(this.peek(), kind, text))
+      return false;
+    this.expect(kind, text);
+    return true;
   }
   // ------------------------------------------------------------------
   // Types
   // ------------------------------------------------------------------
   /** Parses a type annotation (used in varDecls and Dictionary generics). */
   parseType(options = {}) {
+    return this.parseTypeOrFail(options);
+  }
+  parseTypeOrFail(options) {
     const startPos = at(this.peek());
     let inner;
     const t = this.peek();
@@ -29472,17 +30039,18 @@ var Parser = class _Parser {
       };
     } else if (t.kind === "type" && (t.text === "Dictionary" || t.text === "List" || t.text === "Set")) {
       this.next();
-      this.expect("operator", "<");
+      if (!this.expectTypeToken("operator", "<")) return null;
       if (t.text === "Dictionary") {
-        const key = this.parseType();
+        const key = this.parseTypeOrFail({});
+        if (!key) return null;
         if (this.peek().text === ">")
-          throw new CompileError(
+          return this.typeFailure(
             "Dictionary requires a key type and a value type, for example Dictionary<string, int>.",
-            at(this.peek())
+            this.peek()
           );
-        this.expect("punctuation", ",");
-        const value = this.parseType();
-        this.expect("operator", ">");
+        if (!this.expectTypeToken("punctuation", ",")) return null;
+        const value = this.parseTypeOrFail({});
+        if (!value || !this.expectTypeToken("operator", ">")) return null;
         inner = {
           kind: "dict",
           key,
@@ -29491,8 +30059,8 @@ var Parser = class _Parser {
           pos: startPos
         };
       } else {
-        const element = this.parseType();
-        this.expect("operator", ">");
+        const element = this.parseTypeOrFail({});
+        if (!element || !this.expectTypeToken("operator", ">")) return null;
         inner = {
           kind: t.text === "List" ? "list" : "set",
           element,
@@ -29504,10 +30072,12 @@ var Parser = class _Parser {
       this.next();
       const typeArguments = [];
       if (this.eat("operator", "<")) {
-        typeArguments.push(this.parseType());
-        while (this.eat("punctuation", ","))
-          typeArguments.push(this.parseType());
-        this.expect("operator", ">");
+        do {
+          const argument2 = typeArguments.length === 0 && t.text === "NeoDelegate" ? this.parseDelegateReturnType() : this.parseTypeOrFail({});
+          if (!argument2) return null;
+          typeArguments.push(argument2);
+        } while (this.eat("punctuation", ","));
+        if (!this.expectTypeToken("operator", ">")) return null;
       }
       inner = {
         kind: "named",
@@ -29517,7 +30087,7 @@ var Parser = class _Parser {
         pos: startPos
       };
     } else {
-      throw new CompileError(`Expected a type, got ${describeToken(t)}`, at(t));
+      return this.typeFailure(`Expected a type, got ${describeToken(t)}`, t);
     }
     while (this.peek().kind === "punctuation" && this.peek().text === "[" && this.peek(1).kind === "punctuation" && this.peek(1).text === "]") {
       const arrPos = at(this.peek());
@@ -29536,6 +30106,14 @@ var Parser = class _Parser {
     }
     return inner;
   }
+  /** `NeoDelegate<void, …>`: the return slot is the one type that may be `void`. */
+  parseDelegateReturnType() {
+    const t = this.peek();
+    if (t.kind !== "keyword" || t.text !== "void")
+      return this.parseTypeOrFail({});
+    this.next();
+    return { kind: "primitive", name: "void", required: true, pos: at(t) };
+  }
   /**
    * `is T ? a : b` is ambiguous at the token level because `?` is also the
    * nullable type suffix. A colon at the same delimiter depth makes it the
@@ -29890,7 +30468,7 @@ var Parser = class _Parser {
     }
     while (true) {
       let name = null;
-      if ((isIdentifier(this.peek()) || this.peek().kind === "keyword" && (this.peek().text === "default" || isValidNeoProjectIdentifier(this.peek().text))) && this.peek(1).kind === "punctuation" && this.peek(1).text === ":") {
+      if (isCallArgumentLabelToken(this.peek()) && this.peek(1).kind === "punctuation" && this.peek(1).text === ":") {
         name = this.next().text;
         this.next();
       }
@@ -30373,6 +30951,9 @@ function at(token) {
 function tokenMatches(token, kind, text) {
   return (kind === "identifier" ? isIdentifier(token) : token.kind === kind) && (text === void 0 || token.text === text);
 }
+function isCallArgumentLabelToken(token) {
+  return isIdentifier(token) || token.kind === "keyword" && (token.text === "default" || isValidNeoProjectIdentifier(token.text));
+}
 function isIdentifier(token) {
   return token.kind === "identifier" || token.kind === "type" && token.text !== "int" && token.text !== "float" && token.text !== "decimal" && token.text !== "bool" && token.text !== "string" && token.text !== "Dictionary" && token.text !== "List" && token.text !== "Set";
 }
@@ -30484,6 +31065,41 @@ function declarationInitializerContext(document2) {
   });
   return created;
 }
+var defaultValuePlansByDocument = /* @__PURE__ */ new WeakMap();
+function defaultValuePlans(document2) {
+  const key = document2.databaseVM ?? initializerEvaluatorCacheKey(document2);
+  const revision = initializerEvaluatorCacheRevision(document2);
+  const valueGeneration = document2.databaseVM?.valueGeneration;
+  const cached = defaultValuePlansByDocument.get(key);
+  if (cached !== void 0 && (revision === void 0 ? cached.members === document2.members && cached.classes === document2.classes && cached.values === document2.values && cached.constructors === document2.constructors : cached.revision === revision && cached.valueGeneration === valueGeneration)) {
+    return cached.plans;
+  }
+  const lookups = initializerEvaluatorLookups(document2);
+  const plans = withIndexedDefaultValueDocument({
+    project: document2.project,
+    members: document2.members,
+    classes: document2.classes,
+    enums: document2.enums,
+    values: document2.values,
+    constructors: document2.constructors,
+    projectFiles: document2.projectFiles,
+    textureTemplates: document2.textureTemplates,
+    memberById: lookups.memberById,
+    valueById: lookups.defaultValueById ?? lookups.valueById,
+    // A host database without list membership falls back to `values`.
+    unorderedListEntryIds: document2.databaseVM?.unorderedListEntryIds === void 0 && document2.databaseVM !== void 0 ? void 0 : lookups.unorderedListEntryIds
+  });
+  defaultValuePlansByDocument.set(key, {
+    members: document2.members,
+    classes: document2.classes,
+    values: document2.values,
+    constructors: document2.constructors,
+    revision,
+    valueGeneration,
+    plans
+  });
+  return plans;
+}
 function evaluateInitializerMaterialization(args) {
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
@@ -30591,9 +31207,6 @@ function materializeInitializerValue(args) {
 function materializeMemberDefaultValue(args) {
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
-  args.readTracking?.recordUnattributableValueRead(
-    ownershipChainRead("declaration-owner-resolution", args.envelope.id)
-  );
   const declarationArguments = (member, init, sourceValueId) => {
     const { valuesById, rootOwners } = declarationInitializerContext(
       args.document
@@ -30602,7 +31215,8 @@ function materializeMemberDefaultValue(args) {
       args.document,
       sourceValueId,
       rootOwners,
-      valuesById
+      valuesById,
+      (id) => args.readTracking?.valueIds.add(id)
     ).ownerClass : typeof Reflect.get(member, "id") === "string" ? findSchemaPlacement(
       String(Reflect.get(member, "id")),
       args.document.classes
@@ -30624,15 +31238,38 @@ function materializeMemberDefaultValue(args) {
     );
   };
   let lookups;
+  const evaluatorLookups = () => lookups ??= initializerEvaluatorLookups(args.document, args.readTracking);
+  const plans = args.readTracking !== void 0 && args.document.databaseVM === void 0 ? void 0 : defaultValuePlans(args.document);
   const built = buildDefaultMemberValue({
     document: {
       ...args.document,
+      // The declaration rows a default clones are reads of this
+      // materialization, like any row its initializers read.
       valueById: (id) => {
-        lookups ??= initializerEvaluatorLookups(
-          args.document,
-          args.readTracking
-        );
-        return (lookups.defaultValueById ?? lookups.valueById)(id);
+        args.readTracking?.valueIds.add(id);
+        const database = evaluatorLookups();
+        return database.defaultValueById !== void 0 ? database.defaultValueById(id) : database.valueById(id);
+      },
+      unorderedListEntryIds: (containerId) => {
+        args.readTracking?.containerIds.add(containerId);
+        const entryIds = evaluatorLookups().unorderedListEntryIds?.(containerId);
+        if (entryIds === void 0) {
+          throw new Error(
+            `Initializer lookups resolve no unordered-list membership for container "${containerId}".`
+          );
+        }
+        return entryIds;
+      },
+      // Not `resolvedMember`: its id-keyed cache would answer for the
+      // caller's rewritten copy of a member with the stored original.
+      ...plans === void 0 ? {} : {
+        instanceEnv: plans.instanceEnv,
+        storedInstanceMaterializationPlan: plans.storedInstanceMaterializationPlan
+      },
+      recordPlanReads: (reads) => {
+        for (const id of reads.valueIds) args.readTracking?.valueIds.add(id);
+        for (const id of reads.containerIds)
+          args.readTracking?.containerIds.add(id);
       }
     },
     projectId: args.envelope.projectId,
@@ -30711,10 +31348,6 @@ function buildVirtualInstanceMaterializedIndex(args) {
     })
   };
 }
-var CORPUS_SCANNING_MEMBER_KINDS = /* @__PURE__ */ new Set([
-  9 /* Lookup */,
-  18 /* DialogueLookup */
-]);
 function derivesContentFromMemberDefault(args) {
   const member = args.member;
   if (!isMemberClassBase(member)) return false;
@@ -30778,43 +31411,50 @@ var VirtualExpansionUnsupportedError = class extends Error {
     this.name = "VirtualExpansionUnsupportedError";
   }
 };
-function expandStoredInstance(args) {
-  const recorder = args.readRecorder ?? null;
-  const readTracking = recorder === null ? void 0 : new InitializerReadSet();
-  const trackMaterialization = readTracking === void 0 ? (materialize) => materialize() : (materialize) => {
+function materializationReadTracking(recorder) {
+  if (recorder === void 0)
+    return { readTracking: void 0, trackMaterialization: (m) => m() };
+  const readTracking = new InitializerReadSet();
+  const trackMaterialization = (materialize) => {
     try {
       return materialize();
     } finally {
       for (const valueId of readTracking.valueIds) {
-        recorder?.recordValueRead(valueId);
+        recorder.recordValueRead(valueId);
       }
       for (const textId of readTracking.localizedTextIds) {
-        recorder?.recordLocalizedTextRead(textId);
+        recorder.recordLocalizedTextRead(textId);
       }
       for (const variantId of readTracking.variantIds) {
-        recorder?.recordVariantRead(variantId);
+        recorder.recordVariantRead(variantId);
       }
       for (const memberId of readTracking.staticMemberIds) {
-        recorder?.recordStaticMemberRead(memberId);
+        recorder.recordStaticMemberRead(memberId);
       }
       for (const containerId of readTracking.containerIds) {
-        recorder?.recordContainerMembershipRead(containerId);
+        recorder.recordContainerMembershipRead(containerId);
       }
       for (const read of readTracking.worldQueries) {
-        recorder?.recordWorldQueryRead?.(read);
+        recorder.recordWorldQueryRead?.(read);
       }
-      if (readTracking.hasOwnershipChainRead) {
-        recorder?.recordGlobalRead(OWNERSHIP_CHAIN_READ);
+      if (readTracking.hasValuePlacementRead) {
+        recorder.recordValuePlacementRead();
       }
       for (const containerId of readTracking.containerEntryReadIds) {
-        recorder?.recordGlobalRead(containerEntriesRead(containerId));
+        recorder.recordContainerMembershipRead(containerId);
       }
       for (const reason of readTracking.corpusReadReasons) {
-        recorder?.recordGlobalRead(reason);
+        recorder.recordGlobalRead(reason);
       }
     }
   };
-  recorder?.recordValueRead(args.instanceRoot.id);
+  return { readTracking, trackMaterialization };
+}
+function expandStoredInstance(args) {
+  const { readTracking, trackMaterialization } = materializationReadTracking(
+    args.readRecorder
+  );
+  args.readRecorder?.recordValueRead(args.instanceRoot.id);
   const rootMember = resolveMember(args.rootMember, args.document.members);
   if (!isMemberClassBase(rootMember)) {
     throw new Error(
@@ -30850,11 +31490,6 @@ function expandStoredInstance(args) {
       `Virtual expansion root "${args.instanceRoot.id}" is missing required constructor arguments.`
     );
   }
-  const constructorArguments = storedConstructorReplayArguments(
-    requiredConstructor,
-    storedArgs,
-    instanceRoot.id
-  );
   const {
     value: _value,
     classId: _classId,
@@ -30875,6 +31510,34 @@ function expandStoredInstance(args) {
     instanceRoot
   );
   const replayMember = closedRootMember === rootMember ? rootMember : { ...closedRootMember, classId };
+  let environment;
+  const constructorArguments = storedConstructorReplayArguments(
+    requiredConstructor === null ? null : {
+      ...requiredConstructor,
+      argumentTypes: requiredConstructor.argumentTypes.map((argument2) => {
+        if (argument2.type !== 21 /* Generic */) return argument2;
+        environment ??= resolveInstanceEnv(
+          classId,
+          replayMember.classArguments,
+          args.document.classes
+        );
+        const type = substituteInheritedCallableTypeInfo(
+          argument2,
+          environment,
+          args.document.classes,
+          args.document.members
+        );
+        if (type.type === NS_TYPE_VOID) {
+          throw new Error(
+            `Constructor parameter "${argument2.name}" on "${classId}" cannot have type void.`
+          );
+        }
+        return { ...type, name: argument2.name };
+      })
+    },
+    storedArgs,
+    instanceRoot.id
+  );
   const replay = (fields) => {
     const init = storedConstructorReplayInitializer({
       classId,
@@ -30939,11 +31602,7 @@ function expandStoredInstance(args) {
 function resolveVirtualInstanceGraph(args) {
   const expansion = args.expansionIndex ?? indexExpansion(args);
   const recorder = args.readRecorder ?? null;
-  if (recorder !== null) {
-    recorder.recordValueRead(args.instanceRoot.id);
-    const unattributable = firstUnattributableExpansionMember(expansion);
-    if (unattributable !== null) recorder.recordGlobalRead(unattributable);
-  }
+  recorder?.recordValueRead(args.instanceRoot.id);
   const materializedById = args.materializedIndex?.rowsById ?? new Map(
     (args.materializedRows ?? args.document.values).map((row) => [
       row.id,
@@ -31498,15 +32157,6 @@ function mergeExpandedAndMaterializedRow(expanded, materialized) {
   if (merged.sourceValueId === materialized.id) delete merged.sourceValueId;
   return merged;
 }
-function firstUnattributableExpansionMember(expansion) {
-  for (const node of expansion.nodesByPath.values()) {
-    const member = node.member;
-    if (CORPUS_SCANNING_MEMBER_KINDS.has(member.kind)) {
-      return `corpus-scanning-member-kind:${node.memberId}`;
-    }
-  }
-  return null;
-}
 function prepareStoredClassValueResolution(args) {
   let listenerDefaults;
   let copiedListeners;
@@ -31518,9 +32168,10 @@ function prepareStoredClassValueResolution(args) {
     ...args.document,
     // Construction checks share the existing schema index across every nested default.
     memberById: args.document.memberById ?? ((id) => schema.member(id) ?? null),
-    evaluatorCache: {
-      key: initializerEvaluatorCacheKey(args.document),
-      revision: initializerEvaluatorCacheRevision(args.document)
+    // The same rows under a fresh object: share its evaluator caches.
+    evaluatorCache: args.document.evaluatorCache ?? {
+      key: args.document,
+      revision: void 0
     },
     listenerDefaultCapture: {
       begin: () => {
@@ -31596,27 +32247,32 @@ function expandStoredClassValue(args) {
   }
   const classId = root.classId ?? member.classId;
   args.readRecorder?.recordValueRead(root.id);
-  args.readRecorder?.recordGlobalRead("declaration-default");
-  const materialized = materializeMemberDefaultValue({
-    saveStaticBindings: args.saveStaticBindings,
-    sessionStaticBindings: args.sessionStaticBindings,
-    evaluateInitializer: args.evaluateInitializer,
-    document: args.document,
-    member: closeClassArgumentsFromRowStamp(
-      {
-        ...member,
-        classId,
-        defaultValue: derivesContentFromMemberDefault({
-          member,
-          instanceRoot: root,
-          effectiveClassId: classId
-        }) ? member.defaultValue : void 0
-      },
-      root
-    ),
-    envelope: root,
-    declarationRoot: true
-  });
+  const { readTracking, trackMaterialization } = materializationReadTracking(
+    args.readRecorder
+  );
+  const materialized = trackMaterialization(
+    () => materializeMemberDefaultValue({
+      ...readTracking === void 0 ? {} : { readTracking },
+      saveStaticBindings: args.saveStaticBindings,
+      sessionStaticBindings: args.sessionStaticBindings,
+      evaluateInitializer: args.evaluateInitializer,
+      document: args.document,
+      member: closeClassArgumentsFromRowStamp(
+        {
+          ...member,
+          classId,
+          defaultValue: derivesContentFromMemberDefault({
+            member,
+            instanceRoot: root,
+            effectiveClassId: classId
+          }) ? member.defaultValue : void 0
+        },
+        root
+      ),
+      envelope: root,
+      declarationRoot: true
+    })
+  );
   return {
     root: { ...root, classId, value: materialized.root.value },
     rows: materialized.createdValues,
@@ -32371,6 +33027,17 @@ function variantSwapDeclaredMember(document2, rootValueId) {
   if (placement === void 0) return void 0;
   return document2.members.find((member) => member.id === placement.memberId);
 }
+function emptyExpansionReads() {
+  return {
+    valueIds: /* @__PURE__ */ new Set(),
+    containerIds: /* @__PURE__ */ new Set(),
+    localizedTextIds: /* @__PURE__ */ new Set(),
+    variantIds: /* @__PURE__ */ new Set(),
+    staticMemberIds: /* @__PURE__ */ new Set(),
+    global: false,
+    merged: /* @__PURE__ */ new WeakSet()
+  };
+}
 function createHeadlessVirtualInstanceResolver(args) {
   const { document: document2 } = args;
   const membersById = args.membersById ?? new Map(document2.members.map((member) => [member.id, member]));
@@ -32394,16 +33061,22 @@ function createHeadlessVirtualInstanceResolver(args) {
   const emptyRows = [];
   const graphByValueId = /* @__PURE__ */ new Map();
   const failedRootIds = /* @__PURE__ */ new Set();
+  const expandingRootIds = /* @__PURE__ */ new Set();
   const expandedRowById = /* @__PURE__ */ new Map();
   const expandedRowByRecord = /* @__PURE__ */ new WeakMap();
   const readsByRootId = /* @__PURE__ */ new Map();
   const activeReads = [];
   const sharedByReceiverId = /* @__PURE__ */ new Map();
+  const callerReads = /* @__PURE__ */ new WeakMap();
   const mergeReads = (reads) => {
     for (const active of activeReads) {
-      if (active === reads) continue;
+      if (active === reads || active.merged.has(reads)) continue;
+      active.merged.add(reads);
       for (const id of reads.valueIds) active.valueIds.add(id);
       for (const id of reads.containerIds) active.containerIds.add(id);
+      for (const id of reads.localizedTextIds) active.localizedTextIds.add(id);
+      for (const id of reads.variantIds) active.variantIds.add(id);
+      for (const id of reads.staticMemberIds) active.staticMemberIds.add(id);
       if (reads.global) active.global = true;
     }
   };
@@ -32412,9 +33085,18 @@ function createHeadlessVirtualInstanceResolver(args) {
       for (const active of activeReads) active.valueIds.add(id);
       args.readRecorder?.recordValueRead(id);
     },
-    recordLocalizedTextRead: (id) => args.readRecorder?.recordLocalizedTextRead(id),
-    recordVariantRead: (id) => args.readRecorder?.recordVariantRead(id),
-    recordStaticMemberRead: (id) => args.readRecorder?.recordStaticMemberRead(id),
+    recordLocalizedTextRead: (id) => {
+      for (const active of activeReads) active.localizedTextIds.add(id);
+      args.readRecorder?.recordLocalizedTextRead(id);
+    },
+    recordVariantRead: (id) => {
+      for (const active of activeReads) active.variantIds.add(id);
+      args.readRecorder?.recordVariantRead(id);
+    },
+    recordStaticMemberRead: (id) => {
+      for (const active of activeReads) active.staticMemberIds.add(id);
+      args.readRecorder?.recordStaticMemberRead(id);
+    },
     recordContainerMembershipRead: (id) => {
       for (const active of activeReads) active.containerIds.add(id);
       args.readRecorder?.recordContainerMembershipRead(id);
@@ -32460,6 +33142,7 @@ function createHeadlessVirtualInstanceResolver(args) {
       if (reads2 !== void 0) mergeReads(reads2);
       return cached;
     }
+    if (expandingRootIds.has(rootId)) return emptyRows;
     if (failedRootIds.has(rootId)) return emptyRows;
     const instanceRoot = rawById.get(rootId);
     if (instanceRoot === void 0 || declaredMember === void 0) {
@@ -32475,12 +33158,9 @@ function createHeadlessVirtualInstanceResolver(args) {
       failedRootIds.add(rootId);
       return emptyRows;
     }
-    const reads = {
-      valueIds: /* @__PURE__ */ new Set(),
-      containerIds: /* @__PURE__ */ new Set(),
-      global: false
-    };
+    const reads = emptyExpansionReads();
     activeReads.push(reads);
+    expandingRootIds.add(rootId);
     try {
       const resolverDocument = resolverDocumentOnce();
       materializedIndex ??= buildVirtualInstanceMaterializedIndex({
@@ -32504,6 +33184,7 @@ function createHeadlessVirtualInstanceResolver(args) {
       failedRootIds.add(rootId);
       return emptyRows;
     } finally {
+      expandingRootIds.delete(rootId);
       activeReads.pop();
       mergeReads(reads);
     }
@@ -32522,9 +33203,15 @@ function createHeadlessVirtualInstanceResolver(args) {
       share.containerChanged
     );
     if (shared === null) return null;
+    recorder.recordValuePlacementRead();
     for (const id of shared.reads.valueIds) recorder.recordValueRead(id);
     for (const id of shared.reads.containerIds)
       recorder.recordContainerMembershipRead(id);
+    for (const id of shared.reads.localizedTextIds)
+      recorder.recordLocalizedTextRead(id);
+    for (const id of shared.reads.variantIds) recorder.recordVariantRead(id);
+    for (const id of shared.reads.staticMemberIds)
+      recorder.recordStaticMemberRead(id);
     if (graphRowsByRootId.get(shared.graph.instanceRootId) === void 0) {
       readsByRootId.set(shared.graph.instanceRootId, shared.reads);
       remember(shared.graph, shared.rows);
@@ -32568,7 +33255,16 @@ function createHeadlessVirtualInstanceResolver(args) {
       return graph?.instanceRootId === rootId ? graph : null;
     },
     virtualInstanceRowsForValue,
-    valueById: (id) => expandedRowById.get(id) ?? null,
+    valueById: (id) => {
+      const row = expandedRowById.get(id);
+      if (row === void 0) return null;
+      if (activeReads.length > 0) {
+        const rootId = graphByValueId.get(id)?.instanceRootId;
+        const reads = rootId === void 0 ? void 0 : readsByRootId.get(rootId);
+        if (reads !== void 0) mergeReads(reads);
+      }
+      return row;
+    },
     rowForValueReference: (value) => expandedRowByRecord.get(value) ?? null,
     virtualInstanceGraphForValue: (valueId) => {
       const known = graphByValueId.get(valueId);
@@ -32580,11 +33276,7 @@ function createHeadlessVirtualInstanceResolver(args) {
       return graphByValueId.get(valueId) ?? null;
     },
     shareExpansion: (receiverValueId, masked, containerChanged) => {
-      const reads = {
-        valueIds: /* @__PURE__ */ new Set(),
-        containerIds: /* @__PURE__ */ new Set(),
-        global: false
-      };
+      const reads = emptyExpansionReads();
       activeReads.push(reads);
       let rows;
       try {
@@ -32605,6 +33297,29 @@ function createHeadlessVirtualInstanceResolver(args) {
         );
       }
       return { graph, rows, reads };
+    },
+    recordReads: (target, read) => {
+      let reads = callerReads.get(target);
+      if (reads === void 0) {
+        reads = {
+          valueIds: target.valueIds,
+          containerIds: target.containerIds,
+          localizedTextIds: target.localizedTextIds,
+          variantIds: target.variantIds,
+          staticMemberIds: target.staticMemberIds,
+          global: false,
+          merged: /* @__PURE__ */ new WeakSet()
+        };
+        callerReads.set(target, reads);
+      }
+      activeReads.push(reads);
+      try {
+        return read();
+      } finally {
+        activeReads.pop();
+        if (reads.global)
+          target.recordUnattributableValueRead("virtual-instance-expansion");
+      }
     }
   };
 }
@@ -32654,6 +33369,10 @@ function initializerEvaluatorLookups(document2, readTracking) {
       ...databaseVM.changeListenerDefaultsForOwner === void 0 ? {} : {
         changeListenerDefaultsForOwner: (id) => databaseVM.changeListenerDefaultsForOwner(id)
       },
+      // Read live: this wrapper outlives a scalar's nullness change.
+      get valueGeneration() {
+        return databaseVM.valueGeneration;
+      },
       memberById: (id) => databaseVM.memberById(id),
       valueById: (id) => databaseVM.valueById(id),
       defaultValueById: (id) => databaseVM.defaultValueById?.(id) ?? databaseVM.valueById(id),
@@ -32680,6 +33399,7 @@ function initializerEvaluatorLookups(document2, readTracking) {
         return resolved;
       },
       virtualInstanceRowsForValue: (receiverValueId) => databaseVM.virtualInstanceRowsForValue(receiverValueId),
+      ...databaseVM.worldGridQueryIndex === void 0 ? {} : { worldGridQueryIndex: () => databaseVM.worldGridQueryIndex() },
       rowForValueReference: (value) => databaseVM.rowForValueReference?.(value) ?? null,
       resolveVariantInstanceGraph: (args) => {
         const resolver = databaseVM.resolveVariantInstanceGraph;
@@ -32708,88 +33428,45 @@ function initializerEvaluatorLookups(document2, readTracking) {
     indexKey,
     revision
   );
-  const shareFrom = document2.databaseVM === void 0 && document2.evaluatorOverlay !== void 0 ? sharedHeadlessResolver(document2.evaluatorOverlay) : void 0;
+  const shareFrom = document2.evaluatorOverlay === void 0 ? void 0 : sharedHeadlessResolver(document2.evaluatorOverlay);
   let hasListenerMetadata;
-  const headlessVirtualResolver = document2.databaseVM === void 0 ? createHeadlessVirtualInstanceResolver({
+  const headlessVirtualResolver = createHeadlessVirtualInstanceResolver({
     evaluateInitializer: evaluateMemberInitializer,
     document: document2,
     resolverLookups: () => lookups,
     ...shareFrom === void 0 ? {} : { shareFrom },
     ...readTracking === void 0 ? {} : { readRecorder: virtualReadRecorder(readTracking) }
-  }) : null;
+  });
   const lookups = {
     ...indexedLookups,
-    ...document2.databaseVM === void 0 && headlessVirtualResolver !== null ? {
-      changeListenerDefaultsForOwner: (id) => {
-        if (!(hasListenerMetadata ??= hasAuthoredChangeListenerMetadata(document2)))
-          return void 0;
-        const inherited = headlessVirtualResolver.virtualInstanceGraphForValue(id)?.listenerDefaultsByOwner?.get(id);
-        const authored = authoredChangeListenerOwners(document2.values).get(
-          id
-        );
-        return inherited === void 0 ? authored : { ...inherited, ...authored };
-      },
-      defaultValueById: (id) => declarationDefaultSource(
-        id,
-        indexedLookups.valueById(id),
-        headlessVirtualResolver.virtualInstanceGraphForValue
-      ),
-      valueById: (id) => indexedLookups.valueById(id) ?? headlessVirtualResolver.valueById(id),
-      rowForValueReference: (value) => indexedLookups.rowForValueReference?.(value) ?? headlessVirtualResolver.rowForValueReference(value),
-      virtualInstanceRowsForValue: (receiverValueId) => headlessVirtualResolver.virtualInstanceRowsForValue(
-        receiverValueId
-      ),
-      // Headless hosts still evaluate `ToVariant` during
-      // stored-construction replay — production's variant-constructed
-      // placements collapse through exactly this path. The shared core
-      // resolves against the plain document, with these lookups as the
-      // nested resolver.
-      resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument({
-        evaluateInitializer: evaluateMemberInitializer,
-        document: document2,
-        resolverLookups: lookups,
-        ...readTracking === void 0 ? {} : { readRecorder: virtualReadRecorder(readTracking) },
-        ...args
-      })
-    } : {
-      get worldQueryRevision() {
-        return document2.databaseVM?.worldQueryRevision;
-      },
-      memberById: (id) => document2.databaseVM?.memberById(id) ?? null,
-      valueById: (id) => document2.databaseVM?.valueById(id) ?? null,
-      variantById: (id) => document2.databaseVM?.variantById?.(id) ?? null,
-      // The VM's `valueById` answers EXPANDED-first: a collapse-stamped
-      // root resolves to a record the VM minted, an object the raw value
-      // index has never seen. Reference-identity dispatch (`.Id`, `is`,
-      // lookup selection) must reach the VM's reverse map for those
-      // records — dropping to the raw index alone made every lookup
-      // variant's initializer report "produced a value with no backing
-      // row" once P75 expansion started succeeding.
-      rowForValueReference: (value) => indexedLookups.rowForValueReference?.(value) ?? document2.databaseVM?.rowForValueReference?.(value) ?? null,
-      unorderedListEntryIds: (containerValueId) => {
-        const resolved = document2.databaseVM?.unorderedListEntryIds?.(containerValueId) ?? indexedLookups.unorderedListEntryIds?.(containerValueId);
-        if (resolved === void 0) {
-          throw new Error(
-            `Evaluator database resolves no unordered-list membership for container "${containerValueId}".`
-          );
-        }
-        return resolved;
-      },
-      virtualInstanceRowsForValue: (receiverValueId) => {
-        const databaseVM = document2.databaseVM;
-        if (databaseVM === void 0) return [];
-        return databaseVM.virtualInstanceRowsForValue(receiverValueId);
-      },
-      resolveVariantInstanceGraph: (args) => {
-        const resolver = document2.databaseVM?.resolveVariantInstanceGraph;
-        if (resolver === void 0) {
-          throw new Error(
-            "Evaluator database has no virtual variant resolver."
-          );
-        }
-        return resolver.call(document2.databaseVM, args);
-      }
-    }
+    changeListenerDefaultsForOwner: (id) => {
+      if (!(hasListenerMetadata ??= hasAuthoredChangeListenerMetadata(document2)))
+        return void 0;
+      const inherited = headlessVirtualResolver.virtualInstanceGraphForValue(id)?.listenerDefaultsByOwner?.get(id);
+      const authored = authoredChangeListenerOwners(document2.values).get(id);
+      return inherited === void 0 ? authored : { ...inherited, ...authored };
+    },
+    defaultValueById: (id) => declarationDefaultSource(
+      id,
+      indexedLookups.valueById(id),
+      headlessVirtualResolver.virtualInstanceGraphForValue
+    ),
+    valueById: (id) => indexedLookups.valueById(id) ?? headlessVirtualResolver.valueById(id),
+    rowForValueReference: (value) => indexedLookups.rowForValueReference?.(value) ?? headlessVirtualResolver.rowForValueReference(value),
+    virtualInstanceRowsForValue: (receiverValueId) => headlessVirtualResolver.virtualInstanceRowsForValue(receiverValueId),
+    recordVirtualInstanceReads: (reads, read) => headlessVirtualResolver.recordReads(reads, read),
+    // Headless hosts still evaluate `ToVariant` during
+    // stored-construction replay — production's variant-constructed
+    // placements collapse through exactly this path. The shared core
+    // resolves against the plain document, with these lookups as the
+    // nested resolver.
+    resolveVariantInstanceGraph: (args) => resolveVariantInstanceGraphForDocument({
+      evaluateInitializer: evaluateMemberInitializer,
+      document: document2,
+      resolverLookups: lookups,
+      ...readTracking === void 0 ? {} : { readRecorder: virtualReadRecorder(readTracking) },
+      ...args
+    })
   };
   if (!trackedHeadless) {
     evaluatorLookupsByDocument.set(lookupKey, {
@@ -32798,8 +33475,7 @@ function initializerEvaluatorLookups(document2, readTracking) {
       revision,
       lookups
     });
-    if (headlessVirtualResolver !== null)
-      headlessResolversByLookupKey.set(lookupKey, headlessVirtualResolver);
+    headlessResolversByLookupKey.set(lookupKey, headlessVirtualResolver);
   }
   return lookups;
 }
@@ -32976,6 +33652,9 @@ function evaluateMemberInitializer(args) {
     } catch (error) {
       if (error instanceof NSGetterRuntimeError) {
         error.initializerValueId ??= args.sourceValueId ?? void 0;
+        const memberId = Reflect.get(args.member, "id");
+        if (args.sourceValueId == null && typeof memberId === "string")
+          error.sourceOwnerId ??= memberId;
       }
       throw error;
     }
@@ -33116,53 +33795,6 @@ function memoizeFrozenJsonGuard(isValid) {
   };
 }
 
-// ../packages/manifest/src/value-comparison.ts
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// ../packages/neoscript-runtime/src/values/canonical-json.ts
-function canonicalJsonStringify(value) {
-  return JSON.stringify(toCanonicalJsonValue(value));
-}
-function toCanonicalJsonValue(value) {
-  if (value === null) return null;
-  if (value === void 0) return void 0;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "string") return value;
-  if (typeof value === "boolean") return value;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error("Cannot canonicalize a non-finite number.");
-    }
-    return value;
-  }
-  if (typeof value === "bigint") {
-    throw new Error("Cannot canonicalize bigint values.");
-  }
-  if (typeof value === "symbol") {
-    throw new Error("Cannot canonicalize symbol values.");
-  }
-  if (typeof value === "function") {
-    throw new Error("Cannot canonicalize function values.");
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => {
-      const canonicalItem = toCanonicalJsonValue(item);
-      if (canonicalItem === void 0) return null;
-      return canonicalItem;
-    });
-  }
-  const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
-  const canonicalObject = {};
-  for (const [key, entryValue] of entries) {
-    const canonicalValue = toCanonicalJsonValue(entryValue);
-    if (canonicalValue === void 0) continue;
-    canonicalObject[key] = canonicalValue;
-  }
-  return canonicalObject;
-}
-
 // ../packages/neoscript-language/src/syntax-index.ts
 var OPEN_TO_CLOSE = /* @__PURE__ */ new Map([
   ["(", ")"],
@@ -33240,6 +33872,9 @@ function buildNeoScriptEditorIndex(lexed, kind) {
   const references = [];
   const calls = [];
   const switches = [];
+  const lambdaBodies = [];
+  const contextualKeywordRanges = [];
+  const objectInitializers = [];
   for (const executable of executableRegions) {
     const executablePairs = pairBrackets(executable);
     const regionSwitches = indexSwitchStatements(
@@ -33249,7 +33884,13 @@ function buildNeoScriptEditorIndex(lexed, kind) {
       diagnostics
     );
     const regionLocals = applySwitchSectionScopes(
-      indexLocals(executable, executablePairs, lexed, diagnostics),
+      indexLocals(
+        executable,
+        executablePairs,
+        lexed,
+        diagnostics,
+        lambdaBodies
+      ),
       regionSwitches,
       lexed
     );
@@ -33260,24 +33901,36 @@ function buildNeoScriptEditorIndex(lexed, kind) {
       )
     );
     const contextualKeywords = new Set(
-      [
-        ...regionLocals.flatMap(
-          (local) => local.contextualKeywordRange ? [local.contextualKeywordRange] : []
-        ),
-        ...regionCalls.flatMap(
-          (call) => call.contextualKeywordRange ? [call.contextualKeywordRange] : []
-        )
-      ].map((range2) => `${range2.start.line}:${range2.start.character}`)
+      regionLocals.flatMap(
+        (local) => local.contextualKeywordRange ? [local.contextualKeywordRange] : []
+      ).map((range2) => `${range2.start.line}:${range2.start.character}`)
     );
     locals.push(...regionLocals);
     references.push(
-      ...indexReferences(executable, declarations, contextualKeywords)
+      ...indexReferences(
+        executable,
+        executablePairs,
+        declarations,
+        contextualKeywords,
+        contextualKeywordRanges,
+        objectInitializers
+      )
     );
     calls.push(...regionCalls);
     switches.push(...regionSwitches);
     validateTerminatedStatements(executable, diagnostics);
   }
-  return { units, locals, references, calls, switches, diagnostics };
+  return {
+    units,
+    locals,
+    references,
+    calls,
+    switches,
+    lambdaBodies,
+    contextualKeywordRanges,
+    objectInitializers,
+    diagnostics
+  };
 }
 function indexUnits(tokens, pairs, kind, lexed) {
   if (kind !== "property") {
@@ -33694,8 +34347,9 @@ function duplicateUnitDiagnostic(label, units, diagnostics) {
     ]
   });
 }
-function indexLocals(tokens, pairs, lexed, diagnostics) {
+function indexLocals(tokens, pairs, lexed, diagnostics, lambdaBodies) {
   const locals = [];
+  const braceScope = braceScopeIndex(tokens, lexed.end);
   for (let index = 0; index < tokens.length; index++) {
     const caught = tryParseCatchParameter(tokens, index, pairs, lexed);
     if (caught) {
@@ -33703,7 +34357,14 @@ function indexLocals(tokens, pairs, lexed, diagnostics) {
       index = caught.resumeTokenIndex;
       continue;
     }
-    const loop = tryParseLoopLocal(tokens, index, pairs, lexed, diagnostics);
+    const loop = tryParseLoopLocal(
+      tokens,
+      index,
+      pairs,
+      lexed,
+      diagnostics,
+      braceScope
+    );
     if (loop) {
       locals.push(...loop.locals);
       index = loop.resumeTokenIndex;
@@ -33712,10 +34373,16 @@ function indexLocals(tokens, pairs, lexed, diagnostics) {
     const lambda = tryParseLambdaParameters(tokens, index, pairs, lexed);
     if (lambda) {
       locals.push(...lambda.locals);
+      lambdaBodies.push(lambda.body);
       index = lambda.endTokenIndex;
       continue;
     }
-    const declaration = tryParseVariableDeclaration(tokens, index, lexed);
+    const declaration = tryParseVariableDeclaration(
+      tokens,
+      index,
+      lexed,
+      braceScope
+    );
     if (!declaration) continue;
     locals.push(declaration.local);
     if (declaration.missingInitializer) {
@@ -33731,36 +34398,14 @@ function indexLocals(tokens, pairs, lexed, diagnostics) {
   }
   return locals;
 }
-function tryParseVariableDeclaration(tokens, start, lexed) {
+function tryParseVariableDeclaration(tokens, start, lexed, braceScope) {
   const first = tokens[start];
   if (!first || first.kind !== "type" && first.kind !== "identifier")
     return null;
   const inferred = first.kind === "identifier" && first.text === NEOSCRIPT_INFERRED_LOCAL_KEYWORD;
-  let cursor = start + 1;
-  if (!inferred && (first.text === "Dictionary" || first.text === "Set")) {
-    const open = tokens[cursor];
-    if (!open || open.kind !== "operator" || open.text !== "<") return null;
-    let angleDepth = 0;
-    while (cursor < tokens.length) {
-      const token = tokens[cursor];
-      if (!token) return null;
-      if (token.kind === "operator" && token.text === "<") angleDepth++;
-      if (token.kind === "operator" && token.text === ">") {
-        angleDepth--;
-        if (angleDepth === 0) {
-          cursor++;
-          break;
-        }
-      }
-      cursor++;
-    }
-  }
-  while (!inferred && tokens[cursor]?.kind === "punctuation" && tokens[cursor]?.text === "[" && tokens[cursor + 1]?.kind === "punctuation" && tokens[cursor + 1]?.text === "]") {
-    cursor += 2;
-  }
-  if (!inferred && tokens[cursor]?.kind === "operator" && tokens[cursor]?.text === "?") {
-    cursor++;
-  }
+  if (!inferred && !mayStartTypedLocal(tokens, start)) return null;
+  const cursor = inferred ? start + 1 : new Parser(tokens, start).typeEnd();
+  if (cursor < 0) return null;
   const name = tokens[cursor];
   const equals = tokens[cursor + 1];
   if (!name || name.kind !== "identifier") return null;
@@ -33772,7 +34417,7 @@ function tryParseVariableDeclaration(tokens, start, lexed) {
   const statementEnd = statementEndTokenIndex(tokens, cursor + 2);
   const initializerTokens = hasEquals ? tokens.slice(cursor + 2, statementEnd) : [];
   const terminator = tokens[statementEnd];
-  const scope = containingBraceRange(tokens, start, lexed.end);
+  const scope = braceScope(start);
   return {
     local: {
       name: name.text,
@@ -33790,6 +34435,24 @@ function tryParseVariableDeclaration(tokens, start, lexed) {
     missingInitializer: inferred && (!hasEquals || initializerTokens.length === 0)
   };
 }
+var STATEMENT_BOUNDARY_TOKENS = /* @__PURE__ */ new Set([
+  ";",
+  "{",
+  "}",
+  ")",
+  ":"
+]);
+function mayStartTypedLocal(tokens, start) {
+  const previous = tokens[start - 1];
+  if (previous && !STATEMENT_BOUNDARY_TOKENS.has(previous.text) && previous.text !== "else" && !(previous.text === "(" && tokens[start - 2]?.text === "for")) {
+    return false;
+  }
+  const next = tokens[start + 1];
+  if (!next) return false;
+  if (next.kind === "identifier") return true;
+  if (next.kind === "operator") return next.text === "<" || next.text === "?";
+  return next.kind === "punctuation" && next.text === "[";
+}
 function statementEndTokenIndex(tokens, start) {
   let depth = 0;
   for (let cursor = start; cursor < tokens.length; cursor++) {
@@ -33816,6 +34479,7 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
     if (!arrow2 || arrow2.kind !== "operator" || arrow2.text !== "=>") {
       return null;
     }
+    const body2 = lambdaBodySpan(tokens, start + 1, pairs, lexed);
     return {
       locals: [
         {
@@ -33824,17 +34488,13 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
           typeTokens: [],
           inferred: false,
           declarationRange: open.range,
-          scopeStart: arrow2.end,
-          scopeEnd: lambdaExpressionScopeEnd(
-            tokens,
-            start + 2,
-            pairs,
-            lexed.end
-          ),
+          scopeStart: body2.start,
+          scopeEnd: body2.end,
           lambdaParameter: true,
           lambdaParameterIndex: 0
         }
       ],
+      body: body2,
       endTokenIndex: start + 1
     };
   }
@@ -33842,12 +34502,8 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
   const closeIndex = pairs.get(start);
   if (closeIndex === void 0) return null;
   const arrow = tokens[closeIndex + 1];
-  const bodyOpen = tokens[closeIndex + 2];
   if (!arrow || arrow.kind !== "operator" || arrow.text !== "=>") return null;
-  const hasBlockBody = bodyOpen?.kind === "punctuation" && bodyOpen.text === "{";
-  const bodyCloseIndex = hasBlockBody ? pairs.get(closeIndex + 2) : void 0;
-  const bodyClose = bodyCloseIndex === void 0 ? void 0 : tokens[bodyCloseIndex];
-  const scopeEnd = hasBlockBody ? bodyClose?.start ?? lexed.end : lambdaExpressionScopeEnd(tokens, closeIndex + 2, pairs, lexed.end);
+  const body = lambdaBodySpan(tokens, closeIndex + 1, pairs, lexed);
   const locals = [];
   let segmentStart = start + 1;
   for (let cursor = start + 1; cursor <= closeIndex; cursor++) {
@@ -33868,15 +34524,28 @@ function tryParseLambdaParameters(tokens, start, pairs, lexed) {
           segment[0]?.start ?? nameToken.start,
           nameToken.end
         ),
-        scopeStart: hasBlockBody && bodyOpen ? bodyOpen.end : bodyOpen?.start ?? arrow.end,
-        scopeEnd,
+        scopeStart: body.start,
+        scopeEnd: body.end,
         lambdaParameter: true,
         lambdaParameterIndex: locals.length
       });
     }
     segmentStart = cursor + 1;
   }
-  return { locals, endTokenIndex: closeIndex };
+  return { locals, body, endTokenIndex: closeIndex };
+}
+function lambdaBodySpan(tokens, arrowIndex, pairs, lexed) {
+  const arrow = tokens[arrowIndex];
+  const bodyOpen = tokens[arrowIndex + 1];
+  if (bodyOpen?.kind === "punctuation" && bodyOpen.text === "{") {
+    const closeIndex = pairs.get(arrowIndex + 1);
+    const close = closeIndex === void 0 ? void 0 : tokens[closeIndex];
+    return { start: bodyOpen.end, end: close?.start ?? lexed.end };
+  }
+  return {
+    start: arrow?.end ?? lexed.end,
+    end: lambdaExpressionScopeEnd(tokens, arrowIndex + 1, pairs, lexed.end)
+  };
 }
 function lambdaExpressionScopeEnd(tokens, bodyStart, pairs, sourceEnd) {
   for (let cursor = bodyStart; cursor < tokens.length; cursor++) {
@@ -33893,6 +34562,9 @@ function lambdaExpressionScopeEnd(tokens, bodyStart, pairs, sourceEnd) {
   }
   return sourceEnd;
 }
+function isCallTypeArgumentToken(token) {
+  return token.kind === "identifier" || token.kind === "type" || [".", ",", "?", "[", "]"].includes(token.text);
+}
 function callOpenParenIndex(tokens, nameIndex) {
   if (tokens[nameIndex + 1]?.text === "(") return nameIndex + 1;
   if (tokens[nameIndex + 1]?.text !== "<") return -1;
@@ -33901,8 +34573,7 @@ function callOpenParenIndex(tokens, nameIndex) {
     const token = tokens[cursor];
     if (token.text === "<") depth++;
     else if (/^>+$/.test(token.text)) depth -= token.text.length;
-    else if (token.kind !== "identifier" && token.kind !== "type" && ![".", ",", "?", "[", "]"].includes(token.text))
-      return -1;
+    else if (!isCallTypeArgumentToken(token)) return -1;
     if (depth === 0) return tokens[cursor + 1]?.text === "(" ? cursor + 1 : -1;
     if (depth < 0) return -1;
   }
@@ -33924,15 +34595,84 @@ function callTypeArgumentTokens(tokens, nameIndex, openIndex) {
   }
   return argumentsTokens;
 }
-function indexReferences(tokens, declarations, contextualKeywords) {
+function enclosingOpenerIndex(tokens) {
+  const enclosing = new Int32Array(tokens.length);
+  const openers = [];
+  for (let index = 0; index < tokens.length; index++) {
+    enclosing[index] = openers.length ? openers[openers.length - 1] : -1;
+    const token = tokens[index];
+    if (token.kind !== "punctuation") continue;
+    if (token.text === "(" || token.text === "[" || token.text === "{") {
+      openers.push(index);
+    } else if (token.text === ")" || token.text === "]" || token.text === "}") {
+      openers.pop();
+    }
+  }
+  return enclosing;
+}
+function isContextualNew(token, previous, next) {
+  return token.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD && previous?.text !== "." && previous?.text !== "?." && (next?.kind === "identifier" || next?.kind === "type" || next?.text === "(" || next?.text === "{");
+}
+function objectInitializerBraceIndex(tokens, newIndex, pairs) {
+  let cursor = newIndex + 1;
+  const opener = tokens[cursor]?.text;
+  if (opener !== "(" && opener !== "{") {
+    const typeEnd = new Parser(tokens, cursor).typeEnd();
+    if (typeEnd >= 0) cursor = typeEnd;
+  }
+  if (tokens[cursor]?.text === "(") {
+    const close = pairs.get(cursor);
+    if (close === void 0) return -1;
+    cursor = close + 1;
+  }
+  return tokens[cursor]?.text === "{" ? cursor : -1;
+}
+function indexReferences(tokens, pairs, declarations, contextualKeywords, negations, initializers) {
   const references = [];
+  const enclosing = enclosingOpenerIndex(tokens);
+  const initializerBraces = /* @__PURE__ */ new Set();
+  const patternBindings = /* @__PURE__ */ new Set();
   for (let index = 0; index < tokens.length; index++) {
     const token = tokens[index];
-    if (!token || token.kind !== "identifier" && token.text !== "base")
+    if (!token) continue;
+    if (token.kind === "keyword" && token.text === "is") {
+      const not = tokens[index + 1];
+      let typeStart = index + 1;
+      if (not?.text === "not") {
+        negations.push(not.range);
+        typeStart = index + 2;
+        index++;
+      }
+      const end = new Parser(tokens, typeStart).typeEnd({
+        conditionalQuestion: true
+      });
+      if (end >= 0 && tokens[end]?.kind === "identifier") {
+        patternBindings.add(end);
+      }
       continue;
+    }
+    if (token.kind !== "identifier" && token.text !== "base") continue;
+    const previous = tokens[index - 1];
+    const next = tokens[index + 1];
+    if (isContextualNew(token, previous, next)) {
+      const brace = objectInitializerBraceIndex(tokens, index, pairs);
+      if (brace >= 0) {
+        initializerBraces.add(brace);
+        initializers.push({
+          constructorStart: token.start,
+          braceStart: tokens[brace].start
+        });
+      }
+      continue;
+    }
+    const opener = enclosing[index];
+    if (opener >= 0 && (previous?.text === "," || index - 1 === opener)) {
+      const label = next?.text === ":" && tokens[opener]?.text === "(";
+      const key = next?.kind === "operator" && next.text === "=" && initializerBraces.has(opener);
+      if (label || key) continue;
+    }
     const declarationKey = `${token.range.start.line}:${token.range.start.character}`;
     if (contextualKeywords.has(declarationKey)) continue;
-    const previous = tokens[index - 1];
     references.push({
       name: token.text,
       range: token.range,
@@ -33940,7 +34680,7 @@ function indexReferences(tokens, declarations, contextualKeywords) {
       end: token.end,
       member: previous?.kind === "punctuation" && previous.text === "." || previous?.kind === "operator" && previous.text === "?.",
       call: callOpenParenIndex(tokens, index) >= 0,
-      declaration: declarations.has(declarationKey)
+      declaration: declarations.has(declarationKey) || patternBindings.has(index)
     });
   }
   return references;
@@ -33953,12 +34693,18 @@ function indexCalls(tokens, pairs, lexed) {
     const open = tokens[openIndex];
     if (!name || name.kind !== "identifier") continue;
     if (!open || open.kind !== "punctuation" || open.text !== "(") continue;
-    const contextualKeyword = tokens[index - 1];
-    const constructor = contextualKeyword?.kind === "identifier" && contextualKeyword.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD;
+    const previous = tokens[index - 1];
+    const targetTyped = isContextualNew(name, previous, open);
+    let contextualKeyword;
+    if (targetTyped) contextualKeyword = name;
+    else if (previous?.kind === "identifier" && previous.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD)
+      contextualKeyword = previous;
     const closeIndex = pairs.get(openIndex);
     const close = closeIndex === void 0 ? void 0 : tokens[closeIndex];
     const ranges = [];
+    const names = [];
     let segmentStart = open.end;
+    let segmentStartIndex = openIndex + 1;
     let nested = 0;
     const limit = closeIndex ?? tokens.length;
     for (let cursor = openIndex + 1; cursor < limit; cursor++) {
@@ -33970,17 +34716,21 @@ function indexCalls(tokens, pairs, lexed) {
         nested--;
       if (nested === 0 && token.kind === "punctuation" && token.text === ",") {
         ranges.push(lexed.source.range(segmentStart, token.start));
+        names.push(callArgumentLabel(tokens, segmentStartIndex, cursor));
         segmentStart = token.end;
+        segmentStartIndex = cursor + 1;
       }
     }
     if (segmentStart < (close?.start ?? lexed.end)) {
       ranges.push(lexed.source.range(segmentStart, close?.start ?? lexed.end));
+      names.push(callArgumentLabel(tokens, segmentStartIndex, limit));
     }
     calls.push({
-      kind: constructor ? "constructor" : "function",
+      kind: contextualKeyword ? "constructor" : "function",
       name: name.text,
       nameRange: name.range,
-      ...constructor ? { contextualKeywordRange: contextualKeyword.range } : {},
+      ...contextualKeyword ? { contextualKeywordRange: contextualKeyword.range } : {},
+      ...targetTyped ? { targetTyped: true } : {},
       ...openIndex > index + 1 ? {
         typeArgumentTokens: callTypeArgumentTokens(
           tokens,
@@ -33990,11 +34740,17 @@ function indexCalls(tokens, pairs, lexed) {
       } : {},
       openParenOffset: open.start,
       ...close ? { closeParenOffset: close.end } : {},
-      argumentRanges: ranges
+      argumentRanges: ranges,
+      argumentNames: names
     });
   }
   return calls;
 }
+function callArgumentLabel(tokens, start, end) {
+  const name = tokens[start];
+  const colon = tokens[start + 1];
+  return start + 1 < end && name !== void 0 && isCallArgumentLabelToken(name) && colon?.kind === "punctuation" && colon.text === ":" ? name.text : null;
+}
 function validateTerminatedStatements(tokens, diagnostics) {
   for (let index = 0; index < tokens.length; index++) {
     const token = tokens[index];
@@ -34039,36 +34795,44 @@ function validateTerminatedStatements(tokens, diagnostics) {
     }
   }
 }
-function containingBraceRange(tokens, tokenIndex, documentEnd) {
-  let depth = 0;
-  let start = 0;
-  for (let index = tokenIndex - 1; index >= 0; index--) {
+function braceScopeIndex(tokens, documentEnd) {
+  const openBefore = new Int32Array(tokens.length);
+  const closeOf = /* @__PURE__ */ new Map();
+  const unmatchedCloses = [];
+  const stack = [];
+  for (let index = 0; index < tokens.length; index++) {
+    openBefore[index] = stack.at(-1) ?? -1;
     const token = tokens[index];
-    if (!token || token.kind !== "punctuation") continue;
-    if (token.text === "}") depth++;
-    if (token.text === "{") {
-      if (depth === 0) {
-        start = token.end;
-        break;
-      }
-      depth--;
+    if (token.kind !== "punctuation") continue;
+    if (token.text === "{") stack.push(index);
+    else if (token.text === "}") {
+      const open = stack.pop();
+      if (open === void 0) unmatchedCloses.push(index);
+      else closeOf.set(open, index);
+    }
+  }
+  return (tokenIndex) => {
+    const open = openBefore[tokenIndex] ?? -1;
+    if (open >= 0) {
+      const close2 = closeOf.get(open);
+      return {
+        start: tokens[open].end,
+        end: close2 === void 0 ? documentEnd : tokens[close2].start
+      };
     }
-  }
-  depth = 0;
-  let end = documentEnd;
-  for (let index = tokenIndex + 1; index < tokens.length; index++) {
-    const token = tokens[index];
-    if (!token || token.kind !== "punctuation") continue;
-    if (token.text === "{") depth++;
-    if (token.text === "}") {
-      if (depth === 0) {
-        end = token.start;
-        break;
-      }
-      depth--;
+    let low = 0;
+    let high = unmatchedCloses.length;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (unmatchedCloses[mid] > tokenIndex) high = mid;
+      else low = mid + 1;
     }
-  }
-  return { start, end };
+    const close = unmatchedCloses[low];
+    return {
+      start: 0,
+      end: close === void 0 ? documentEnd : tokens[close].start
+    };
+  };
 }
 function tryParseCatchParameter(tokens, start, pairs, lexed) {
   const keyword = tokens[start];
@@ -34116,7 +34880,7 @@ function tryParseCatchParameter(tokens, start, pairs, lexed) {
     resumeTokenIndex: closeIndex
   };
 }
-function tryParseLoopLocal(tokens, start, pairs, lexed, diagnostics) {
+function tryParseLoopLocal(tokens, start, pairs, lexed, diagnostics, braceScope) {
   const keyword = tokens[start];
   if (!keyword || keyword.kind !== "keyword" || keyword.text !== "for" && keyword.text !== "foreach") {
     return null;
@@ -34127,7 +34891,12 @@ function tryParseLoopLocal(tokens, start, pairs, lexed, diagnostics) {
   if (closeIndex === void 0) return null;
   const scopeEnd = loopBodyScopeEnd(tokens, closeIndex + 1, pairs, lexed.end);
   if (keyword.text === "for") {
-    const declaration = tryParseVariableDeclaration(tokens, start + 2, lexed);
+    const declaration = tryParseVariableDeclaration(
+      tokens,
+      start + 2,
+      lexed,
+      braceScope
+    );
     if (!declaration || declaration.endTokenIndex >= closeIndex) return null;
     if (declaration.missingInitializer) {
       diagnostics.push({
@@ -34449,6 +35218,23 @@ var COLLECTION_QUERY_METHODS = {
   Reverse: "none",
   Concat: "collection"
 };
+var COLLECTION_FUNCTION_ARGUMENTS = {
+  Where: "predicate",
+  First: "optionalPredicate",
+  FirstOrDefault: "optionalPredicate",
+  Select: "selector",
+  Count: "optionalPredicate",
+  ...COLLECTION_QUERY_METHODS
+};
+function isCollectionFunctionName(name) {
+  return Object.hasOwn(COLLECTION_FUNCTION_ARGUMENTS, name);
+}
+var COLLECTION_FUNCTION_ALIASES = { Find: "FirstOrDefault" };
+function collectionFunctionContract(name) {
+  if (Object.hasOwn(COLLECTION_FUNCTION_ALIASES, name))
+    return COLLECTION_FUNCTION_ALIASES[name];
+  return isCollectionFunctionName(name) ? name : null;
+}
 function isCollectionQueryName(name) {
   return Object.hasOwn(COLLECTION_QUERY_METHODS, name);
 }
@@ -36339,10 +37125,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         statement.pos
       );
     }
-    if (statement.target.kind === "member" && statement.target.name === "OnChanged") {
+    if (statement.target.kind === "member" && statement.target.name === NEOSCRIPT_ON_CHANGED_MEMBER) {
       const observed = this.resolveExpression(statement.target.receiver, scope);
       const observedType = neoScriptMemberLookupType(observed.type);
-      const declared = observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some((member) => member.name === "OnChanged");
+      const declared = observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some(
+        (member) => member.name === NEOSCRIPT_ON_CHANGED_MEMBER
+      );
       if (!declared) {
         if (statement.op !== "+=" && statement.op !== "-=")
           throw new CompileError(ON_CHANGED_OPERATIONS_ERROR, statement.pos);
@@ -36561,12 +37349,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   }
   /** `X.M.OnChanged.Clear()` empties M's listener set on X (P70, P106). */
   resolveChangeListenerClear(expression, scope, pos) {
-    if (expression.kind !== "call" || expression.callee.kind !== "member" || expression.callee.name !== "Clear" || expression.callee.receiver.kind !== "member" || expression.callee.receiver.name !== "OnChanged")
+    if (expression.kind !== "call" || expression.callee.kind !== "member" || expression.callee.name !== "Clear" || expression.callee.receiver.kind !== "member" || expression.callee.receiver.name !== NEOSCRIPT_ON_CHANGED_MEMBER)
       return null;
     const onChanged = expression.callee.receiver;
     const observed = this.resolveExpression(onChanged.receiver, scope);
     const observedType = neoScriptMemberLookupType(observed.type);
-    if (observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some((member) => member.name === "OnChanged"))
+    if (observedType.kind === "named" && this.project.typeById.get(observedType.typeId)?.members.some((member) => member.name === NEOSCRIPT_ON_CHANGED_MEMBER))
       return null;
     if (expression.callee.optional)
       throw new CompileError(
@@ -37292,7 +38080,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         );
       }
       case "new": {
-        const vector3 = this.targetTypedVectorKind(expression, expected);
+        const constructed = expression.className ?? (expected?.kind === "primitive" ? expected.name : null);
+        if (constructed === "Color") {
+          throw new CompileError(
+            "Color has no NeoScript constructor; write its components as numeric literals.",
+            expression.pos
+          );
+        }
+        const vector3 = this.constructedVectorKind(expression, constructed);
         if (vector3 !== null) {
           return this.resolveVectorConstructor(
             vector3,
@@ -37802,10 +38597,19 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     };
   }
   resolveListLiteral(elements, scope, expected, pos) {
-    const expectedEntry = expected?.kind === "list" ? expected.elementType : void 0;
+    const expectedEntry = expected?.kind === "list" || expected?.kind === "set" ? expected.elementType : void 0;
     const resolved = elements.map(
       (element) => this.resolveExpression(element, scope, expectedEntry)
     );
+    if (expectedEntry !== void 0 && this.context.kind === "initializer") {
+      resolved.forEach((item, index) => {
+        if (isNeoScriptTypeAssignable(item.type, expectedEntry, this.project)) return;
+        throw new CompileError(
+          `Expected ${this.describe(expectedEntry)} but received ${this.describe(item.type)}.`,
+          elements[index].pos
+        );
+      });
+    }
     let entryType = expectedEntry ?? resolved[0]?.type;
     if (!entryType) {
       throw new CompileError(
@@ -37827,6 +38631,14 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       }
       entryType = common;
     }
+    if (expected?.kind === "set" && this.context.kind === "initializer") {
+      const element = expected.elementType;
+      const spelling = element.kind === "named" && this.project.typeById.get(element.typeId)?.kind === "enum" ? `.Option or ${this.describe({ ...element, nullable: false })}.Option values` : "literal values";
+      throw new CompileError(
+        `${this.describe(expected)} has no NeoScript literal; write its elements as ${spelling}.`,
+        pos
+      );
+    }
     const type = {
       kind: "list",
       elementType: entryType
@@ -38763,7 +39575,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
           pos
         );
       }
-      if (name === "Id" && type.kind === "class") {
+      if (name === NEOSCRIPT_CLASS_ID_MEMBER && type.kind === "class") {
         return this.keyOf(
           receiver,
           name,
@@ -38852,7 +39664,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         entryUserData
       };
     }
-    if (name === "OnChanged")
+    if (name === NEOSCRIPT_ON_CHANGED_MEMBER)
       throw new CompileError(ON_CHANGED_OPERATIONS_ERROR, pos);
     throw new CompileError(
       `Cannot read member '${name}' on ${this.describe(receiver.type)}`,
@@ -39925,7 +40737,10 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       const resolved = this.resolveIdentifier(callee.name, scope, callee.pos);
       return resolved.type.kind === "delegate" || resolved.type.kind === "action" ? resolved : null;
     }
-    if (callee.kind !== "member") return null;
+    if (callee.kind !== "member") {
+      const resolved = this.resolveExpression(callee, scope);
+      return resolved.type.kind === "delegate" ? resolved : null;
+    }
     try {
       const resolved = this.resolveMember(
         callee.receiver,
@@ -40349,23 +41164,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
         this.project.typeByName.get(className) ?? { declaredConstructors: [] }
       );
     }
-    const inferredTypes = this.inferOverloadArgumentTypes(
+    const resolution = this.declaredConstructorResolution(
       declared,
       named,
-      expression,
+      expression.args,
       scope
     );
-    const resolution = resolveNeoScriptDeclaredConstructorOverload(
-      declared,
-      named.map((name, index) => {
-        const inferred = inferredTypes?.[index];
-        if (!inferred) return { name };
-        return {
-          name,
-          matchesParameter: (parameter3) => isNeoScriptTypeAssignable(inferred, parameter3.type, this.project)
-        };
-      })
-    );
     if (resolution.kind === "resolved") return resolution.constructor;
     if (resolution.kind === "ambiguous") {
       throw new CompileError(
@@ -40378,6 +41182,38 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       pos
     );
   }
+  /**
+   * #1310. The overload a named `new` call in an initializer expression
+   * compiles against, for editor features that hold its argument expressions.
+   */
+  initializerConstructorOverload(declared, named, args) {
+    const resolution = this.declaredConstructorResolution(
+      declared,
+      named,
+      args,
+      this.initialScope()
+    );
+    return resolution.kind === "resolved" ? resolution.constructor : null;
+  }
+  declaredConstructorResolution(declared, named, args, scope) {
+    const inferredTypes = this.inferOverloadArgumentTypes(
+      declared,
+      named,
+      args,
+      scope
+    );
+    return resolveNeoScriptDeclaredConstructorOverload(
+      declared,
+      named.map((name, index) => {
+        const inferred = inferredTypes?.[index];
+        if (!inferred) return { name };
+        return {
+          name,
+          matchesParameter: (parameter3) => isNeoScriptTypeAssignable(inferred, parameter3.type, this.project)
+        };
+      })
+    );
+  }
   /**
    * Types for the §6.1.1 step-2 tie-break, computed only when several
    * overloads share the call's name set. Expected-type inference is
@@ -40385,7 +41221,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
    * known — so an argument that needs it (a contextual enum option, a
    * target-typed `new`) simply does not participate in the tie-break.
    */
-  inferOverloadArgumentTypes(declared, named, expression, scope) {
+  inferOverloadArgumentTypes(declared, named, args, scope) {
     const nameSetKey = neoScriptArgumentNameSetKey(named);
     const sharing = declared.filter(
       (candidate) => neoScriptArgumentNameSetKey(
@@ -40394,7 +41230,7 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     );
     if (sharing.length < 2) return null;
     return named.map((_, index) => {
-      const argument2 = expression.args[index];
+      const argument2 = args[index];
       if (!argument2) return null;
       try {
         return this.resolveExpression(argument2, scope).type;
@@ -41078,6 +41914,15 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   resolveCollectionFunction(receiver, name, args, scope, pos) {
     const collection = collectionPartsFor(receiver);
     if (!collection) return null;
+    const contract = collectionFunctionContract(name);
+    if (contract !== null) {
+      requireCollectionArguments(
+        name,
+        COLLECTION_FUNCTION_ARGUMENTS[contract],
+        args,
+        pos
+      );
+    }
     if (isCollectionQueryName(name)) {
       return this.resolveCollectionQuery(
         receiver,
@@ -41089,12 +41934,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     if (name === "Count") {
-      if (args.length > 1) {
-        throw new CompileError(
-          `Count expects zero or one predicate, got ${args.length}.`,
-          pos
-        );
-      }
       const fn = args[0] ? this.resolveCollectionLambda(
         args[0],
         collection,
@@ -41170,7 +42009,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       );
     }
     if (name === "Where") {
-      requireArgCount(name, args, 1, pos);
       const fn = this.resolveCollectionLambda(
         requiredAt(args, 0),
         collection,
@@ -41193,12 +42031,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       };
     }
     if (name === "First" || name === "FirstOrDefault" || name === "Find") {
-      if (args.length > 1) {
-        throw new CompileError(
-          `${name} expects zero or one predicate, got ${args.length}.`,
-          pos
-        );
-      }
       const fn = args[0] ? this.resolveCollectionLambda(
         args[0],
         collection,
@@ -41223,7 +42055,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
       };
     }
     if (name === "Select") {
-      requireArgCount(name, args, 1, pos);
       const lambda = requiredAt(args, 0);
       if (lambda.kind !== "lambda") {
         throw new CompileError("Select requires a lambda argument.", pos);
@@ -41250,16 +42081,6 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     return null;
   }
   resolveCollectionQuery(receiver, collection, name, args, scope, pos) {
-    const kind = COLLECTION_QUERY_METHODS[name];
-    if (kind === "optionalPredicate") {
-      if (args.length > 1)
-        throw new CompileError(
-          `${name} expects zero or one predicate, got ${args.length}.`,
-          pos
-        );
-    } else {
-      requireArgCount(name, args, kind === "none" ? 0 : 1, pos);
-    }
     const base = { collectionPointer: receiver.pointer };
     let info;
     let resultType = {
@@ -41425,6 +42246,8 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     };
   }
   resolveScalarFunction(receiver, name, args, scope, pos) {
+    if (receiver.type.kind !== "primitive" || !neoScriptScalarMethod(receiver.type.name, name))
+      return null;
     if (isPrimitive(receiver.type, "string")) {
       if (name === "Contains") {
         requireArgCount("string.Contains", args, 1, pos);
@@ -42576,27 +43399,26 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
     };
   }
   /**
-   * The vector leaf a target-typed `new(…)` constructs, or null when the
-   * expression is not one.
+   * The vector leaf a target-typed `new(…)` or a named `new Vector2(…)`
+   * constructs, or null when the expression is not one.
    *
    * A vector has fields rather than members, so neither of `new`'s two
    * declaration-side spellings applies to it: an argument names a component by
    * position and there is no member for an initializer block to settle.
    */
-  targetTypedVectorKind(expression, expected) {
-    if (expression.className !== null) return null;
-    if (expected?.kind !== "primitive") return null;
-    const vector3 = vectorKind(expected.name);
+  constructedVectorKind(expression, constructed) {
+    const vector3 = constructed === null ? null : vectorKind(constructed);
     if (vector3 === null) return null;
+    const spelling = expression.className === null ? "new(\u2026)" : `new ${vector3}(\u2026)`;
     if (expression.argumentNames !== void 0) {
       throw new CompileError(
-        `${vector3} components are positional, so \`new(\u2026)\` cannot name them.`,
+        `${vector3} components are positional, so \`${spelling}\` cannot name them.`,
         expression.pos
       );
     }
     if ((expression.initializer?.length ?? 0) > 0) {
       throw new CompileError(
-        `${vector3} has fields rather than members, so \`new(\u2026)\` cannot carry an initializer block. Pass every component instead.`,
+        `${vector3} has fields rather than members, so \`${spelling}\` cannot carry an initializer block. Pass every component instead.`,
         expression.pos
       );
     }
@@ -42767,6 +43589,12 @@ var StrictNeoScriptResolver = class _StrictNeoScriptResolver {
   }
   requireAssignable(source, target, pos, usage) {
     if (isNeoScriptTypeAssignable(source, target, this.project)) return;
+    if (usage === "return" && this.context.kind === "initializer" && this.lambdaDepth === 0) {
+      throw new CompileError(
+        `Expected ${this.describe(target)} but received ${this.describe(source)}.`,
+        pos
+      );
+    }
     const prefix = usage === "return" ? "Returned" : "Cannot use";
     throw new CompileError(
       `${prefix} ${this.describe(source)} ${usage === "return" ? "is not assignable to declared return type" : `as ${usage} of type`} ${this.describe(target)}`,
@@ -44041,17 +44869,6 @@ function collectionOperationValueType(expression, collection) {
 function isLookupSelectionCollection(expression, collection) {
   return collection.kind === "set" && expression.wireType?.type === 9 /* Lookup */;
 }
-var SPRITE_DERIVED_MEMBERS = {
-  FileName: { kind: "primitive", name: "string" },
-  Name: { kind: "primitive", name: "string" },
-  Size: { kind: "primitive", name: "Vector2" },
-  Pivot: { kind: "primitive", name: "Vector2" },
-  Slices: {
-    kind: "list",
-    elementType: { kind: "primitive", name: "SpriteInfo" },
-    readOnly: true
-  }
-};
 function assignableFieldList(owner) {
   if (!isNeoScriptStructuredLeafTypeName(owner)) return "a stored field";
   const names = neoScriptStructuredLeafFieldNames(owner);
@@ -44065,19 +44882,8 @@ function resolvePrimitiveMember(type, name) {
     );
     if (field) return { type: field.type, key: field.key };
   }
-  if (type.name === "SpriteInfo" && Object.prototype.hasOwnProperty.call(SPRITE_DERIVED_MEMBERS, name)) {
-    const derived = SPRITE_DERIVED_MEMBERS[name];
-    if (derived) return { type: derived, derived: true };
-  }
-  if (type.name === "AudioClipInfo") {
-    if (name === "url" || name === "name")
-      return { type: { kind: "primitive", name: "string" } };
-    if (name === "length")
-      return { type: { kind: "primitive", name: "float" } };
-  }
-  if (type.name === "NeoDialogueReference" && name === "id")
-    return { type: { kind: "primitive", name: "string" } };
-  return null;
+  const derived = neoScriptPrimitiveDerivedMember(type.name, name);
+  return derived ? { type: derived.type, derived: true } : null;
 }
 function isActionMemberPointer(pointer) {
   if (pointer.type === "staticMember" /* StaticMember */) return true;
@@ -44326,6 +45132,17 @@ function functionArityMessage(name, minimum, maximum, got) {
   }
   return `Function '${name}' expects between ${minimum} and ${maximum} arguments, got ${got}.`;
 }
+function requireCollectionArguments(name, shape, args, pos) {
+  if (shape !== "optionalPredicate") {
+    requireArgCount(name, args, shape === "none" ? 0 : 1, pos);
+    return;
+  }
+  if (args.length <= 1) return;
+  throw new CompileError(
+    `${name} expects zero or one predicate, got ${args.length}.`,
+    pos
+  );
+}
 function requireArgCount(name, args, expected, pos) {
   if (args.length === expected) return;
   throw new CompileError(
@@ -44407,6 +45224,18 @@ function resolveNeoScriptType(type, context, project) {
         resolved = registryReference;
         break;
       }
+      if (type.name === "NeoDelegate") {
+        const [returnType, ...parameterTypes] = (type.typeArguments ?? []).map(
+          (argument2) => resolveNeoScriptType(argument2, context, project)
+        );
+        if (!returnType)
+          throw new CompileError(
+            "NeoDelegate requires a return type argument, for example NeoDelegate<int>.",
+            type.pos
+          );
+        resolved = { kind: "delegate", returnType, parameterTypes };
+        break;
+      }
       const named = project.typeByName.get(type.name);
       if (!named)
         throw new CompileError(
@@ -46031,7 +46860,7 @@ function manifestParameterDefault(argument2, environment, field) {
   const value = constantDefaultValue(declared.value, `${field}.default.value`);
   const type = record2(argument2.type, `${field}.type`);
   const kind = string(type.kind, `${field}.type.kind`);
-  const enumOptionName = kind === "enum" && typeof value === "string" ? manifestEnumOptionName(
+  const enumOptionName2 = kind === "enum" && typeof value === "string" ? manifestEnumOptionName(
     string(type.enumId, `${field}.type.enumId`),
     value,
     environment
@@ -46041,7 +46870,7 @@ function manifestParameterDefault(argument2, environment, field) {
       displayText: neoScriptParameterDefaultDisplayText({
         value,
         kind: kind === "enum" || kind === "decimal" ? kind : "other",
-        ...enumOptionName === void 0 ? {} : { enumOptionName }
+        ...enumOptionName2 === void 0 ? {} : { enumOptionName: enumOptionName2 }
       }),
       value
     }
@@ -46906,13 +47735,13 @@ function overrideBaseClass(context) {
 function parameterDefaultDescriptor(argument2, context) {
   if (argument2.defaultValue === void 0) return {};
   const value = argument2.defaultValue.value;
-  const enumOptionName = argument2.type === 8 /* Enum */ && typeof value === "string" ? analyzerEnumOptionName(argument2.enumId, value, context) : void 0;
+  const enumOptionName2 = argument2.type === 8 /* Enum */ && typeof value === "string" ? analyzerEnumOptionName(argument2.enumId, value, context) : void 0;
   return {
     defaultValue: {
       displayText: neoScriptParameterDefaultDisplayText({
         value,
         kind: parameterDefaultSpellingKind(argument2.type),
-        ...enumOptionName === void 0 ? {} : { enumOptionName }
+        ...enumOptionName2 === void 0 ? {} : { enumOptionName: enumOptionName2 }
       }),
       value
     }
@@ -48535,8 +49364,9 @@ function createContext(ctx, options) {
 }
 
 // ../src/database/neoscript/compile-delegate-closure.ts
+var CLOSURE_GETTER_PREFIX = "return ";
 function compileDelegateClosureValue(code, signature) {
-  const compiled = compileNSGetter(`return ${code};`, {
+  const compiled = compileNSGetter(`${CLOSURE_GETTER_PREFIX}${code};`, {
     project: signature.project,
     projectFiles: [...signature.projectFiles ?? []],
     dialogueGroups: signature.dialogueGroups ?? [],
@@ -48548,13 +49378,16 @@ function compileDelegateClosureValue(code, signature) {
     variants: [...signature.variants ?? []],
     variantFolders: [...signature.variantFolders ?? []],
     thisClass: signature.thisClass,
+    implicitMemberAccess: true,
+    staticMember: signature.staticMember,
     returnTypeInfo: {
       type: 25 /* NSDelegate */,
       required: true,
       returnTypeInfo: signature.returnTypeInfo,
       argumentTypes: [...signature.argumentTypes]
     },
-    functionName: signature.name
+    functionName: signature.name,
+    compilationProject: signature.compilationProject
   });
   const instruction = compiled.instructions[0];
   if (compiled.instructions.length !== 1 || instruction?.type !== "return" /* return */ || instruction.pointer?.type !== "value" /* value */) {
@@ -48616,7 +49449,11 @@ function compileMemberInitializerBody(args) {
     );
   }
   const members = replaceMember(args.members, args.member);
-  const returnTypeInfo = resolveMemberDeclaredTypeInfo(args.member, members) ?? initializerGenericTypeInfo(args.member, args.thisClass);
+  const returnTypeInfo = resolveMemberDeclaredTypeInfo(
+    args.member,
+    members,
+    args.thisClass
+  );
   if (returnTypeInfo === null) {
     throw new Error(
       `Member "${args.member.name}" has an initializer but no resolvable declared type.`
@@ -48644,24 +49481,12 @@ function compileMemberInitializerBody(args) {
       error,
       memberId: args.member.id,
       memberName: args.member.name,
-      valueId: null
+      valueId: null,
+      code: defaultValue.init.code
     });
   }
   Object.assign(defaultValue.init, { compiled });
 }
-function initializerGenericTypeInfo(member, ownerClass) {
-  if (!isMemberGenericBase(member) || ownerClass === null) return null;
-  const declaration = ownerClass.genericParams?.find(
-    (parameter3) => parameter3.id === member.genericParamId
-  );
-  if (declaration === void 0) return null;
-  return {
-    type: 21 /* Generic */,
-    required: isRequiredMember(member),
-    ownerClassId: ownerClass.id,
-    genericParamId: declaration.id
-  };
-}
 function compileValueRowInitializerBody(args) {
   const container = args.valueRow;
   if (!isInitValueContent(container)) return;
@@ -48703,7 +49528,8 @@ function compileValueRowInitializerBody(args) {
       error,
       memberId: args.member.id,
       memberName: args.member.name,
-      valueId: args.valueId
+      valueId: args.valueId,
+      code: container.init.code
     });
   }
   Object.assign(container.init, { compiled });
@@ -48732,10 +49558,20 @@ var NeoScriptBodyCompileError = class extends Error {
   memberId;
   memberName;
   valueId;
+  /**
+   * The constructor argument the body is stored inline under, when the value
+   * row carries it as creation data rather than as its own row (#1303).
+   */
+  argument;
+  /** The exact code handed to the compiler; `bodyPosition` is measured in it. */
+  code;
   bodyPosition;
+  /** The compiler's message without its body position. */
+  detail;
   constructor(args) {
-    const subject = args.valueId === null ? `Member "${args.memberName}" (${args.memberId})` : `Value row "${args.valueId}" of member "${args.memberName}" (${args.memberId})`;
-    const at2 = args.bodyPosition === null ? "" : ` at initializer ${args.bodyPosition}`;
+    const argument2 = args.argument === void 0 ? "" : ` constructor argument "${args.argument.parameterName}"`;
+    const subject = args.valueId === null ? `Member "${args.memberName}" (${args.memberId})` : `Value row "${args.valueId}"${argument2} of member "${args.memberName}" (${args.memberId})`;
+    const at2 = args.bodyPosition === null ? "" : ` at initializer ${args.bodyPosition.line}:${args.bodyPosition.column}`;
     super(
       `${subject} has a NeoScript body that failed to compile${at2}: ${args.detail}`
     );
@@ -48743,18 +49579,24 @@ var NeoScriptBodyCompileError = class extends Error {
     this.memberId = args.memberId;
     this.memberName = args.memberName;
     this.valueId = args.valueId;
+    this.argument = args.argument ?? null;
+    this.code = args.code;
     this.bodyPosition = args.bodyPosition;
+    this.detail = args.detail;
   }
 };
 function throwNamedBodyCompileFailure(args) {
   if (args.error instanceof NeoScriptBodyCompileError) throw args.error;
   const compileError = args.error instanceof CompileError ? args.error : null;
   const detail = args.error instanceof Error ? args.error.message : String(args.error);
+  const position = compileError === null ? null : { line: compileError.line, column: compileError.column };
   throw new NeoScriptBodyCompileError({
     memberId: args.memberId,
     memberName: args.memberName,
     valueId: args.valueId,
-    bodyPosition: compileError === null ? null : `${compileError.line}:${compileError.column}`,
+    ...args.argument === void 0 ? {} : { argument: args.argument },
+    code: args.code,
+    bodyPosition: position === null ? null : args.codePosition?.(position) ?? position,
     detail: compileError === null ? detail : detail.replace(
       new RegExp(`^${compileError.line}:${compileError.column}: `),
       ""
@@ -56025,79 +56867,9 @@ var INITIALIZER_KEY_PLACEHOLDER = new RegExp(
   "g"
 );
 
-// ../packages/neoscript-language/src/project-schema-contract.generated.ts
-var PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
-
-// src/project-source/lower-configuration.ts
-var wireEnumOptions = () => (options) => options;
-var TEXTURE_TYPE_WIRE_OPTIONS = wireEnumOptions()([
-  "default",
-  "normal-map",
-  "editor-gui-and-legacy-gui",
-  "sprite",
-  "cursor",
-  "cookie",
-  "lightmap",
-  "single-channel"
-]);
-var ALPHA_SOURCE_WIRE_OPTIONS = wireEnumOptions()(["none", "input-texture-alpha", "from-gray-scale"]);
-var NON_POWER_OF_TWO_SCALE_WIRE_OPTIONS = wireEnumOptions()(["none", "to-nearest", "to-larger", "to-smaller"]);
-var MIP_MAP_FILTERING_WIRE_OPTIONS = wireEnumOptions()(["box", "kaiser"]);
-var WRAP_MODE_WIRE_OPTIONS = wireEnumOptions()(["repeat", "clamp", "mirror", "mirror-once", "per-axis"]);
-var FILTER_MODE_WIRE_OPTIONS = wireEnumOptions()(["point", "bilinear", "trilinear"]);
-var RESIZE_ALGORITHM_WIRE_OPTIONS = wireEnumOptions()(["mitchell", "bilinear"]);
-var TEXTURE_COMPRESSION_WIRE_OPTIONS = wireEnumOptions()(["none", "low-quality", "normal-quality", "high-quality"]);
-var PLATFORM_FORMAT_WIRE_OPTIONS = wireEnumOptions()([
-  "automatic",
-  "rgba-compressed-dxt5-bc3",
-  "rgb-compressed-dxt1-bc1",
-  "rgba-32-bit",
-  "rgb-24-bit"
-]);
-var SPRITE_MODE_WIRE_OPTIONS = wireEnumOptions()(["single", "multiple", "polygon"]);
-var MESH_TYPE_WIRE_OPTIONS = wireEnumOptions()(["full-rect", "tight"]);
-var PIVOT_ALIGNMENT_WIRE_OPTIONS = wireEnumOptions()([
-  "center",
-  "top-left",
-  "top-center",
-  "top-right",
-  "left-center",
-  "right-center",
-  "bottom-left",
-  "bottom-center",
-  "bottom-right",
-  "custom"
-]);
-var SLICE_TYPE_WIRE_OPTIONS = wireEnumOptions()(["grid-by-cell-size"]);
-var SLICE_NAMING_ORDER_WIRE_OPTIONS = wireEnumOptions()(["row-major", "column-major"]);
-var NORMAL_MAP_FILTERING_WIRE_OPTIONS = wireEnumOptions()(["sharp", "smooth"]);
-var COOKIE_LIGHT_TYPE_WIRE_OPTIONS = wireEnumOptions()(["spot", "directional", "point"]);
-var SINGLE_CHANNEL_COMPONENT_WIRE_OPTIONS = wireEnumOptions()(["alpha", "red"]);
-var SWIZZLE_WIRE_OPTIONS = wireEnumOptions()(["red", "green", "blue", "alpha", "zero", "one"]);
-var AUDIO_LOAD_TYPE_WIRE_OPTIONS = wireEnumOptions()(["decompress-on-load", "compressed-in-memory", "streaming"]);
-var AUDIO_COMPRESSION_FORMAT_WIRE_OPTIONS = wireEnumOptions()(["pcm", "adpcm", "vorbis"]);
-var AUDIO_SAMPLE_RATE_WIRE_OPTIONS = wireEnumOptions()(["preserve-sample-rate", "optimize-sample-rate", "override-sample-rate"]);
-
-// src/project-source/lower-relations.ts
-var RELATION_KIND_BY_PROPERTY = /* @__PURE__ */ new Map([
-  ["tileImports", "world.grid.tile-import"],
-  ["objectImports", "world.grid.object-import"],
-  ["tileLayers", "world.grid.tile-layer"],
-  ["objectLayers", "world.grid.object-layer"]
-]);
-var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
-  ...RELATION_KIND_BY_PROPERTY.values(),
-  "world.tile.compatible-layer",
-  "world.tile.default-layer",
-  "world.object.compatible-layer",
-  "world.object.default-layer",
-  "world.tile-layer-link.target",
-  "world.object-layer-link.target"
-]);
-
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.76.1",
+  cliVersion: "0.76.3",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {
@@ -57531,6 +58303,76 @@ var PROJECT_SCHEMA_CONTRACT = Object.freeze({
   }
 });
 
+// ../packages/neoscript-language/src/project-schema-contract.generated.ts
+var PROJECT_FILE_UPLOAD_BATCH_SIZE = 32;
+
+// src/project-source/lower-configuration.ts
+var wireEnumOptions = () => (options) => options;
+var TEXTURE_TYPE_WIRE_OPTIONS = wireEnumOptions()([
+  "default",
+  "normal-map",
+  "editor-gui-and-legacy-gui",
+  "sprite",
+  "cursor",
+  "cookie",
+  "lightmap",
+  "single-channel"
+]);
+var ALPHA_SOURCE_WIRE_OPTIONS = wireEnumOptions()(["none", "input-texture-alpha", "from-gray-scale"]);
+var NON_POWER_OF_TWO_SCALE_WIRE_OPTIONS = wireEnumOptions()(["none", "to-nearest", "to-larger", "to-smaller"]);
+var MIP_MAP_FILTERING_WIRE_OPTIONS = wireEnumOptions()(["box", "kaiser"]);
+var WRAP_MODE_WIRE_OPTIONS = wireEnumOptions()(["repeat", "clamp", "mirror", "mirror-once", "per-axis"]);
+var FILTER_MODE_WIRE_OPTIONS = wireEnumOptions()(["point", "bilinear", "trilinear"]);
+var RESIZE_ALGORITHM_WIRE_OPTIONS = wireEnumOptions()(["mitchell", "bilinear"]);
+var TEXTURE_COMPRESSION_WIRE_OPTIONS = wireEnumOptions()(["none", "low-quality", "normal-quality", "high-quality"]);
+var PLATFORM_FORMAT_WIRE_OPTIONS = wireEnumOptions()([
+  "automatic",
+  "rgba-compressed-dxt5-bc3",
+  "rgb-compressed-dxt1-bc1",
+  "rgba-32-bit",
+  "rgb-24-bit"
+]);
+var SPRITE_MODE_WIRE_OPTIONS = wireEnumOptions()(["single", "multiple", "polygon"]);
+var MESH_TYPE_WIRE_OPTIONS = wireEnumOptions()(["full-rect", "tight"]);
+var PIVOT_ALIGNMENT_WIRE_OPTIONS = wireEnumOptions()([
+  "center",
+  "top-left",
+  "top-center",
+  "top-right",
+  "left-center",
+  "right-center",
+  "bottom-left",
+  "bottom-center",
+  "bottom-right",
+  "custom"
+]);
+var SLICE_TYPE_WIRE_OPTIONS = wireEnumOptions()(["grid-by-cell-size"]);
+var SLICE_NAMING_ORDER_WIRE_OPTIONS = wireEnumOptions()(["row-major", "column-major"]);
+var NORMAL_MAP_FILTERING_WIRE_OPTIONS = wireEnumOptions()(["sharp", "smooth"]);
+var COOKIE_LIGHT_TYPE_WIRE_OPTIONS = wireEnumOptions()(["spot", "directional", "point"]);
+var SINGLE_CHANNEL_COMPONENT_WIRE_OPTIONS = wireEnumOptions()(["alpha", "red"]);
+var SWIZZLE_WIRE_OPTIONS = wireEnumOptions()(["red", "green", "blue", "alpha", "zero", "one"]);
+var AUDIO_LOAD_TYPE_WIRE_OPTIONS = wireEnumOptions()(["decompress-on-load", "compressed-in-memory", "streaming"]);
+var AUDIO_COMPRESSION_FORMAT_WIRE_OPTIONS = wireEnumOptions()(["pcm", "adpcm", "vorbis"]);
+var AUDIO_SAMPLE_RATE_WIRE_OPTIONS = wireEnumOptions()(["preserve-sample-rate", "optimize-sample-rate", "override-sample-rate"]);
+
+// src/project-source/lower-relations.ts
+var RELATION_KIND_BY_PROPERTY = /* @__PURE__ */ new Map([
+  ["tileImports", "world.grid.tile-import"],
+  ["objectImports", "world.grid.object-import"],
+  ["tileLayers", "world.grid.tile-layer"],
+  ["objectLayers", "world.grid.object-layer"]
+]);
+var SPECIALIZED_RELATION_KINDS = /* @__PURE__ */ new Set([
+  ...RELATION_KIND_BY_PROPERTY.values(),
+  "world.tile.compatible-layer",
+  "world.tile.default-layer",
+  "world.object.compatible-layer",
+  "world.object.default-layer",
+  "world.tile-layer-link.target",
+  "world.object-layer-link.target"
+]);
+
 // src/project-source/workspace-status-core.ts
 var ANIMATION_DOCUMENT_RECORD_KINDS = [
   ProjectRecordKind.Project,
@@ -58213,6 +59055,7 @@ function validateRegistrationAction(action, allowRegistration) {
   }
 }
 function registerSpec(spec, document2) {
+  document2 = withCompiledConstructionTypes(document2, spec.action);
   validateRegistrationAction(spec.action, true);
   const root = {
     name: "",
@@ -58293,7 +59136,7 @@ function registerSpec(spec, document2) {
     makeEvaluatorContext(document2, interceptor),
     []
   );
-  return { spec, root, tests };
+  return { spec, root, tests, document: document2 };
 }
 function mockResponse(environment, mock, selected, call) {
   if (selected === null) {
@@ -58716,13 +59559,13 @@ function prepareTestEvaluator(document2) {
 async function executeTestFile(spec, document2, selected, timeoutMs, interrupted2 = () => false) {
   return executeRegisteredSpec(
     registerSpec(spec, document2),
-    document2,
     selected,
     timeoutMs,
     interrupted2
   );
 }
-async function executeRegisteredSpec(registered, document2, selected, timeoutMs, interrupted2) {
+async function executeRegisteredSpec(registered, selected, timeoutMs, interrupted2) {
+  const document2 = registered.document;
   let restoredRuntimeSources = false;
   const reportFailure = (error, position, member = null) => {
     if (error instanceof NSGetterRuntimeError && error.node !== void 0 && (error.source === void 0 || error.callerNode !== void 0 && runtimeSource(error.callerNode) === void 0)) {