@neocompose/cli 0.76.2 → 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;
@@ -3896,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 */]: [
@@ -6408,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") {
@@ -8654,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);
@@ -8885,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) {
@@ -9486,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;
     }
   };
 }
@@ -9603,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);
@@ -10668,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
   };
@@ -10787,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,
@@ -10804,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;
@@ -10824,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,
@@ -10898,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) ?? [];
@@ -10930,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])
@@ -11233,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,
@@ -11426,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)
     )) {
@@ -11746,6 +11870,7 @@ function cloneDefaultValueForMemberCore(args, sourceValue) {
       effectiveClassId,
       childEnv
     );
+    args.document.recordPlanReads?.(materializationPlan.reads);
     const anchorsParentClassPartition = sourceValue.constructorArgs == null && completeDefaultClassRecord({
       ...args,
       member,
@@ -12630,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 }));
@@ -13595,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) {
@@ -13605,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)) {
@@ -13639,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;
@@ -14840,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) => {
@@ -14850,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);
@@ -14895,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) ?? [];
@@ -15069,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);
@@ -15163,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;
@@ -15615,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;
@@ -16697,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, {
@@ -16737,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;
@@ -16757,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;
@@ -19208,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({
@@ -21592,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 };
@@ -21606,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 {
@@ -21641,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)
@@ -21965,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) => {
@@ -21987,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,
@@ -22015,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,
@@ -22035,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,
@@ -22046,7 +22424,7 @@ function worldGridQueryIndexForContext(context) {
       ) !== null)
         return value;
       return trackedRowForValueReference(value, current)?.id ?? null;
-    }
+    })
   });
 }
 function readSystemNativeField(value, key, ctx) {
@@ -23685,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;
@@ -24303,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,
@@ -24315,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(
@@ -27853,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;
@@ -27874,7 +28272,8 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
           const argumentType = resolveMemberDeclaredTypeInfoInternal(
             argumentMember,
             members,
-            nextSeen
+            nextSeen,
+            ownerClass
           );
           return argumentType === null ? [] : [[genericParamId, argumentType]];
         }
@@ -27940,7 +28339,8 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
     const entryTypeInfo = resolveMemberDeclaredTypeInfoInternal(
       entry,
       members,
-      nextSeen
+      nextSeen,
+      ownerClass
     );
     if (entryTypeInfo === null) return null;
     return {
@@ -27957,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)
@@ -30648,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();
@@ -30755,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
@@ -30766,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
@@ -30788,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,
@@ -30875,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;
@@ -30942,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(
@@ -31014,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,
@@ -31039,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,
@@ -31103,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,
@@ -31662,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;
@@ -31682,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: () => {
@@ -31760,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,
@@ -32535,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]));
@@ -32558,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;
     }
   };
@@ -32576,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);
@@ -32624,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) {
@@ -32639,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({
@@ -32668,6 +33184,7 @@ function createHeadlessVirtualInstanceResolver(args) {
       failedRootIds.add(rootId);
       return emptyRows;
     } finally {
+      expandingRootIds.delete(rootId);
       activeReads.pop();
       mergeReads(reads);
     }
@@ -32686,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);
@@ -32732,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);
@@ -32744,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 {
@@ -32769,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");
+      }
     }
   };
 }
@@ -32818,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),
@@ -32844,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;
@@ -32872,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, {
@@ -32962,8 +33475,7 @@ function initializerEvaluatorLookups(document2, readTracking) {
       revision,
       lookups
     });
-    if (headlessVirtualResolver !== null)
-      headlessResolversByLookupKey.set(lookupKey, headlessVirtualResolver);
+    headlessResolversByLookupKey.set(lookupKey, headlessVirtualResolver);
   }
   return lookups;
 }
@@ -33283,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([
   ["(", ")"],
@@ -40272,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,
@@ -48910,6 +49378,8 @@ function compileDelegateClosureValue(code, signature) {
     variants: [...signature.variants ?? []],
     variantFolders: [...signature.variantFolders ?? []],
     thisClass: signature.thisClass,
+    implicitMemberAccess: true,
+    staticMember: signature.staticMember,
     returnTypeInfo: {
       type: 25 /* NSDelegate */,
       required: true,
@@ -48979,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.`
@@ -49013,19 +49487,6 @@ function compileMemberInitializerBody(args) {
   }
   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;
@@ -56408,7 +56869,7 @@ var INITIALIZER_KEY_PLACEHOLDER = new RegExp(
 
 // ../packages/manifest/schema-contract/registry.mjs
 var PROJECT_SCHEMA_CONTRACT = Object.freeze({
-  cliVersion: "0.76.2",
+  cliVersion: "0.76.3",
   projectFileUploadBatchSize: 32,
   documentRecords: {
     member: {
@@ -58594,6 +59055,7 @@ function validateRegistrationAction(action, allowRegistration) {
   }
 }
 function registerSpec(spec, document2) {
+  document2 = withCompiledConstructionTypes(document2, spec.action);
   validateRegistrationAction(spec.action, true);
   const root = {
     name: "",
@@ -58674,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) {
@@ -59097,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)) {