@neocompose/cli 0.76.2 → 0.76.3

package/dist/neo.mjs

@@ -10011,13 +10011,16 @@ function constructionMembers(classId, context) {
 }
 function createMemberDefaultConstructionChecker(document) {
   const context = contextFor(document);
-  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;
     }
   };
 }
@@ -10128,6 +10131,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);
@@ -11312,74 +11316,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(document, options = {}) {
   const cache = options.cache ?? createDefaultValueResolutionCache();
-  if (cache.memberByIdIndex === null && options.memberById === void 0 && document.memberById === void 0) {
-    cache.memberByIdIndex = new Map(
+  const schemaCache = cache.schema;
+  if (schemaCache.memberByIdIndex === null && options.memberById === void 0 && document.memberById === void 0) {
+    schemaCache.memberByIdIndex = new Map(
       document.members.map((member) => [member.id, member])
     );
   }
   const indexed = {
     ...document,
-    memberById: (id2) => options.memberById?.(id2) ?? document.memberById?.(id2) ?? cache.memberByIdIndex?.get(id2) ?? null,
+    memberById: (id2) => options.memberById?.(id2) ?? document.memberById?.(id2) ?? schemaCache.memberByIdIndex?.get(id2) ?? null,
     resolvedMember: (member) => {
       const memberId = "id" in member ? member.id : void 0;
       if (typeof memberId !== "string") {
         return resolveMember(member, document.members);
       }
-      const cached = cache.resolvedMemberById.get(memberId);
+      const cached = schemaCache.resolvedMemberById.get(memberId);
       if (cached !== void 0) return cached;
       const resolved = resolveMember(member, document.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,
         document.classes,
         document.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,
         document.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: document.constructors ?? []
       });
-      return cache.memberDefaultConstructionChecker(member, environment);
+      return cache.memberDefaultConstructionChecker(
+        member,
+        environment,
+        readValueIds
+      );
     },
     createValueRow: options.createValueRow ?? document.createValueRow
   };
@@ -11431,12 +11445,20 @@ function buildDefaultClassMaterializationPlan(document, classId, instanceEnv) {
     ...document,
     constructors: document.constructors ?? []
   });
-  return storedSchemaOf(document, classId).flatMap(
+  const reads = {
+    valueIds: /* @__PURE__ */ new Set(),
+    containerIds: /* @__PURE__ */ new Set()
+  };
+  const entries = storedSchemaOf(document, classId).flatMap(
     (entry) => {
       if (entry.memberId === null) return [];
       const childMember = findMemberInDocument(document, entry.memberId);
       if (!memberKindOwnsStoredValue(childMember.kind)) return [];
-      if (instanceEnv.size === 0 && isConstantMember(document, resolvedInDocument(document, childMember)))
+      if (instanceEnv.size === 0 && isConstantMember(
+        document,
+        resolvedInDocument(document, childMember),
+        reads
+      ))
         return [];
       const member = substituteMember(
         childMember,
@@ -11448,14 +11470,19 @@ function buildDefaultClassMaterializationPlan(document, classId, instanceEnv) {
         {
           schemaKey: entry.schemaKey,
           member,
-          defaultSettlesConstruction: settlesConstruction(member, instanceEnv),
+          defaultSettlesConstruction: settlesConstruction(
+            member,
+            instanceEnv,
+            reads.valueIds
+          ),
           directScalarBody: directScalarDefaultBody(document, member)
         }
       ];
     }
   );
+  return { entries, reads };
 }
-function isConstantMember(document, resolved) {
+function isConstantMember(document, resolved, reads) {
   if (isStaticMember(resolved)) return false;
   const fixedness = fixednessOf(resolved, 0 /* Writable */);
   if (fixedness === 0 /* Writable */) return false;
@@ -11468,7 +11495,8 @@ function isConstantMember(document, resolved) {
       document,
       rows: /* @__PURE__ */ new Set(),
       declarations: /* @__PURE__ */ new Set(),
-      classes: /* @__PURE__ */ new Set()
+      classes: /* @__PURE__ */ new Set(),
+      reads
     },
     resolved,
     declared,
@@ -11542,6 +11570,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 ? [] : document.unorderedListEntryIds?.(rowId) ?? (walk.membership ??= buildUnorderedListMembershipIndex(
       document.values
     )).get(rowId) ?? [];
@@ -11574,6 +11604,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 } = walk;
   const row = document.valueById?.(valueId) ?? (walk.rowById ??= new Map(
     document.values.map((value) => [value.id, value])
@@ -11877,6 +11908,7 @@ function buildDefaultMemberValueCore(args, resolvedMember) {
       effectiveClassId,
       childEnv
     );
+    args.document.recordPlanReads?.(materializationPlan.reads);
     const record7 = member.payload === 1 /* Partial */ ? {} : cloneDefaultClassRecord({
       document: args.document,
       projectId: args.projectId,
@@ -12070,7 +12102,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)
     )) {
@@ -12390,6 +12422,7 @@ function cloneDefaultValueForMemberCore(args, sourceValue) {
       effectiveClassId,
       childEnv
     );
+    args.document.recordPlanReads?.(materializationPlan.reads);
     const anchorsParentClassPartition = sourceValue.constructorArgs == null && completeDefaultClassRecord({
       ...args,
       member,
@@ -37059,7 +37092,10 @@ var init_strict_resolver = __esm({
           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,
@@ -45493,7 +45529,7 @@ function validateExpression(expression, expected, scope, environment, uri, range
   if (expected && expression.kind !== "contextualEnum" && expression.kind !== "annotated" && !isReferenceCall(expression)) {
     const actual = inferExpressionType(expression, scope, environment);
     const explicitConstruction = expression.kind === "new" && expression.className !== null && expected.name !== "Partial";
-    const assignable = actual === void 0 || (explicitConstruction ? constructionTypesAssignable(actual, expected, scope, environment) : semanticTypesAssignable(actual, expected));
+    const assignable = actual === void 0 || (explicitConstruction ? constructionTypesAssignable(actual, expected, scope, environment) : semanticTypesAssignable(actual, expected, environment));
     if (actual && !assignable) {
       pushDiagnostic(
         diagnostics,
@@ -45508,13 +45544,18 @@ function validateExpression(expression, expected, scope, environment, uri, range
       );
     }
   }
-  if (expression.kind === "contextualEnum") {
-    const enumeration = expected ? environment.enums.get(expected.name) : void 0;
+  const qualifiedEnum = qualifiedEnumReceiver(expression, scope, environment);
+  if (expression.kind === "contextualEnum" || expression.kind === "member" && qualifiedEnum !== void 0) {
+    let enumeration = qualifiedEnum;
+    if (expression.kind === "contextualEnum" && expected !== void 0) {
+      enumeration = environment.enums.get(expected.name);
+    }
+    const optionRange = anchor ? anchorSpan(anchor, expression.pos, 1) : range2;
     if (!enumeration) {
       pushDiagnostic(
         diagnostics,
         uri,
-        range2,
+        optionRange,
         "contextual-enum-without-expected-type",
         `Cannot infer enum option '.${expression.name}' without one expected enum type.`
       );
@@ -45522,7 +45563,7 @@ function validateExpression(expression, expected, scope, environment, uri, range
       pushDiagnostic(
         diagnostics,
         uri,
-        range2,
+        optionRange,
         "unknown-contextual-enum-option",
         `Enum '${enumeration.name}' has no option '${expression.name}'.`
       );
@@ -45598,7 +45639,8 @@ function validateExpression(expression, expected, scope, environment, uri, range
     for (const entry of expression.entries) {
       validateExpression(
         entry.key,
-        key,
+        // Enum dictionaries also preserve quoted option IDs, including orphaned IDs.
+        entry.key.kind === "litString" ? void 0 : key,
         scope,
         environment,
         uri,
@@ -45689,7 +45731,7 @@ function validateExpression(expression, expected, scope, environment, uri, range
       scope,
       environment
     );
-    const branchType = expected ?? commonSemanticAssignableType(trueType, falseType);
+    const branchType = expected ?? commonSemanticAssignableType(trueType, falseType, environment);
     validateExpression(
       expression.whenTrue,
       branchType,
@@ -46292,7 +46334,7 @@ function substituteSemanticType(type, bindings) {
   );
   return { ...type, arguments: argumentsList2 };
 }
-function semanticTypesAssignable(actual, expected) {
+function semanticTypesAssignable(actual, expected, environment) {
   if (actual.name === "null") {
     return expected.name === "null" || expected.nullable === true;
   }
@@ -46307,18 +46349,13 @@ function semanticTypesAssignable(actual, expected) {
   if (actual.name === "float" && expected.name === "decimal") {
     return actual.nullable !== true || expected.nullable === true;
   }
-  if (Object.prototype.hasOwnProperty.call(
-    NEO_PROJECT_SOURCE_RECORD_CONTRACT.enums,
-    expected.name
-  )) {
-    return false;
-  }
+  if (environment.enums.has(expected.name)) return false;
   if (SEMANTIC_PRIMITIVE_TYPE_NAMES.has(expected.name) && SEMANTIC_PRIMITIVE_TYPE_NAMES.has(actual.name)) {
     return false;
   }
   return true;
 }
-function commonSemanticAssignableType(left, right) {
+function commonSemanticAssignableType(left, right, environment) {
   if (left === void 0) return right;
   if (right === void 0) return left;
   if (left.name === "null" && right.name === "null") return left;
@@ -46339,8 +46376,8 @@ function commonSemanticAssignableType(left, right) {
       nullable: left.nullable === true || right.nullable === true
     };
   }
-  if (semanticTypesAssignable(left, right)) return right;
-  if (semanticTypesAssignable(right, left)) return left;
+  if (semanticTypesAssignable(left, right, environment)) return right;
+  if (semanticTypesAssignable(right, left, environment)) return left;
   return void 0;
 }
 function constructionTypesAssignable(actual, expected, scope, environment) {
@@ -46515,6 +46552,14 @@ function validateInlineAnnotation(annotation2, environment, uri, range2, diagnos
     diagnostics
   );
 }
+function qualifiedEnumReceiver(expression, scope, environment) {
+  if (expression.kind !== "member") return void 0;
+  if (expression.receiver.kind !== "ident") return void 0;
+  const name = expression.receiver.name;
+  if (scope.has(name)) return void 0;
+  if (environment.globals.has(name)) return void 0;
+  return environment.enums.get(name);
+}
 function inferExpressionType(expression, scope, environment) {
   if (expression.kind === "annotated")
     return inferExpressionType(expression.expression, scope, environment);
@@ -46567,12 +46612,11 @@ function inferExpressionType(expression, scope, environment) {
       scope,
       environment
     );
-    return commonSemanticAssignableType(whenTrue, whenFalse);
+    return commonSemanticAssignableType(whenTrue, whenFalse, environment);
   }
   if (expression.kind === "member") {
-    if (expression.receiver.kind === "ident" && environment.enums.has(expression.receiver.name)) {
-      return { name: expression.receiver.name };
-    }
+    const enumeration = qualifiedEnumReceiver(expression, scope, environment);
+    if (enumeration !== void 0) return { name: enumeration.name };
     const receiverType = inferExpressionType(
       expression.receiver,
       scope,
@@ -52896,7 +52940,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.76.2",
+      cliVersion: "0.76.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -62877,7 +62921,7 @@ function collectDerivedBodySites(recordKind, record7) {
     });
   }
   if (record7.kind === 25 /* NSDelegate */) {
-    collectDelegateClosureSite(asRecord2(record7.defaultValue), sites, false);
+    collectDelegateClosureSite(asRecord2(record7.defaultValue), sites, true);
   }
   collectInitializerSite(asRecord2(record7.defaultValue), sites);
   return sites;
@@ -66018,10 +66062,15 @@ var init_lookup_declared_type = __esm({
 });
 
 // ../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;
@@ -66039,7 +66088,8 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
           const argumentType = resolveMemberDeclaredTypeInfoInternal(
             argumentMember,
             members,
-            nextSeen
+            nextSeen,
+            ownerClass
           );
           return argumentType === null ? [] : [[genericParamId, argumentType]];
         }
@@ -66105,7 +66155,8 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
     const entryTypeInfo = resolveMemberDeclaredTypeInfoInternal(
       entry,
       members,
-      nextSeen
+      nextSeen,
+      ownerClass
     );
     if (entryTypeInfo === null) return null;
     return {
@@ -66122,12 +66173,29 @@ function resolveMemberDeclaredTypeInfoInternal(member, members, seen) {
     if (collection === void 0) return null;
     return lookupDeclaredTypeInfo2(
       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(
+      (parameter4) => parameter4.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)
@@ -69840,6 +69908,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,
@@ -70097,7 +70167,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.`
@@ -70131,19 +70205,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(
-    (parameter4) => parameter4.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;
@@ -70223,12 +70284,25 @@ function compileMemberDelegateDefault(args) {
   if (defaultValue === void 0 || !isLiteralValueContent(defaultValue) || !isNSDelegateClosureValueDraft(defaultValue.value)) {
     return;
   }
-  defaultValue.value = compileDelegateClosureValue(defaultValue.value.code, {
-    ...args,
-    returnTypeInfo: args.member.returnTypeInfo,
-    argumentTypes: args.member.argumentTypes,
-    name: args.member.name
-  });
+  const code = defaultValue.value.code;
+  try {
+    defaultValue.value = compileDelegateClosureValue(code, {
+      ...args,
+      staticMember: isStaticMember(args.member),
+      returnTypeInfo: args.member.returnTypeInfo,
+      argumentTypes: args.member.argumentTypes,
+      name: args.member.name
+    });
+  } catch (error) {
+    throwNamedBodyCompileFailure({
+      error,
+      memberId: args.member.id,
+      memberName: args.member.name,
+      valueId: null,
+      code,
+      codePosition: delegateClosureCodePosition
+    });
+  }
 }
 function compileConstructorRecord(args) {
   const owner = args.classes.find(
@@ -71361,21 +71435,16 @@ function classifyUnattributableRead(reason) {
   }
   return { scope: "corpus" /* Corpus */ };
 }
-var OWNERSHIP_CHAIN_PREFIXES, CONTAINER_ENTRIES_PREFIX, OWNERSHIP_CHAIN_READ;
+var OWNERSHIP_CHAIN_PREFIXES, CONTAINER_ENTRIES_PREFIX;
 var init_unattributable_reads = __esm({
   "../packages/neoscript-runtime/src/neoscript/unattributable-reads.ts"() {
     "use strict";
     OWNERSHIP_CHAIN_PREFIXES = [
       "generic-parent-resolution:",
       "member-owner-resolution:",
-      "owned-value-parents:",
-      "declaration-owner-resolution:"
+      "owned-value-parents:"
     ];
     CONTAINER_ENTRIES_PREFIX = "container-entries:";
-    OWNERSHIP_CHAIN_READ = ownershipChainRead(
-      "member-owner-resolution",
-      "*"
-    );
   }
 });
 
@@ -71394,12 +71463,13 @@ function valueIdsWithSourceChains(targetValueIds, valuesById) {
   }
   return result;
 }
-function initializerOwnerContext(document, valueId, rootOwners, valuesById) {
+function initializerOwnerContext(document, 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;
@@ -72330,9 +72400,8 @@ var init_initializer_context = __esm({
       /**
        * 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) => {
@@ -72340,7 +72409,6 @@ var init_initializer_context = __esm({
         const read = classifyUnattributableRead(reason);
         switch (read.scope) {
           case "ownership-chain" /* OwnershipChain */:
-            this.hasOwnershipChainRead = true;
             return;
           case "container" /* Container */:
             this.containerEntryReadIds.add(read.containerId);
@@ -72375,6 +72443,10 @@ function getWorldGridQueryIndex(source) {
     building.delete(source.cacheKey);
   }
 }
+function readsAny(reads, ids) {
+  for (const id2 of ids) if (reads.has(id2)) return true;
+  return false;
+}
 function buildIndex(source) {
   const reads = new InitializerReadSet();
   const relations = createEffectiveClassRelationResolver(source);
@@ -72456,8 +72528,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 (record5(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);
@@ -72550,11 +72627,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 record5(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -72618,16 +72702,56 @@ var init_world_grid_query = __esm({
     indexes2 = /* @__PURE__ */ new WeakMap();
     building = /* @__PURE__ */ new WeakSet();
     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 id2 of valueIds) {
+          if (reads.valueIds.has(id2)) return true;
+          const classId = this.placedRecordIds.has(id2) ? stampOf(id2) : classIdOf(id2);
+          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 id2 of containerIds) {
+          if (reads.containerIds.has(id2)) return true;
+          if (reads.containerEntryReadIds.has(id2)) 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) ?? [];
@@ -74111,8 +74235,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, {
@@ -74151,6 +74275,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;
@@ -74171,7 +74313,7 @@ function evaluatorDefaultValueDocument(ctx) {
       projectFiles: ctx.vm.projectFiles ?? [],
       textureTemplates: ctx.vm.textureTemplates ?? []
     },
-    { cache: evaluatorResolutionCache(ctx).defaultValueResolutionCache }
+    { cache: evaluatorValueGeneration(ctx).defaults }
   );
   ctx.__defaultValueDocument = document;
   return document;
@@ -76596,8 +76738,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({
@@ -78979,6 +79125,17 @@ function ensureVirtualExpansionIndexed(rows, ctx, existingIndexes) {
   );
   indexes3.indexedVirtualRowSets.add(rows);
 }
+function recordDeclarationReads(ctx, reads) {
+  for (const id2 of reads.valueIds) ctx.valueDependencies?.add(id2);
+  for (const id2 of reads.containerIds) ctx.containerDependencies?.add(id2);
+}
+function constantMemberDecision(document, member) {
+  const reads = {
+    valueIds: /* @__PURE__ */ new Set(),
+    containerIds: /* @__PURE__ */ new Set()
+  };
+  return { constant: isConstantMember(document, member, reads), reads };
+}
 function readDeclarationDefault(member, ctx) {
   if (member?.defaultValue === void 0 || member.defaultValue === null) {
     return { matched: false };
@@ -78993,16 +79150,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 document = constructorDefaultValueDocument(ctx, member);
-    const constant = shared !== void 0 && known !== false && (known !== void 0 || isConstantMember(document, member));
-    if (shared !== void 0 && !constant) shared.set(member.id, false);
+    if (shared !== void 0 && known === void 0) {
+      known = constantMemberDecision(document, member);
+      recordDeclarationReads(ctx, known.reads);
+      shared.set(member.id, known);
+    }
     const created = [];
     const closeFrame = pushConstructionFrame(ctx, `${member.name} declaration`);
     try {
@@ -79028,7 +79189,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)
@@ -79352,6 +79513,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) => {
@@ -79374,24 +79539,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(id2, reads) {
+    readRow: (id2, reads) => recording(reads, () => {
       const current = readContext(reads);
       const row = evalValueById(
         current,
@@ -79402,8 +79569,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(id2, key, reads) {
+    }),
+    readField: (id2, key, reads) => recording(reads, () => {
       const current = readContext(reads);
       const row = evalValueById(
         current,
@@ -79422,8 +79589,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,
@@ -79433,7 +79600,7 @@ function worldGridQueryIndexForContext(context) {
       ) !== null)
         return value;
       return trackedRowForValueReference(value, current)?.id ?? null;
-    }
+    })
   });
 }
 function readSystemNativeField(value, key, ctx) {
@@ -81059,7 +81226,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;
@@ -81676,6 +81843,8 @@ function constructClassValue(info, scope, ctx) {
   }
 }
 function constructorDefaultValueDocument(ctx, syntheticMember2) {
+  const database = ctx.vm.databaseVM;
+  const entryIdsOf = database?.unorderedListEntryIds?.bind(database);
   return {
     listenerDefaultCapture: ctx.listenerDefaultCapture,
     beforeValueAllocation: ctx.beforeValueAllocation,
@@ -81688,11 +81857,24 @@ function constructorDefaultValueDocument(ctx, syntheticMember2) {
     // 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: (id2) => {
+        ctx.valueDependencies?.add(id2);
+        return database.defaultValueById !== void 0 ? database.defaultValueById(id2) : database.valueById(id2);
+      }
+    },
+    ...entryIdsOf === void 0 ? {} : {
+      unorderedListEntryIds: (containerId) => {
+        ctx.containerDependencies?.add(containerId);
+        return entryIdsOf(containerId);
+      }
+    },
     resolvedMember: (member) => member === syntheticMember2 ? syntheticMember2 : 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(
@@ -86537,43 +86719,50 @@ function claimVirtualIdentity(args) {
   args.claimedVirtualIds.set(virtualId, args.pathKey);
   return { sourceIdentity: sourceIdentity3, virtualId };
 }
-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(
@@ -86609,11 +86798,6 @@ function expandStoredInstance(args) {
       `Virtual expansion root "${args.instanceRoot.id}" is missing required constructor arguments.`
     );
   }
-  const constructorArguments4 = storedConstructorReplayArguments(
-    requiredConstructor,
-    storedArgs,
-    instanceRoot.id
-  );
   const {
     value: _value,
     classId: _classId,
@@ -86634,6 +86818,34 @@ function expandStoredInstance(args) {
     instanceRoot
   );
   const replayMember = closedRootMember === rootMember ? rootMember : { ...closedRootMember, classId };
+  let environment;
+  const constructorArguments4 = 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,
@@ -86698,11 +86910,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,
@@ -87257,15 +87465,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 recordKeysLost(kept, candidate) {
   if (!isLiteralValueContent(kept)) return [];
   if (!isLiteralValueContent(candidate)) return [];
@@ -87298,9 +87497,10 @@ function prepareStoredClassValueResolution(args) {
     ...args.document,
     // Construction checks share the existing schema index across every nested default.
     memberById: args.document.memberById ?? ((id2) => schema.member(id2) ?? 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: () => {
@@ -87510,27 +87710,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,
@@ -89207,6 +89412,17 @@ function variantSwapDeclaredMember(document, rootValueId) {
   if (placement === void 0) return void 0;
   return document.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 } = args;
   const membersById = args.membersById ?? new Map(document.members.map((member) => [member.id, member]));
@@ -89230,16 +89446,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 id2 of reads.valueIds) active.valueIds.add(id2);
       for (const id2 of reads.containerIds) active.containerIds.add(id2);
+      for (const id2 of reads.localizedTextIds) active.localizedTextIds.add(id2);
+      for (const id2 of reads.variantIds) active.variantIds.add(id2);
+      for (const id2 of reads.staticMemberIds) active.staticMemberIds.add(id2);
       if (reads.global) active.global = true;
     }
   };
@@ -89248,9 +89470,18 @@ function createHeadlessVirtualInstanceResolver(args) {
       for (const active of activeReads) active.valueIds.add(id2);
       args.readRecorder?.recordValueRead(id2);
     },
-    recordLocalizedTextRead: (id2) => args.readRecorder?.recordLocalizedTextRead(id2),
-    recordVariantRead: (id2) => args.readRecorder?.recordVariantRead(id2),
-    recordStaticMemberRead: (id2) => args.readRecorder?.recordStaticMemberRead(id2),
+    recordLocalizedTextRead: (id2) => {
+      for (const active of activeReads) active.localizedTextIds.add(id2);
+      args.readRecorder?.recordLocalizedTextRead(id2);
+    },
+    recordVariantRead: (id2) => {
+      for (const active of activeReads) active.variantIds.add(id2);
+      args.readRecorder?.recordVariantRead(id2);
+    },
+    recordStaticMemberRead: (id2) => {
+      for (const active of activeReads) active.staticMemberIds.add(id2);
+      args.readRecorder?.recordStaticMemberRead(id2);
+    },
     recordContainerMembershipRead: (id2) => {
       for (const active of activeReads) active.containerIds.add(id2);
       args.readRecorder?.recordContainerMembershipRead(id2);
@@ -89296,6 +89527,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) {
@@ -89311,12 +89543,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({
@@ -89340,6 +89569,7 @@ function createHeadlessVirtualInstanceResolver(args) {
       failedRootIds.add(rootId);
       return emptyRows;
     } finally {
+      expandingRootIds.delete(rootId);
       activeReads.pop();
       mergeReads(reads);
     }
@@ -89358,9 +89588,15 @@ function createHeadlessVirtualInstanceResolver(args) {
       share.containerChanged
     );
     if (shared === null) return null;
+    recorder.recordValuePlacementRead();
     for (const id2 of shared.reads.valueIds) recorder.recordValueRead(id2);
     for (const id2 of shared.reads.containerIds)
       recorder.recordContainerMembershipRead(id2);
+    for (const id2 of shared.reads.localizedTextIds)
+      recorder.recordLocalizedTextRead(id2);
+    for (const id2 of shared.reads.variantIds) recorder.recordVariantRead(id2);
+    for (const id2 of shared.reads.staticMemberIds)
+      recorder.recordStaticMemberRead(id2);
     if (graphRowsByRootId.get(shared.graph.instanceRootId) === void 0) {
       readsByRootId.set(shared.graph.instanceRootId, shared.reads);
       remember(shared.graph, shared.rows);
@@ -89404,7 +89640,16 @@ function createHeadlessVirtualInstanceResolver(args) {
       return graph?.instanceRootId === rootId ? graph : null;
     },
     virtualInstanceRowsForValue,
-    valueById: (id2) => expandedRowById.get(id2) ?? null,
+    valueById: (id2) => {
+      const row = expandedRowById.get(id2);
+      if (row === void 0) return null;
+      if (activeReads.length > 0) {
+        const rootId = graphByValueId.get(id2)?.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);
@@ -89416,11 +89661,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 {
@@ -89441,6 +89682,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");
+      }
     }
   };
 }
@@ -89456,7 +89720,7 @@ function assertStoredConstructionStamp(root, classId = root.classId) {
     );
   }
 }
-var KEPT_ROW_SAMPLE_LIMIT, CORPUS_SCANNING_MEMBER_KINDS, VirtualExpansionUnsupportedError, ROOT_PATH, OpenGenericComparisonError, SYNTHETIC_LINEAGE_PREFIXES, resolverDocumentsByDocument;
+var KEPT_ROW_SAMPLE_LIMIT, VirtualExpansionUnsupportedError, ROOT_PATH, OpenGenericComparisonError, SYNTHETIC_LINEAGE_PREFIXES, resolverDocumentsByDocument;
 var init_virtual_instance_graph = __esm({
   "../packages/neoscript-runtime/src/virtual-instance-graph.ts"() {
     "use strict";
@@ -89475,6 +89739,7 @@ var init_virtual_instance_graph = __esm({
     init_member_value_id();
     init_stored_value_placement_index();
     init_unordered_list_membership();
+    init_neoscript_types();
     init_neoscript_guards();
     init_project_schema_index();
     init_initializer_context();
@@ -89482,10 +89747,6 @@ var init_virtual_instance_graph = __esm({
     init_initializer_materialization();
     init_unattributable_reads();
     KEPT_ROW_SAMPLE_LIMIT = 12;
-    CORPUS_SCANNING_MEMBER_KINDS = /* @__PURE__ */ new Set([
-      9 /* Lookup */,
-      18 /* DialogueLookup */
-    ]);
     VirtualExpansionUnsupportedError = class extends Error {
       constructor(message) {
         super(message);
@@ -89534,6 +89795,10 @@ function initializerEvaluatorLookups(document, readTracking) {
       ...databaseVM.changeListenerDefaultsForOwner === void 0 ? {} : {
         changeListenerDefaultsForOwner: (id2) => databaseVM.changeListenerDefaultsForOwner(id2)
       },
+      // Read live: this wrapper outlives a scalar's nullness change.
+      get valueGeneration() {
+        return databaseVM.valueGeneration;
+      },
       memberById: (id2) => databaseVM.memberById(id2),
       valueById: (id2) => databaseVM.valueById(id2),
       defaultValueById: (id2) => databaseVM.defaultValueById?.(id2) ?? databaseVM.valueById(id2),
@@ -89560,6 +89825,7 @@ function initializerEvaluatorLookups(document, 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;
@@ -89588,88 +89854,45 @@ function initializerEvaluatorLookups(document, readTracking) {
     indexKey,
     revision
   );
-  const shareFrom = document.databaseVM === void 0 && document.evaluatorOverlay !== void 0 ? sharedHeadlessResolver(document.evaluatorOverlay) : void 0;
+  const shareFrom = document.evaluatorOverlay === void 0 ? void 0 : sharedHeadlessResolver(document.evaluatorOverlay);
   let hasListenerMetadata;
-  const headlessVirtualResolver = document.databaseVM === void 0 ? createHeadlessVirtualInstanceResolver({
+  const headlessVirtualResolver = createHeadlessVirtualInstanceResolver({
     evaluateInitializer: evaluateMemberInitializer,
     document,
     resolverLookups: () => lookups,
     ...shareFrom === void 0 ? {} : { shareFrom },
     ...readTracking === void 0 ? {} : { readRecorder: virtualReadRecorder(readTracking) }
-  }) : null;
+  });
   const lookups = {
     ...indexedLookups,
-    ...document.databaseVM === void 0 && headlessVirtualResolver !== null ? {
-      changeListenerDefaultsForOwner: (id2) => {
-        if (!(hasListenerMetadata ??= hasAuthoredChangeListenerMetadata(document)))
-          return void 0;
-        const inherited = headlessVirtualResolver.virtualInstanceGraphForValue(id2)?.listenerDefaultsByOwner?.get(id2);
-        const authored = authoredChangeListenerOwners(document.values).get(
-          id2
-        );
-        return inherited === void 0 ? authored : { ...inherited, ...authored };
-      },
-      defaultValueById: (id2) => declarationDefaultSource(
-        id2,
-        indexedLookups.valueById(id2),
-        headlessVirtualResolver.virtualInstanceGraphForValue
-      ),
-      valueById: (id2) => indexedLookups.valueById(id2) ?? headlessVirtualResolver.valueById(id2),
-      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,
-        resolverLookups: lookups,
-        ...readTracking === void 0 ? {} : { readRecorder: virtualReadRecorder(readTracking) },
-        ...args
-      })
-    } : {
-      get worldQueryRevision() {
-        return document.databaseVM?.worldQueryRevision;
-      },
-      memberById: (id2) => document.databaseVM?.memberById(id2) ?? null,
-      valueById: (id2) => document.databaseVM?.valueById(id2) ?? null,
-      variantById: (id2) => document.databaseVM?.variantById?.(id2) ?? 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) ?? document.databaseVM?.rowForValueReference?.(value) ?? null,
-      unorderedListEntryIds: (containerValueId) => {
-        const resolved = document.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 = document.databaseVM;
-        if (databaseVM === void 0) return [];
-        return databaseVM.virtualInstanceRowsForValue(receiverValueId);
-      },
-      resolveVariantInstanceGraph: (args) => {
-        const resolver = document.databaseVM?.resolveVariantInstanceGraph;
-        if (resolver === void 0) {
-          throw new Error(
-            "Evaluator database has no virtual variant resolver."
-          );
-        }
-        return resolver.call(document.databaseVM, args);
-      }
-    }
+    changeListenerDefaultsForOwner: (id2) => {
+      if (!(hasListenerMetadata ??= hasAuthoredChangeListenerMetadata(document)))
+        return void 0;
+      const inherited = headlessVirtualResolver.virtualInstanceGraphForValue(id2)?.listenerDefaultsByOwner?.get(id2);
+      const authored = authoredChangeListenerOwners(document.values).get(id2);
+      return inherited === void 0 ? authored : { ...inherited, ...authored };
+    },
+    defaultValueById: (id2) => declarationDefaultSource(
+      id2,
+      indexedLookups.valueById(id2),
+      headlessVirtualResolver.virtualInstanceGraphForValue
+    ),
+    valueById: (id2) => indexedLookups.valueById(id2) ?? headlessVirtualResolver.valueById(id2),
+    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,
+      resolverLookups: lookups,
+      ...readTracking === void 0 ? {} : { readRecorder: virtualReadRecorder(readTracking) },
+      ...args
+    })
   };
   if (!trackedHeadless) {
     evaluatorLookupsByDocument.set(lookupKey, {
@@ -89678,8 +89901,7 @@ function initializerEvaluatorLookups(document, readTracking) {
       revision,
       lookups
     });
-    if (headlessVirtualResolver !== null)
-      headlessResolversByLookupKey.set(lookupKey, headlessVirtualResolver);
+    headlessResolversByLookupKey.set(lookupKey, headlessVirtualResolver);
   }
   return lookups;
 }
@@ -90186,6 +90408,40 @@ function declarationInitializerContext(document) {
   });
   return created;
 }
+function defaultValuePlans(document) {
+  const key = document.databaseVM ?? initializerEvaluatorCacheKey(document);
+  const revision = initializerEvaluatorCacheRevision(document);
+  const valueGeneration = document.databaseVM?.valueGeneration;
+  const cached = defaultValuePlansByDocument.get(key);
+  if (cached !== void 0 && (revision === void 0 ? cached.members === document.members && cached.classes === document.classes && cached.values === document.values && cached.constructors === document.constructors : cached.revision === revision && cached.valueGeneration === valueGeneration)) {
+    return cached.plans;
+  }
+  const lookups = initializerEvaluatorLookups(document);
+  const plans = withIndexedDefaultValueDocument({
+    project: document.project,
+    members: document.members,
+    classes: document.classes,
+    enums: document.enums,
+    values: document.values,
+    constructors: document.constructors,
+    projectFiles: document.projectFiles,
+    textureTemplates: document.textureTemplates,
+    memberById: lookups.memberById,
+    valueById: lookups.defaultValueById ?? lookups.valueById,
+    // A host database without list membership falls back to `values`.
+    unorderedListEntryIds: document.databaseVM?.unorderedListEntryIds === void 0 && document.databaseVM !== void 0 ? void 0 : lookups.unorderedListEntryIds
+  });
+  defaultValuePlansByDocument.set(key, {
+    members: document.members,
+    classes: document.classes,
+    values: document.values,
+    constructors: document.constructors,
+    revision,
+    valueGeneration,
+    plans
+  });
+  return plans;
+}
 function evaluateInitializerMaterialization(args) {
   const createdValues = [];
   const storageKeyDeclarations = /* @__PURE__ */ new Map();
@@ -90293,9 +90549,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
@@ -90304,7 +90557,8 @@ function materializeMemberDefaultValue(args) {
       args.document,
       sourceValueId,
       rootOwners,
-      valuesById
+      valuesById,
+      (id2) => args.readTracking?.valueIds.add(id2)
     ).ownerClass : typeof Reflect.get(member, "id") === "string" ? findSchemaPlacement(
       String(Reflect.get(member, "id")),
       args.document.classes
@@ -90326,15 +90580,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: (id2) => {
-        lookups ??= initializerEvaluatorLookups(
-          args.document,
-          args.readTracking
-        );
-        return (lookups.defaultValueById ?? lookups.valueById)(id2);
+        args.readTracking?.valueIds.add(id2);
+        const database = evaluatorLookups();
+        return database.defaultValueById !== void 0 ? database.defaultValueById(id2) : database.valueById(id2);
+      },
+      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 id2 of reads.valueIds) args.readTracking?.valueIds.add(id2);
+        for (const id2 of reads.containerIds)
+          args.readTracking?.containerIds.add(id2);
       }
     },
     projectId: args.envelope.projectId,
@@ -90385,11 +90662,10 @@ function materializeMemberDefaultValue(args) {
   });
   return { root, createdValues: interior, pinnedRootSchemaKeys: /* @__PURE__ */ new Set() };
 }
-var declarationInitializerContextByDocument;
+var declarationInitializerContextByDocument, defaultValuePlansByDocument;
 var init_initializer_materialization = __esm({
   "../packages/neoscript-runtime/src/initializer-materialization.ts"() {
     "use strict";
-    init_unattributable_reads();
     init_deep_clone_plain_data();
     init_members();
     init_inheritance();
@@ -90400,6 +90676,7 @@ var init_initializer_materialization = __esm({
     init_value_row_owner_members();
     init_initializer_identifiers();
     declarationInitializerContextByDocument = /* @__PURE__ */ new WeakMap();
+    defaultValuePlansByDocument = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -90415,7 +90692,13 @@ function rootReadScope(document) {
   );
   const created = scope.document === document ? scope : {
     ...scope,
-    document: { ...scope.document, evaluatorCache: void 0 }
+    // Packed rows expand into new rows: the base's caches and world
+    // index slot describe the document before expansion.
+    document: {
+      ...scope.document,
+      evaluatorCache: void 0,
+      worldQueryCache: void 0
+    }
   };
   rootReadScopes.set(document, {
     members: document.members,
@@ -90799,6 +91082,8 @@ var init_effective_value_reader = __esm({
           ...baseDocument,
           databaseVM: void 0,
           evaluatorCache: void 0,
+          // The base's world index slot covers the base rows, not these.
+          worldQueryCache: void 0,
           evaluatorOverlay: {
             containerMembership: this.context.containerMembership,
             base: baseDocument,
@@ -92831,10 +93116,16 @@ function isEvaluatedOnlyExpression(expression) {
     case "unary":
       if (expression.op !== "-") return true;
       return isEvaluatedOnlyExpression(expression.operand);
+    case "member":
+      return !isNamePath(expression.receiver);
     default:
       return false;
   }
 }
+function isNamePath(expression) {
+  if (expression.kind === "ident") return true;
+  return expression.kind === "member" && isNamePath(expression.receiver);
+}
 function isLiteralCall(expression) {
   if (expression.callee.kind === "ident" && expression.callee.name === "Reference") {
     return true;
@@ -95569,6 +95860,21 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
   if (expected.name === NEO_VARIANT_TYPE_NAME || expected.name === NEO_LOOKUP_VARIANT_TYPE_NAME) {
     return lowerVariantDefault(context, expression, expected, path);
   }
+  const enumName = expected.name === "List" ? expected.arguments[0]?.name ?? expected.name : expected.name;
+  const enumId = context.enumIdsByName.get(enumName);
+  if (enumId !== void 0 && (expression.kind === "contextualEnum" || expression.kind === "member")) {
+    const optionName = enumOptionSpelling(expression, enumName, path);
+    if (optionName === null) {
+      throw new Error(`${path} requires .Option or ${enumName}.Option values.`);
+    }
+    const optionId = context.enumOptionsByName.get(enumId)?.get(optionName);
+    if (optionId === void 0) {
+      throw new Error(
+        `Enum ${enumName} has no option ${JSON.stringify(optionName)}.`
+      );
+    }
+    return optionId;
+  }
   switch (expression.kind) {
     case "litNull":
       if (!expected.nullable) {
@@ -95602,19 +95908,8 @@ function lowerExpressionValue(context, expression, declaredExpected, ownerClass,
       }
       throw new Error("Unary minus requires a numeric persisted default.");
     }
-    case "contextualEnum": {
-      const enumId = context.enumIdsByName.get(expected.name) ?? (expected.name === "List" ? context.enumIdsByName.get(expected.arguments[0]?.name ?? "") : void 0);
-      if (!enumId) {
-        throw new Error(`Cannot infer enum case .${expression.name}.`);
-      }
-      const optionId = context.enumOptionsByName.get(enumId)?.get(expression.name);
-      if (!optionId) {
-        throw new Error(
-          `Enum has no option ${JSON.stringify(expression.name)}.`
-        );
-      }
-      return optionId;
-    }
+    case "contextualEnum":
+      throw new Error(`Cannot infer enum case .${expression.name}.`);
     case "litList": {
       const entry = expected.arguments[0] ?? expected;
       return expression.elements.map(
@@ -98333,7 +98628,17 @@ function referenceTargetType(context, member, enclosingClassId) {
   );
 }
 function renderNestedValue(context, member, value, enclosingClassId) {
-  if (typeof value === "string" && member.kind !== "string" && member.kind !== "decimal" && member.kind !== "enum") {
+  if (typeof value === "string" && member.kind !== "string" && member.kind !== "decimal") {
+    if (member.kind === "enum") {
+      const option = required(
+        context.enums,
+        member.enumId,
+        "enum"
+      ).options.find(
+        (candidate) => candidate.id === value || candidate.key === value
+      );
+      if (option !== void 0) return `.${option.name}`;
+    }
     return `Reference<${referenceTargetType(context, member, enclosingClassId)}>(id: ${quote(value)})`;
   }
   return renderDefaultValue(
@@ -109368,6 +109673,129 @@ var init_project_commit_preparation_scoped_loader = __esm({
   }
 });
 
+// ../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 id2 = v5_default(
+      `neo:compiled-construction-type:${projectId}:${signature}`,
+      v5_default.URL
+    );
+    existingIds ??= new Set(members.map((member) => member.id));
+    if (existingIds.has(id2)) {
+      byType.set(signature, id2);
+      return id2;
+    }
+    const common = {
+      id: id2,
+      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 [parameter4, argument2] of Object.entries(
+          type.typeArguments ?? {}
+        )) {
+          const memberId = intern(argument2);
+          if (memberId === null) return null;
+          classArguments2[parameter4] = {
+            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(id2);
+    byType.set(signature, id2);
+    return id2;
+  };
+  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 child2 of Object.values(value)) visit(child2);
+  };
+  for (const body of bodies) visit(body);
+  return created;
+}
+function withCompiledConstructionTypes(document, body) {
+  const members = document.members;
+  const projectId = getField(document.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 ? document : { ...document, members: [...members, ...created] };
+}
+var init_compiled_construction_types = __esm({
+  "../src/database/compiled-construction-types.ts"() {
+    "use strict";
+    init_dist_node();
+    init_core();
+    init_neoscript_guards();
+    init_neoscript();
+    init_project_content_hash();
+  }
+});
+
 // ../src/database/lookup-target-class-contract.ts
 function lookupTargetClassContractViolation(args) {
   const actualClassId = typeof args.targetClassId === "string" ? args.targetClassId : null;
@@ -112474,11 +112902,7 @@ function appendAuthoredOwnedValueCascadeDeletes(args) {
         authoredPost,
         new Set(replayCandidates.keys())
       );
-      if (authoredCandidateIds.size > 0) {
-        args.earlyDelegateCompilation.contractHash = hashCanonicalJson(
-          neoScriptCompilationProjectContract(authoredPost)
-        );
-      }
+      let contractHash;
       for (const [id2, row] of replayCandidates) {
         let compiled = row;
         const closure = delegateValueRow(compiled);
@@ -112495,6 +112919,9 @@ function appendAuthoredOwnedValueCascadeDeletes(args) {
           args.earlyDelegateCompilation.rows.set(id2, {
             source: row,
             compiled,
+            contractHash: contractHash ??= hashCanonicalJson(
+              neoScriptCompilationProjectContract(authoredPost)
+            ),
             ...compiler.ownershipIds(id2)
           });
         }
@@ -112707,7 +113134,6 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     }).map(cloneAndStripClientDerivedBodies)
   });
   const earlyDelegateCompilation = {
-    contractHash: null,
     rows: /* @__PURE__ */ new Map()
   };
   let authoredPost = appendAuthoredOwnedValueCascadeDeletes({
@@ -113034,6 +113460,27 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     targetIds: recompileTargets.constructorIds,
     contentHashHeads: args.contentHashHeads
   });
+  const constructionTypeMembers = [...sourceMembers];
+  const appendConstructionTypes = () => {
+    const created = compiledConstructionTypeMembers(
+      constructionTypeMembers,
+      prepared.map((change) => change.nextData),
+      args.document.project.id
+    );
+    constructionTypeMembers.push(...created);
+    const changes = created.map((member) => ({
+      recordKind: "member",
+      recordId: member.id,
+      operation: "create",
+      nextData: member,
+      intent: createProjectVersionIntent("member.create", {
+        source: "compiled-construction-type"
+      })
+    }));
+    prepared.push(...changes);
+    return changes;
+  };
+  appendConstructionTypes();
   const postDocument = applyProjectVersionWriteChanges(args.document, prepared);
   const listIndexErrors = validateDocumentListIndexes({
     members: postDocument.members,
@@ -113074,6 +113521,7 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     recompileTargets,
     contentHashHeads: args.contentHashHeads
   });
+  appendConstructionTypes();
   args.passLifecycle?.("complete", "neo-script-recompile-targets");
   yield {
     pass: "neo-script-recompile-targets",
@@ -113099,6 +113547,7 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     targetIds: recompileTargets.valueIds,
     contentHashHeads: args.contentHashHeads
   });
+  appendConstructionTypes();
   args.passLifecycle?.("complete", "authored-value-seeds");
   yield { pass: "authored-value-seeds", preparedChanges: prepared };
   args.passLifecycle?.("start", "variant-child-override-binding-members");
@@ -113113,6 +113562,12 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     preparedChanges: prepared
   };
   args.passLifecycle?.("start", "prepared-instance-initializers");
+  compileInitializerReadableDelegateRows({
+    document: args.document,
+    prepared,
+    earlyDelegateCompilation,
+    appendConstructionTypes
+  });
   materializePreparedInstanceInitializers({
     document: args.document,
     prepared,
@@ -113143,6 +113598,7 @@ function* prepareServerOwnedSchemaCommitPasses(args) {
     physicalValues: args.document.physicalValues,
     earlyDelegateCompilation
   });
+  appendConstructionTypes();
   args.passLifecycle?.("complete", "delegate-value-bodies");
   yield { pass: "delegate-value-bodies", preparedChanges: prepared };
   args.passLifecycle?.("start", "variant-constructor-args");
@@ -115197,6 +115653,8 @@ function commitInitEvaluator(document, createdValues) {
 function hasAuthoredNeoScriptBody(member) {
   if (member.kind === 10 /* NSProperty */) return true;
   if (member.kind === 23 /* NSFunction */) return true;
+  if (isMemberDelegateBase(member) && isLiteralValueContent(member.defaultValue) && (isNSDelegateClosureValueDraft(member.defaultValue.value) || isNSDelegateClosureValue(member.defaultValue.value)))
+    return true;
   return isInitValueContent(member.defaultValue);
 }
 function touchedInitializerFilter(prepared) {
@@ -115731,6 +116189,7 @@ function compileInlineDelegateConstructorArguments(args) {
         returnTypeInfo: substituted.returnTypeInfo,
         argumentTypes: substituted.argumentTypes,
         name: `${settledMember.name} argument`,
+        staticMember: rootOwner !== void 0 && isStaticMember(rootOwner),
         compilationProject: args.compilationProject
       });
     } catch (error) {
@@ -115775,8 +116234,9 @@ function carriesValueBody(content) {
   if (isNSDelegateClosureValue(value)) return true;
   return carriesUncompiledInlineDelegateArgument(content);
 }
-function assertValueBodiesCompile(args) {
-  if (args.valueIds.size === 0) return;
+function compileValueBodies(args) {
+  const closures = [];
+  if (args.valueIds.size === 0) return closures;
   const { scope } = args;
   const compiler = createDelegateValueBodyCompiler(
     scope.document,
@@ -115787,7 +116247,7 @@ function assertValueBodiesCompile(args) {
     const value = scope.valuesById.get(id2);
     if (value === void 0) continue;
     const closure = delegateValueRow(value);
-    if (closure !== null) compiler.compileClosure(closure);
+    if (closure !== null) closures.push(compiler.compileClosure(closure));
     const inline = inlineDelegateArgumentRow(value);
     if (inline !== null) compiler.compileInline(inline);
     const init = initBackedValueRow(value);
@@ -115801,6 +116261,7 @@ function assertValueBodiesCompile(args) {
       valuesById: scope.valuesById
     });
   }
+  return closures;
 }
 function createDelegateValueBodyCompiler(postDocument, targetIds, prepared) {
   const scope = prepared ?? delegateValueBodyOwnership(postDocument, targetIds);
@@ -115845,6 +116306,7 @@ function createDelegateValueBodyCompiler(postDocument, targetIds, prepared) {
         returnTypeInfo: member.returnTypeInfo,
         argumentTypes: member.argumentTypes,
         name: `${member.name} value`,
+        staticMember: rootOwner !== void 0 && isStaticMember(rootOwner),
         compilationProject: compilationProjectFor(document)
       });
     } catch (error) {
@@ -115870,7 +116332,8 @@ function createDelegateValueBodyCompiler(postDocument, targetIds, prepared) {
     ownerMemberId: getOptionalString(ownerByValueId.get(valueId), "id") ?? null,
     rootOwnerId: rootOwnerByValueId.get(valueId)?.id ?? null
   });
-  return { compileClosure, compileInline, ownershipIds };
+  const ownsClosure = (valueId) => isMemberDelegateBase(ownerByValueId.get(valueId));
+  return { compileClosure, compileInline, ownershipIds, ownsClosure };
 }
 function delegateValueBodyOwnership(postDocument, targetIds) {
   const scope = withVariantOwnershipRoots(
@@ -115886,6 +116349,57 @@ function delegateValueBodyOwnership(postDocument, targetIds) {
   );
   return { document: scope.document, ownerByValueId, rootOwnerByValueId };
 }
+function compileInitializerReadableDelegateRows(args) {
+  const rows = /* @__PURE__ */ new Map();
+  let replaysInitializer = false;
+  for (let index = 0; index < args.prepared.length; index += 1) {
+    const change = args.prepared[index];
+    if (change?.recordKind !== "value" || change.operation === "delete") {
+      continue;
+    }
+    if (isMemberValue(change.nextData) && isInitValueContent(change.nextData)) {
+      replaysInitializer = true;
+    }
+    const row = delegateValueRow(change.nextData);
+    if (row !== null && isNSDelegateClosureValueDraft(row.value)) {
+      rows.set(index, row);
+    }
+  }
+  if (!replaysInitializer || rows.size === 0) return;
+  const postDocument = applyProjectVersionWriteChanges(
+    args.document,
+    args.prepared
+  );
+  const compiler = createDelegateValueBodyCompiler(
+    postDocument,
+    new Set(Array.from(rows.values(), (row) => row.id))
+  );
+  const compiled = [];
+  for (const [index, row] of rows) {
+    if (!compiler.ownsClosure(row.id)) continue;
+    const next = compiler.compileClosure(row);
+    args.prepared[index] = { ...args.prepared[index], nextData: next };
+    compiled.push({ row: next, ...compiler.ownershipIds(row.id) });
+  }
+  if (compiled.length === 0) return;
+  const contractHash = hashCanonicalJson(
+    neoScriptCompilationProjectContract(
+      projectVersionDocumentWithChanges(
+        postDocument,
+        args.appendConstructionTypes(),
+        true
+      )
+    )
+  );
+  for (const { row, ...ownership } of compiled) {
+    args.earlyDelegateCompilation.rows.set(row.id, {
+      source: row,
+      compiled: row,
+      contractHash,
+      ...ownership
+    });
+  }
+}
 function prepareServerOwnedDelegateValueBodies(args) {
   const explicitRows = /* @__PURE__ */ new Map();
   const inlineArgumentRows = /* @__PURE__ */ new Map();
@@ -115916,11 +116430,13 @@ function prepareServerOwnedDelegateValueBodies(args) {
     targetIds
   );
   const early = args.earlyDelegateCompilation;
-  const sameCompilerContract = early.rows.size > 0 && early.contractHash === hashCanonicalJson(neoScriptCompilationProjectContract(committedDocument));
+  const contractHash = early.rows.size === 0 ? null : hashCanonicalJson(
+    neoScriptCompilationProjectContract(committedDocument)
+  );
   const reusableEarlyRow = (row) => {
-    if (!sameCompilerContract) return null;
     const candidate = early.rows.get(row.id);
     if (candidate?.source !== row) return null;
+    if (candidate.contractHash !== contractHash) return null;
     const ownership = compiler.ownershipIds(row.id);
     return ownership.ownerMemberId === candidate.ownerMemberId && ownership.rootOwnerId === candidate.rootOwnerId ? candidate.compiled : null;
   };
@@ -116436,6 +116952,7 @@ var SERVER_COMPILATION_PROJECT_CACHE_LIMIT, serverCompilationProjectCache, SCHEM
 var init_project_version_schema_commit = __esm({
   "../src/database/project-version-schema-commit.ts"() {
     "use strict";
+    init_compiled_construction_types();
     init_member_kinds();
     init_project_schema_index();
     init_lookup_target_class_contract();
@@ -125140,6 +125657,7 @@ function compilePulledUncompiledConstructorsV4(document, compilationProject, rep
   assertPulledConstructorsCompiled(document, replayContext);
 }
 function compilePulledProjectDocumentForEvaluationV4(document, compilationProject, targets) {
+  const compiled = [];
   const sharedCompilationProject = compilationProject ?? createNeoScriptCompilationProject({
     project: document.project,
     projectFiles: document.projectFiles,
@@ -125172,6 +125690,7 @@ function compilePulledProjectDocumentForEvaluationV4(document, compilationProjec
         `constructor:${constructor2.id}`
       )
     });
+    compiled.push(constructor2);
   }
   assertPulledConstructorsCompiled(document);
   const memberIndex = documentMemberCompilationIndex(document);
@@ -125185,6 +125704,7 @@ function compilePulledProjectDocumentForEvaluationV4(document, compilationProjec
         scriptSources: targets?.scriptSources?.get(`member:${member.id}`),
         thisClass: memberIndex.ownerClassesByMemberId.get(member.id) ?? null
       });
+      compiled.push(member);
     } catch (error) {
       if (error instanceof CompileError) {
         pulledBodyCompileSites.set(error, {
@@ -125195,6 +125715,7 @@ function compilePulledProjectDocumentForEvaluationV4(document, compilationProjec
       throw error;
     }
   }
+  return compiled;
 }
 function assertPulledConstructorsCompiled(document, replayContext) {
   if (replayContext !== void 0 && replayContext.document !== document) {
@@ -127682,7 +128203,7 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest, options = {}) {
       );
       const baseData3 = stateData(context, "member", memberId);
       const annotatedExpression = annotatedValue(expression).expression;
-      if (requiresEvaluation)
+      if (requiresEvaluation || member.kind === "delegate" && annotatedExpression.kind === "lambda")
         context.initializerSites.set(
           memberId,
           referenceSite(binding, annotatedExpression)
@@ -136261,13 +136782,15 @@ function materializeInitializersLocallyV4(args) {
       written.push({
         recordKind: "value",
         recordId: seed.valueId,
-        operation: "create"
+        operation: "create",
+        nextData: records3.get(`value:${seed.valueId}`)?.data
       });
     for (const row of seed.values ?? [])
       written.push({
         recordKind: "value",
         recordId: row.id,
-        operation: "create"
+        operation: "create",
+        nextData: records3.get(`value:${row.id}`)?.data
       });
   }
   const touched = touchedInitializerFilter(written);
@@ -136277,9 +136800,16 @@ function materializeInitializersLocallyV4(args) {
       return touched.touches("value", change.recordId, data);
     return change.recordKind === "member" && isObjectRecord2(data) && touched.touches("member", change.recordId, data.defaultValue);
   });
-  const valueBodyIds = writtenValueBodyIds(args.changes);
+  const valueBodyIds = writtenValueBodyIds(written);
   const compilesValueBodies = valueBodyIds.size > 0;
-  if (sourceRoots.size === 0 && !validatesTouched && !compilesValueBodies)
+  const compilesDelegateDefaults = written.some((change) => {
+    if (change.recordKind !== "member" || change.operation === "delete")
+      return false;
+    const data = records3.get(`member:${change.recordId}`)?.data;
+    const defaultValue = getField(data, "defaultValue");
+    return isLiteralValueContent(defaultValue) && isNSDelegateClosureValueDraft(defaultValue.value);
+  });
+  if (sourceRoots.size === 0 && !validatesTouched && !compilesValueBodies && !compilesDelegateDefaults)
     return { roots: [] };
   const pulledDocument = readPulledProjectDocumentV4(records3);
   const variantScope = withVariantOwnershipRoots(
@@ -136303,7 +136833,7 @@ function materializeInitializersLocallyV4(args) {
   const pendingRoots = new Set(
     [...sourceRoots].filter((id2) => rootKinds.get(id2) !== "declaration").sort()
   );
-  if (pendingRoots.size === 0 && !validatesTouched && !compilesValueBodies)
+  if (pendingRoots.size === 0 && !validatesTouched && !compilesValueBodies && !compilesDelegateDefaults)
     return { roots };
   const replayedRoots = new Set(pendingRoots);
   const compilationProject = createNeoScriptCompilationProject(authoredDocument);
@@ -136339,7 +136869,7 @@ function materializeInitializersLocallyV4(args) {
       changedBodies.constructorIds.add(id2);
     }
   }
-  compilePulledProjectDocumentForEvaluationV4(
+  const compiledBodies = compilePulledProjectDocumentForEvaluationV4(
     authoredDocument,
     compilationProject,
     changedBodies
@@ -136347,11 +136877,11 @@ function materializeInitializersLocallyV4(args) {
   assertPulledConstructorsCompiled(authoredDocument);
   const compiledBodyIds = new Set(valueBodyIds);
   for (const id2 of replayedRoots) compiledBodyIds.delete(id2);
-  const batch = createInitializerMaterializationBatch(
+  let batch = createInitializerMaterializationBatch(
     authoredDocument,
     pendingRoots
   );
-  assertValueBodiesCompile({
+  const compiledClosures = compileValueBodies({
     scope: {
       document: authoredDocument,
       compilationProject,
@@ -136363,10 +136893,40 @@ function materializeInitializersLocallyV4(args) {
     valueIds: compiledBodyIds
   });
   const compiledInitializers = /* @__PURE__ */ new Map();
+  const templateContext = createPulledConstructionReplayContext({
+    document: authoredDocument,
+    valuesById: batch.valuesById
+  });
+  for (const id2 of pendingRoots) {
+    replayStoredConstructionV4({
+      records: records3,
+      document: authoredDocument,
+      valueId: id2,
+      code: initializerCode(records3, id2),
+      compilationProject,
+      replayContext: templateContext,
+      member: rootOwners.get(id2),
+      evaluate: false,
+      onCompiledInitializer: (init) => compiledInitializers.set(id2, init)
+    });
+  }
+  const typeMembers = compiledConstructionTypeMembers(
+    authoredDocument.members,
+    [compiledBodies, compiledClosures, [...compiledInitializers.values()]],
+    authoredDocument.project.id
+  );
+  const replayDocument = typeMembers.length === 0 ? authoredDocument : {
+    ...authoredDocument,
+    members: [...authoredDocument.members, ...typeMembers]
+  };
+  if (replayDocument !== authoredDocument) {
+    batch = createInitializerMaterializationBatch(replayDocument, pendingRoots);
+  }
+  batch.upsert(compiledClosures);
   materializeInitializerDependencies(pendingRoots, (sourceValueId) => {
     const batchDocument = batch.document();
     const document = {
-      ...authoredDocument,
+      ...replayDocument,
       values: batchDocument.values,
       databaseVM: batchDocument.databaseVM
     };
@@ -136490,6 +137050,7 @@ function materializeInitializersLocallyV4(args) {
     const batchDocument = batch.document();
     const document = {
       ...pulledDocument,
+      members: [...pulledDocument.members, ...typeMembers],
       values: batchDocument.values,
       databaseVM: batchDocument.databaseVM
     };
@@ -136649,6 +137210,7 @@ var init_local_initializer_materialization = __esm({
     init_constructor_argument_ownership();
     init_neo_script_recompile_scope();
     init_compiler_adapter();
+    init_compiled_construction_types();
     init_project_version_schema_commit();
     init_value_row_owner_members();
     init_variant_value_graph();
@@ -142492,12 +143054,33 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
         diagnostic2.range,
         diagnostic2.relatedInformation
       );
-      if (positioned.severity === "error") parseErrors.push(positioned);
-      else parseWarnings.push(positioned);
+      if (positioned.severity === "error") {
+        parseErrors.push(positioned);
+        const errors = errorsByUri.get(diagnostic2.uri) ?? [];
+        errors.push(diagnostic2);
+        errorsByUri.set(diagnostic2.uri, errors);
+      } else parseWarnings.push(positioned);
     }
+    const nextErrorByUri = /* @__PURE__ */ new Map();
+    for (const errors of errorsByUri.values()) {
+      errors.sort(
+        (left, right) => positionCompare(left.range.start, right.range.start)
+      );
+    }
+    const invalidLocal = analysis.values.globals.some(({ source }) => {
+      const errors = errorsByUri.get(source.uri);
+      if (errors === void 0) return false;
+      let index = nextErrorByUri.get(source.uri) ?? 0;
+      while (index < errors.length && positionCompare(errors[index].range.start, source.range.start) < 0) {
+        index++;
+      }
+      nextErrorByUri.set(source.uri, index);
+      const error = errors[index];
+      return error !== void 0 && sourceRangeContains(source.range, error.range.start);
+    });
     if (analysis.diagnostics.some(
       (diagnostic2) => diagnostic2.severity === "error" && (diagnostic2.code === "duplicate-project-id" || diagnostic2.code === "invalid-project-global-initializer" || diagnostic2.code === "local-initializer-use" || diagnostic2.code === "local-initializer-cycle")
-    )) {
+    ) || invalidLocal) {
       return refusedStatus(conflictedFiles, parseErrors, parseWarnings);
     }
     const rootDeclaration = analysis.configuration.globals.find(
@@ -142529,12 +143112,6 @@ function computeStatus(workspace, options, conflictedFiles, parseErrors, parseWa
       );
     }
     const diagnostic = sourceDiagnosticMapper(analysis);
-    for (const error of analysis.diagnostics) {
-      if (error.severity !== "error") continue;
-      const errors = errorsByUri.get(error.uri) ?? [];
-      errors.push(error);
-      errorsByUri.set(error.uri, errors);
-    }
     const validAnalysis = {
       ...analysis,
       configuration: {
@@ -144638,6 +145215,7 @@ var ANIMATION_DOCUMENT_RECORD_KINDS, ANIMATION_REPLAY_RECORD_KINDS, PROSPECTIVE_
 var init_workspace_status_core = __esm({
   "src/project-source/workspace-status-core.ts"() {
     "use strict";
+    init_project_source_tokens();
     init_project_root();
     init_source_text();
     init_dialogue_body_validation();
@@ -148192,7 +148770,7 @@ function complete(snapshot, position) {
     candidates = switchCaseCandidates;
   } else if (tail && (tail.kind === "punctuation" && tail.text === "." || tail.kind === "operator" && tail.text === "?.")) {
     const receiverTokens = expressionTokensBefore(tokens, tokens.length - 1);
-    if (receiverTokens.length === 0 || isContextualCompletionDot(snapshot.source.text, word.start)) {
+    if (receiverTokens.length === 0 || isContextualCompletionDot(snapshot, word.start)) {
       candidates = contextualEnumCompletionItems(
         snapshot,
         expectedTypeAt(snapshot, word.start),
@@ -148878,19 +149456,16 @@ function contextualEnumCompletionItems(snapshot, expected, word) {
     };
   });
 }
-function isContextualCompletionDot(text, wordStart) {
-  if (text[wordStart - 1] !== ".") return false;
-  let cursor = wordStart - 2;
-  while (cursor >= 0 && /\s/.test(text[cursor] ?? "")) cursor--;
-  const beforeDot = text[cursor];
-  if (beforeDot !== void 0 && /[A-Za-z0-9_]/.test(beforeDot)) {
-    let start = cursor;
-    while (start > 0 && /[A-Za-z0-9_]/.test(text[start - 1] ?? "")) start--;
-    while (start < cursor && /[0-9]/.test(text[start] ?? "")) start++;
-    const precedingWord = text.slice(start, cursor + 1);
-    return precedingWord === "return" || precedingWord === "case";
-  }
-  return beforeDot === void 0 || !/[A-Za-z0-9_\])}]/.test(beforeDot);
+function isContextualCompletionDot(snapshot, wordStart) {
+  const { tokens } = scriptFeatureIndex(snapshot);
+  const dot = firstIndex(tokens, (token) => token.start >= wordStart) - 1;
+  if (tokens[dot]?.text !== ".") return false;
+  const previous = tokens[dot - 1];
+  if (!previous) return true;
+  if (previous.kind === "keyword")
+    return previous.text === "return" || previous.text === "case";
+  if (previous.kind === "operator") return previous.text !== "!";
+  return previous.kind === "punctuation" && ![")", "]", "}"].includes(previous.text);
 }
 function resolvedCallArgumentAt(snapshot, offset, body = lambdaBodyAt(snapshot, offset)) {
   const argument2 = callArgumentAt(snapshot, offset, body);
@@ -148909,17 +149484,32 @@ function expectedTypeAt(snapshot, offset, body = lambdaBodyAt(snapshot, offset),
   offset,
   body
 )) {
-  const initializer = initializerExpectedType(snapshot, offset);
+  const initializer = initializerExpectedType(
+    snapshot,
+    offset,
+    body?.start ?? 0
+  );
   if (initializer !== void 0) return initializer;
   const features = scriptFeatureIndex(snapshot);
   if (argument2 && !isCollectionOpener(features, innermostOpener(features, offset))) {
     const { call, index, symbol } = argument2;
-    const parameterType = call.kind === "constructor" ? constructorParameterTypeAt(
-      constructionType(snapshot, call),
-      call,
-      index,
-      snapshot
-    ) : boundParameter(symbol?.parameters ?? [], call, index)?.type;
+    let parameterType;
+    if (call.kind === "constructor") {
+      parameterType = constructorParameterTypeAt(
+        constructionType(snapshot, call),
+        call,
+        index,
+        snapshot
+      ) ?? void 0;
+    } else if (symbol?.type.kind === "delegate" && !symbol.returnType) {
+      parameterType = symbol.type.parameterTypes[index];
+    } else {
+      parameterType = boundParameter(
+        symbol?.parameters ?? [],
+        call,
+        index
+      )?.type;
+    }
     if (parameterType) {
       return expectedCollectionElementType(
         parameterType,
@@ -148996,8 +149586,25 @@ function expectedTypeAt(snapshot, offset, body = lambdaBodyAt(snapshot, offset),
   }
   const throwToken = tokens.slice(boundary + 1).find((token) => token.kind === "keyword" && token.text === "throw");
   if (throwToken) return { kind: "primitive", name: "string" };
-  if (body) return null;
   const returnToken = tokens.slice(boundary + 1).find((token) => token.kind === "keyword" && token.text === "return");
+  if (body) {
+    const bodyIndex = firstIndex(
+      features.tokens,
+      (token) => token.end >= body.start
+    );
+    const block = features.tokens[bodyIndex]?.text === "{";
+    if (block && !returnToken) return null;
+    const arrow = features.tokens[block ? bodyIndex - 1 : bodyIndex];
+    if (arrow?.text !== "=>") return null;
+    const delegate = expectedTypeAt(snapshot, arrow.start);
+    if (delegate?.kind !== "delegate") return null;
+    return expectedCollectionElementType(
+      delegate.returnType,
+      tokens,
+      returnToken?.end ?? body.start,
+      offset
+    );
+  }
   if (returnToken && snapshot.context.returnType) {
     return expectedCollectionElementType(
       snapshot.context.returnType,
@@ -149145,12 +149752,13 @@ function initializerConstruction(snapshot, brace, constructor2) {
   }
   return construction;
 }
-function initializerExpectedType(snapshot, offset) {
+function initializerExpectedType(snapshot, offset, bodyStart) {
   const features = scriptFeatureIndex(snapshot);
   const { tokens, enclosingOpener, callOpenings, objectInitializers } = features;
   let brace = innermostOpener(features, offset);
   for (; brace >= 0; brace = enclosingOpener[brace]) {
     const opener = tokens[brace];
+    if (opener.start < bodyStart) return void 0;
     if (opener.text === "{") break;
     if (opener.text === "(" && callOpenings.has(opener.start)) return void 0;
   }
@@ -149644,10 +150252,7 @@ function resolveReference(snapshot, reference2) {
   return receiver ? resolveMemberOf(snapshot, reference2, receiver) : null;
 }
 function resolveMemberReceiver(snapshot, reference2) {
-  const expectedEnum = isContextualCompletionDot(
-    snapshot.source.text,
-    reference2.start
-  ) ? expectedEnumTypeAt(snapshot, reference2.start) : null;
+  const expectedEnum = isContextualCompletionDot(snapshot, reference2.start) ? expectedEnumTypeAt(snapshot, reference2.start) : null;
   if (expectedEnum && enumMemberNamed(expectedEnum, reference2.name))
     return { kind: "enum", type: expectedEnum };
   const index = scriptFeatureIndex(snapshot);
@@ -149770,8 +150375,9 @@ function switchCaseEnumContext(snapshot, offset) {
   }
   return null;
 }
-function resolveChain(snapshot, tokens, offset) {
+function resolveChain(snapshot, tokens, offset, expectedType) {
   if (tokens.length === 0) return null;
+  const contextualConstructor = tokens[0]?.text === NEOSCRIPT_CONSTRUCTOR_KEYWORD && tokens[1]?.text === "(" && expectedType?.kind === "named" ? snapshot.project.typeById.get(expectedType.typeId) : void 0;
   const constructorType = tokens[0]?.kind === "identifier" && tokens[0].text === NEOSCRIPT_CONSTRUCTOR_KEYWORD && tokens[1]?.kind === "identifier" ? snapshot.project.typeByName.get(tokens[1].text) : void 0;
   const staticRoot = tokens[0]?.kind === "type" ? snapshot.project.typeByName.get(tokens[0].text) : void 0;
   let current;
@@ -149789,11 +150395,11 @@ function resolveChain(snapshot, tokens, offset) {
       staticType: staticRoot
     };
     cursor = 1;
-  } else if (constructorType?.constructorSignature) {
+  } else if (contextualConstructor || constructorType?.constructorSignature) {
     current = {
-      type: constructedTypeRef(snapshot, constructorType, tokens, 1)
+      type: contextualConstructor ? expectedType : constructedTypeRef(snapshot, constructorType, tokens, 1)
     };
-    cursor = new Parser(tokens, 1).typeEnd();
+    cursor = contextualConstructor ? 1 : new Parser(tokens, 1).typeEnd();
     if (cursor < 0) return current;
     if (tokens[cursor]?.text === "(") {
       const close = findClosingToken(tokens, cursor, "(", ")");
@@ -149849,7 +150455,8 @@ function resolveChain(snapshot, tokens, offset) {
     }
     if (token.kind === "punctuation" && token.text === "(") {
       const close = findClosingToken(tokens, cursor, "(", ")");
-      const fallbackType = current.symbol?.returnType ?? current.type;
+      const valueReturnType = current.type.kind === "delegate" ? current.type.returnType : current.type;
+      const fallbackType = current.symbol?.returnType ?? valueReturnType;
       const callType = (current.symbol?.name === "Select" || current.symbol?.name === "SelectMany") && close >= 0 ? inferSelectResultType(
         tokens.slice(cursor + 1, close),
         snapshot,
@@ -150263,30 +150870,77 @@ function inferLocalType(local, snapshot) {
   }
   return UNKNOWN_TYPE;
 }
-function inferExpressionType2(rawTokens, snapshot, offset) {
+function inferExpressionType2(rawTokens, snapshot, offset, expectedType) {
   const tokens = unwrapExpressionTokens(rawTokens);
   const first = tokens[0];
   if (!first) return UNKNOWN_TYPE;
+  const question = topLevelTokenIndex(tokens, (token) => token.text === "?");
+  if (question > 0) {
+    const branches = tokens.slice(question + 1);
+    let nested = 0;
+    const colon = topLevelTokenIndex(branches, (token) => {
+      if (token.text === "?") nested++;
+      if (token.text !== ":") return false;
+      return nested-- === 0;
+    });
+    if (colon < 0) return UNKNOWN_TYPE;
+    const whenTrue = unwrapExpressionTokens(branches.slice(0, colon));
+    const whenFalse = unwrapExpressionTokens(branches.slice(colon + 1));
+    const inferFalseFirst = whenTrue[0]?.text === "null" || whenTrue[0]?.text === ".";
+    let left;
+    let right;
+    if (inferFalseFirst && !expectedType) {
+      right = inferExpressionType2(whenFalse, snapshot, offset);
+      left = inferExpressionType2(whenTrue, snapshot, offset, right);
+    } else {
+      left = inferExpressionType2(whenTrue, snapshot, offset, expectedType);
+      right = inferExpressionType2(
+        whenFalse,
+        snapshot,
+        offset,
+        expectedType ?? left
+      );
+    }
+    return commonNeoScriptAssignableType(left, right, snapshot.project) ?? UNKNOWN_TYPE;
+  }
   if (first.kind === "string") {
     return { kind: "primitive", name: "string" };
   }
-  if (first.kind === "keyword" && first.text === "null") return UNKNOWN_TYPE;
+  if (first.kind === "keyword" && first.text === "null") {
+    return expectedType ? withNullability(expectedType, true) : UNKNOWN_TYPE;
+  }
+  if (first.text === "." && expectedType?.kind === "named") {
+    const type = snapshot.project.typeById.get(expectedType.typeId);
+    if (type?.kind === "enum" && tokens[1] && enumMemberNamed(type, tokens[1].text))
+      return expectedType;
+  }
   if (first.kind === "punctuation" && first.text === "[" && matchingDelimiterIndex(tokens, 0) === tokens.length - 1) {
     const entries = splitTopLevel2(tokens.slice(1, -1), ",");
-    if (entries.length === 0) return UNKNOWN_TYPE;
+    const expectedElement = expectedType?.kind === "list" ? expectedType.elementType : void 0;
+    if (entries.length === 0)
+      return expectedType?.kind === "list" ? expectedType : UNKNOWN_TYPE;
     const elementType = commonInferredType(
-      entries.map((entry) => inferExpressionType2(entry, snapshot, offset)),
+      entries.map(
+        (entry) => inferExpressionType2(entry, snapshot, offset, expectedElement)
+      ),
       snapshot.project
     );
     return elementType === UNKNOWN_TYPE ? UNKNOWN_TYPE : { kind: "list", elementType };
   }
   if (first.kind === "punctuation" && first.text === "{" && matchingDelimiterIndex(tokens, 0) === tokens.length - 1) {
     const entries = splitTopLevel2(tokens.slice(1, -1), ",");
-    if (entries.length === 0) return UNKNOWN_TYPE;
+    const expectedValue = expectedType?.kind === "dictionary" ? expectedType.valueType : void 0;
+    if (entries.length === 0)
+      return expectedType?.kind === "dictionary" ? expectedType : UNKNOWN_TYPE;
     const valueType = commonInferredType(
       entries.map((entry) => {
         const colon = topLevelTokenIndex(entry, (token) => token.text === ":");
-        return colon < 0 ? UNKNOWN_TYPE : inferExpressionType2(entry.slice(colon + 1), snapshot, offset);
+        return colon < 0 ? UNKNOWN_TYPE : inferExpressionType2(
+          entry.slice(colon + 1),
+          snapshot,
+          offset,
+          expectedValue
+        );
       }),
       snapshot.project
     );
@@ -150348,7 +151002,7 @@ function inferExpressionType2(rawTokens, snapshot, offset) {
   if (first.kind === "operator" && (first.text === "!" || first.text === "-")) {
     return first.text === "!" ? { kind: "primitive", name: "bool" } : inferExpressionType2(tokens.slice(1), snapshot, offset);
   }
-  return resolveChain(snapshot, tokens, offset)?.type ?? UNKNOWN_TYPE;
+  return resolveChain(snapshot, tokens, offset, expectedType)?.type ?? UNKNOWN_TYPE;
 }
 function unwrapExpressionTokens(tokens) {
   let result = tokens;
@@ -180139,8 +180793,9 @@ function createPostPushCompileContext(schema) {
   const classesById = /* @__PURE__ */ new Map();
   const ownersByMemberId = /* @__PURE__ */ new Map();
   for (const member of schema.members) {
-    if (typeof member.id !== "string") continue;
-    if (!membersById.has(member.id)) membersById.set(member.id, member);
+    const id2 = member.id;
+    if (typeof id2 !== "string") continue;
+    if (!membersById.has(id2)) membersById.set(id2, member);
   }
   for (const schemaClass2 of schema.classes) {
     if (typeof schemaClass2.id === "string" && !classesById.has(schemaClass2.id)) {
@@ -180166,7 +180821,6 @@ function createPostPushCompileContext(schema) {
   };
 }
 function containingClass(context, memberId) {
-  if (typeof memberId !== "string") return null;
   return context.ownersByMemberId.get(memberId) ?? null;
 }
 function bodyOwnerName(thisClass) {
@@ -180175,7 +180829,7 @@ function bodyOwnerName(thisClass) {
   return thisClass.name;
 }
 function compileNSPropertyChange(context, memberData, locator) {
-  const memberId = memberData.id;
+  const memberId = String(memberData.id);
   const thisClass = containingClass(context, memberId);
   const returnTypeInfo = resolveNSPropertyReturnTypeInfo2(
     memberData,
@@ -180183,7 +180837,7 @@ function compileNSPropertyChange(context, memberData, locator) {
   );
   const bodyIdentity = {
     recordKind: "member",
-    recordId: String(memberId),
+    recordId: memberId,
     ownerName: bodyOwnerName(thisClass),
     memberName: String(memberData.name ?? memberId)
   };
@@ -180194,7 +180848,7 @@ function compileNSPropertyChange(context, memberData, locator) {
       () => compileNSGetter2(code, {
         source: context.scriptSources.get(`member:${memberId}`)?.getter,
         ...context.project(),
-        memberId: String(memberData.id),
+        memberId,
         thisClass,
         returnTypeInfo,
         dialogueContext: null,
@@ -180213,7 +180867,7 @@ function compileNSPropertyChange(context, memberData, locator) {
       () => compileNSSetter2(setterCode, {
         source: context.scriptSources.get(`member:${memberId}`)?.setter,
         ...context.project(),
-        memberId: String(memberData.id),
+        memberId,
         thisClass,
         valueTypeInfo: returnTypeInfo,
         implicitMemberAccess: true,
@@ -180234,26 +180888,28 @@ function compileNSFunctionChange(context, memberData, locator) {
     return next;
   }
   const code = memberData.code;
+  const memberId = String(memberData.id);
+  const memberName = String(memberData.name ?? memberId);
   const contract = resolveNSFunctionContract(memberData, context.membersById);
-  const thisClass = containingClass(context, memberData.id);
+  const thisClass = containingClass(context, memberId);
   next.action = compileNeoScriptBodyOrThrow(
     () => compileNSFunction2(code, {
-      source: context.scriptSources.get(`member:${memberData.id}`)?.action,
+      source: context.scriptSources.get(`member:${memberId}`)?.action,
       ...context.project(),
-      memberId: String(memberData.id),
+      memberId,
       thisClass,
       returnTypeInfo: contract.returnTypeInfo,
       argumentTypes: contract.argumentTypes,
       deferred: contract.deferred,
-      functionName: String(memberData.name ?? memberData.id),
+      functionName: memberName,
       implicitMemberAccess: true,
       staticMember: memberData.modifier === 3
     }),
     {
       recordKind: "member",
-      recordId: String(memberData.id),
+      recordId: memberId,
       ownerName: bodyOwnerName(thisClass),
-      memberName: String(memberData.name ?? memberData.id),
+      memberName,
       unit: "function",
       code
     },
@@ -180313,17 +180969,18 @@ function prepareCompleteNeoScriptBodyChanges(workspace, status, schema, options
     ["constructor", schema.constructors]
   ]) {
     for (const row of records3) {
-      if (typeof row.id !== "string") continue;
-      if (!refreshSourceLocations && !changedSources.has(recordStateKey(kind, row.id)))
+      const id2 = row.id;
+      if (typeof id2 !== "string") continue;
+      if (!refreshSourceLocations && !changedSources.has(recordStateKey(kind, id2)))
         continue;
-      const owner = kind === "constructor" ? context.classesById.get(String(row.classId)) : context.ownersByMemberId.get(row.id);
+      const owner = kind === "constructor" ? context.classesById.get(String(row.classId)) : context.ownersByMemberId.get(id2);
       if (typeof owner?.name !== "string") continue;
       const sources2 = {};
       for (const key of ["getter", "setter", "action"]) {
         const code = row[key === "setter" ? "setterCode" : "code"];
         if (typeof code !== "string") continue;
         const unit = kind === "constructor" ? "constructor" : key === "action" ? "function" : key;
-        const body = kind === "constructor" ? constructorBodies.get(row.id) : bodies.get(bodyKey(owner.name, String(row.name), unit));
+        const body = kind === "constructor" ? constructorBodies.get(id2) : bodies.get(bodyKey(owner.name, String(row.name), unit));
         if (!body?.ir.source) continue;
         let text = sourceTexts.get(body.uri);
         if (text === void 0) {
@@ -180340,7 +180997,7 @@ function prepareCompleteNeoScriptBodyChanges(workspace, status, schema, options
         );
         if (source) sources2[key] = { code, source };
       }
-      context.scriptSources.set(`${kind}:${row.id}`, sources2);
+      context.scriptSources.set(`${kind}:${id2}`, sources2);
     }
   }
   status.scriptSources = context.scriptSources;
@@ -180348,25 +181005,21 @@ function prepareCompleteNeoScriptBodyChanges(workspace, status, schema, options
     status.changes.filter((change) => change.recordKind === "member").map((change) => [change.recordId, change])
   );
   const explicitlyChangedMemberIds = new Set(changesById.keys());
-  const movedMemberIds = new Set(
-    schema.members.filter((member) => {
-      const source = context.scriptSources.get(`member:${member.id}`);
-      return source && neoScriptSourceLocationsChanged(
-        neoScriptRecordSources(member),
-        source
-      );
-    }).map((member) => String(member.id))
-  );
+  const movedMemberIds = /* @__PURE__ */ new Set();
   const compiledMembers = schema.members.map((member) => {
-    if (!completeSweep && !explicitlyChangedMemberIds.has(String(member.id)) && !movedMemberIds.has(String(member.id))) {
-      return member;
-    }
-    if (!completeSweep && !explicitlyChangedMemberIds.has(String(member.id))) {
-      const base = workspace.state.records[recordStateKey("member", String(member.id))]?.data;
-      const sources2 = context.scriptSources.get(`member:${member.id}`);
-      if (isObjectRecord2(base) && sources2) {
-        const moved = remapNeoScriptRecord(base, sources2);
-        if (moved) return mergeCompiledNeoScriptBody(member, moved);
+    const id2 = String(member.id);
+    if (!completeSweep && !explicitlyChangedMemberIds.has(id2)) {
+      const sources2 = context.scriptSources.get(`member:${id2}`);
+      if (sources2 === void 0 || !neoScriptSourceLocationsChanged(
+        neoScriptRecordSources(member),
+        sources2
+      ))
+        return member;
+      movedMemberIds.add(id2);
+      const base = workspace.state.records[recordStateKey("member", id2)]?.data;
+      if (isObjectRecord2(base)) {
+        const remapped = remapNeoScriptRecord(base, sources2);
+        if (remapped) return mergeCompiledNeoScriptBody(member, remapped);
       }
     }
     if (member.kind === 10 /* NSProperty */) {
@@ -186712,6 +187365,7 @@ function validateRegistrationAction(action, allowRegistration) {
   }
 }
 function registerSpec(spec, document) {
+  document = withCompiledConstructionTypes(document, spec.action);
   validateRegistrationAction(spec.action, true);
   const root = {
     name: "",
@@ -186792,7 +187446,7 @@ function registerSpec(spec, document) {
     makeEvaluatorContext(document, interceptor),
     []
   );
-  return { spec, root, tests };
+  return { spec, root, tests, document };
 }
 function mockResponse(environment, mock, selected, call) {
   if (selected === null) {
@@ -187215,13 +187869,13 @@ function prepareTestEvaluator(document) {
 async function executeTestFile(spec, document, selected, timeoutMs, interrupted = () => false) {
   return executeRegisteredSpec(
     registerSpec(spec, document),
-    document,
     selected,
     timeoutMs,
     interrupted
   );
 }
-async function executeRegisteredSpec(registered, document, selected, timeoutMs, interrupted) {
+async function executeRegisteredSpec(registered, selected, timeoutMs, interrupted) {
+  const document = 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)) {
@@ -187564,7 +188218,6 @@ async function runTest(workspace, options, dependencies = {}) {
           entry.spec,
           await executeRegisteredSpec(
             entry,
-            rawDocument,
             selectedIds,
             timeoutMs,
             () => interrupted
@@ -187837,6 +188490,7 @@ var TEST_BUILD_CACHE_LIMIT_BYTES, ABANDONED_TEMP_MAX_AGE_MS, TEST_CANDIDATE_CACH
 var init_test = __esm({
   "src/commands/test.ts"() {
     "use strict";
+    init_compiled_construction_types();
     init_debug();
     init_neoscript_debug();
     init_strict_compile_error();
@@ -194819,7 +195473,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.76.2");
+    console.log("0.76.3");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {